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

export const saveStagedBookmarksAsNewGroupToLocalStorage = (newStagedBookmarks: NonEmptyArray): TaskEither => {
	const stagedBookmarksGroups = pipe(
		getStagedBookmarksGroupsFromLocalStorage,
		TE.map(O.getOrElse((): Array => [])),
	);

	const newGroup = pipe(
		stagedBookmarksGroups,
		TE.map(flow(
			flow(A.map(group => group.id), createUuid, runIO),
			(id): StagedBookmarksGroup => ({
				id,
				time: new Date().getTime(),
				// Assign each bookmark a generated ID, and ensure they don't clash with
				// one another
				bookmarks: newStagedBookmarks.reduce>((acc, bm) => [...acc, {
					...bm,
					id: createUuid(acc.map(b => b.id))(),
				}], []),
			}),
		)),
	);

	return pipe(
		sequenceTTE(stagedBookmarksGroups, newGroup),

describe('composition', () => {
					const double = (a: number): number => a * 2;
					const quad = flow(
						double,
						double,
					);
					it('initial', () => {
						expect(remoteData.map(initial, quad)).toBe(
							pipe(
								initial,
								RD.map(double),
								RD.map(double),
							),
						);
					});
					it('pending', () => {
						expect(remoteData.map(pending, quad)).toBe(
							pipe(
								pending,

function xhr<a>(req: Request</a><a>): Observable&gt; {
  return ajax(toXHRRequest(req)).pipe(
    map(
      flow(
        toResponse(req),
        decodeWith(req.expect)
      )
    ),
    catchError((e: any): Observable&gt; =&gt; of(E.left(toHttpError(e))))
  )
}
</a>

msg$,
      )),
      map(([data, msg]) => ({ ...msg, data } as TransportMessage)),
    );

    const processEffects: ProcessOperator = flow(
      publish(msg$ => zip(
        combinedEffects(msg$.pipe(map(m => m.data)), ctx).pipe(
          catchError(toUnhandledErrorEvent),
        ),
        msg$,
      )),
      map(([data, msg]) => ({ ...msg, data } as TransportMessage)),
    );

    const processOutput: ProcessOperator = flow(
      publish(msg$ => zip(
        outputLogger$(msg$.pipe(map(m => ({ event: m.data, initiator: m }))), ctx).pipe(
          catchError(toUnhandledErrorEvent),
        ),
        msg$,
      )),
      map(([data, msg]) => ({ ...msg, data } as TransportMessage)),
      publish(msg$ => zip(
        output$(msg$.pipe(map(m => ({ event: m.data, initiator: m }))), ctx).pipe(
          catchError(toUnhandledErrorEvent),
        ),
        msg$,
      )),
      map(([data, msg]) => ({ ...msg, data } as TransportMessage)),
    );

export function bimap(io: WaveR, leftMap: FunctionN<[E1], E2>, rightMap: FunctionN<[A], B>): WaveR {
  return foldExit(io,
    (cause) => cause._tag === exit.ExitTag.Raise ? raiseError(leftMap(cause.error)) : completed(cause),
    flow(rightMap, pure)
  );
}

export function mapError(io: Wave, f: FunctionN<[E1], E2>): Wave {
  return chainError(io, flow(f, raiseError));
}

Vault.config(vaultConfiguration)
    await Vault.mountAuthTune()
  } catch (e) {
    logger.fatal(e, 'Error with Vault')
    return
  }

  const encryptWithKey = encrypt(configuration.privateKeyEncryptionKey)
  const decryptWithKey = decrypt(configuration.privateKeyEncryptionKey)

  const decryptBackwardsCompatible = (plaintext: string) =>
    plaintext.startsWith('vault')
      ? Vault.decrypt(plaintext)
      : decryptWithKey(plaintext)

  const encryptApiToken = flow(tokenObjectToToken, encryptWithKey, tokenToTokenObject)

  const decryptApiTokens = async (tokens: ReadonlyArray): Promise> =>
    Promise.all(tokens.map(tokenObjectToToken).map(decryptBackwardsCompatible)).then(tokensToTokenObjects)

  const mongoClient = await MongoClient.connect(configuration.mongodbUrl)
  const dbConnection = await mongoClient.db()
  const accountCollection = dbConnection.collection('accounts')

  const accounts = await accountCollection.find({}).toArray()

  logger.info(
    { count: accounts.length, emails: accounts.map(_ => _.email) },
    'Loaded all accounts.',
  )

  const decryptedAccounts = await Promise.all(accounts.map(async account => {

const mapLeft_: EffectMonad["mapLeft"] = (io, f) =>
  chainError_(io, flow(f, raiseError));

export function map(
  sink: Sink,
  f: FunctionN<[B], C>
): Sink {
  return {
    ...sink,
    extract: flow(sink.extract, T.map(f))
  };
}

export function map(base: Wave, f: FunctionN<[A], B>): Wave {
  return chain(base, flow(f, pure));
}