How to use the fp-ts/lib/Option.fold function in fp-ts

if (httpOperation.method === 'head') {
        logger.info(`Responding with an empty body to a HEAD request.`);

        return E.right({
          code: response.code,
          headers: response.headers || [],
        });
      }

      if (mediaTypes) {
        // a user provided mediaType
        const httpContent = hasContents(response) ? findBestHttpContentByMediaType(response, mediaTypes) : O.none;

        return pipe(
          httpContent,
          O.fold(
            () =>
              pipe(
                findEmptyResponse(response, headers || [], mediaTypes),
                O.map(payloadlessResponse => {
                  logger.info(`${outputNoContentFoundMessage(mediaTypes)}. Sending an empty response.`);

                  return payloadlessResponse;
                }),
                E.fromOption(() => {
                  logger.warn(outputNoContentFoundMessage(mediaTypes));

                  return ProblemJsonError.fromTemplate(NOT_ACCEPTABLE, `Unable to find content for ${mediaTypes}`);
                })
              ),
            content => {
              logger.success(`Found a compatible content for ${mediaTypes}`);

T.chainTap(opt =>
          pipe(
            opt,
            o.fold(
              // Confirm we have seen the last element
              () => alatch.done(none),
              () => T.unit // just keep going
            )
          )
        )

T.chainTap(opt =>
      pipe(
        opt,
        o.fold(
          // Confirm we have seen the last element by closing the breaker so subsequent reads see it
          constant(breaker.done(none)),
          // do nothing to the breaker if we got an element
          constant(T.unit)
        )
      )
    )

it("pull after multiple offers is the last", () => {
    const queue = empty()
      .offer(42)
      .offer(43)
      .offer(44);
    const result = queue.pull();
    p.pipe(
      result,
      O.fold(
        () => { throw new Error("expected some"); },
        (tuple) => {
          expect(tuple[0]).to.equal(44);
          expect(tuple[1].size()).to.equal(2);
        }
      )
    );
  });

const activateOrShowDialogWithConfig = Action.activateOrShowDialog(
    workspaceRoot
  );

  context.subscriptions.push(
    vscode.commands.registerCommand(
      Command.SELECT_ENV_DIALOG,
      selectEnvCommandHandler(workspaceRoot, config)
    )
  );

  return activateOrShowDialogWithConfig(maybeNixEnvConfig)
    .map(mapNullable(() => maybeNixEnvConfig))
    .map(flatten)
    .map(
      fold(
        () => hideStatus("unknown"),
        envConfigPath => envConfigPath.split("/").reverse()[0]
      )
    )
    .fork(
      handleError,
      showStatusWithEnv(Label.SELECTED_ENV, some(Command.SELECT_ENV_DIALOG))
    );
}

const StagedGroupBookmarksList: FC = () => {
	const stagedGroupId = useSelector(state => state.bookmarks.stagedBookmarksGroupEditId);
	const bookmarksMaybe = useSelector(getStagedGroupToEditWeightedBookmarks);
	const bookmarks = O.getOrElse(() => [] as Array)(bookmarksMaybe);
	const dispatch = useDispatch();

	const handleOpenBookmark = (bmId: number): void => {
		dispatch(openBookmarkAndExit(bmId, stagedGroupId));
	};

	const handleEditBookmark = (bmId: number): void => {
		dispatch(setStagedBookmarksGroupBookmarkEditId(O.some(bmId)));
		dispatch(setPage(Page.EditStagedBookmark));
	};

	const [handleDeleteBookmark, handleDeleteGroup, handlePublish] = pipe(stagedGroupId, O.fold(
		() => [constVoid, constVoid, constVoid],
		grpId => [
			(bmId: number): void => {
				dispatch(deleteStagedBookmarksGroupBookmarkOrEntireGroup(grpId, bmId));
			},
			(): void => {
				dispatch(deleteStagedBookmarksGroup(grpId));
				dispatch(setPage(Page.StagedGroupsList));
			},
			(): void => {
				dispatch(addAllBookmarksFromStagedGroup(grpId));
				dispatch(setPage(Page.StagedGroupsList));
			},
		],
	));

function printDescription(description: O.Option): string {
  return pipe(
    description,
    O.fold(
      () => '',
      s => CRLF + s
    )
  )
}

reduce({}, (headers, param) =>
          pipe(
            param,
            generateHttpParam,
            O.fold(
              () => headers,
              value => ({ ...headers, [param.name]: value })
            )
          )
        )

issue(pattern: Pattern, colour?: string): O.Option {
        return pipe(
            this.inquireByPattern(pattern),
            O.fold(
                () => O.some(this.setDecoration(this.createDecoration(pattern, colour))),
                () => O.none
            )
        );
    }

function toXHRRequest<a>(req: Request</a><a>): AjaxRequest {
  return {
    ...req,
    timeout: pipe(
      req.timeout,
      O.fold(() =&gt; 0, identity)
    ),
    async: true,
    responseType: 'json'
  }
}
</a>