TaskEither piping

[nikkonrom]

I have 2 async functions with the following signatures:

export type SmaId = string;

public async resolveSmaIds(
  explorationRequest: ExplorationRequest
): Promise<Either<ExternalExplorationProviderUnavailable, SmaId[]>> {};

public async getAllByIds(
  smaIds: SmaId[]
): TaskEither<SmasNotFound, Sma[]> {};

And I need to combine these functions to an async pipeline that returns Sma[] if both functions return the right result, or one of the possible Errors: ExternalExplorationProviderUnavailable if the first function fails, or SmasNotFound if it does the second one.

I tried to achieve this with the following code:

import { pipe } from 'fp-ts/lib/function';
import { taskEither } from 'fp-ts';
const pipeline = pipe(
  explorationRequest,
  this.resolveSmaIdsProvider.resolveSmaIds,
  taskEither.chain(this.smaRepository.getAllByIds)
);

I am getting the following error from the TS compiler:
TS2345: Argument of type '(ma: TaskEither<SmasNotFound, string[]>) => TaskEither<SmasNotFound, Sma[]>' is not assignable to parameter of type '(b: Promise<Either<ExternalExplorationProviderUnavailable, string[]>>) => TaskEither<SmasNotFound, Sma[]>'. Types of parameters 'ma' and 'b' are incompatible. Type 'Promise<Either<ExternalExplorationProviderUnavailable, string[]>>' is not assignable to type TaskEither<SmasNotFound, string[]>'. Type 'Promise<Either<ExternalExplorationProviderUnavailable, string[]>>' provides no match for the signature '(): Promise<Either<SmasNotFound, string[]>>'.

How do I should resolve this error? Any help is appreciated.

[0x706b]

The signature of TaskEither<E, A> is () => Promise<Either<E, A>> while the return type of resolveSmaIds is Promise<Either<E, A>>. In other words, TaskEither is a thunked Promise while resolveSmaIds returns a bare Promise. Also, since the Left types are different between the functions, TaskEither.chainW is needed to widen the type on the left.

If you can rewrite resolveSmaIds to return a TaskEither, that would be the “idiomatic” way to do it:

import { pipe } from 'fp-ts/function'
import * as TE from 'fp-ts/TaskEither'

declare function resolveSmaIds(
  explorationRequest: ExplorationRequest
): TE.TaskEither<ExternalExplorationProviderUnavailable, SmaId[]>

declare function getAllByIds(smaIds: SmaId[]): TE.TaskEither<SmasNotFound, Sma[]>

declare const explorationRequest: ExplorationRequest

pipe(
  explorationRequest,
  resolveSmaIds,
  TE.chainW(getAllByIds)
)

Otherwise you could rewrite your pipe like this:

import * as E from 'fp-ts/Either'
import { pipe } from 'fp-ts/function'
import * as TE from 'fp-ts/TaskEither'

declare function resolveSmaIds(
  explorationRequest: ExplorationRequest
): Promise<E.Either<ExternalExplorationProviderUnavailable, SmaId[]>>

declare function getAllByIds(smaIds: SmaId[]): TE.TaskEither<SmasNotFound, Sma[]>

declare const explorationRequest: ExplorationRequest

pipe(
  () => resolveSmaIds(explorationRequest), // <--
  TE.chainW(getAllByIds)
)

[nikkonrom]

Thanks!

[centuriononon]

Thank you for the answer! By the way, do you how to avoid returning TE.TaskEither for getAllByIds? As far as I understand, the function may not throw any errors and be synchronous, but the chainW decorator requires a TaskEither object as the return value.

[samhh]

@centuriononon You may want something like TE.chainTaskK.