Problem on TaskEither sequenceArray function for processing different types of return type

Question

I am working on functional programming using fp-ts library. Here is my code and my problem:

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

function getName(): TE.TaskEither<Error, String> {
  return TE.right('John Doe');
}

function getAge(): TE.TaskEither<Error, number> {
  return TE.right(40);
}

export function seqArrayTest(): TE.TaskEither<Error, string> {
  return pipe(
    TE.sequenceArray([
         getName(), 
         getAge(),
       ]),
    TE.chain(([name, age]) => {
      return TE.right(`Name: ${name}, Age: ${age}`);
    }),
  );
}

Here:

1. I have two functions: getName and getAge returning TaskEither with different value types.
2. I am calling them parallel using TE.sequenceArray.
3. After the computation, I am just chaining the response and returning another TaskEither.

During compilation, on TE.sequenceArray([getName(), getAge()]), it shows below error for getAge():

Type 'TaskEither<Error, number>' is not assignable to type 'TaskEither<Error, String>'. Type 'number' is not assignable to type 'String'.ts(2322)

But my understanding is: TE.sequenceArray should take an array of functions with different return types that are wrapped with TaskEither and it will return an array of responses sequentially.

Answer 1

@Souperman answer is correct in this context.TE.sequenceArray expects an array of TaskEithers with the same Right types.

If we want to process an array of TaskEither and the return type is different, then we may use sequenceT.

Here is the modified code:

import * as TE from "fp-ts/TaskEither";
import { pipe } from "fp-ts/lib/function";
import { sequenceT } from "fp-ts/Apply";

function getName(): TE.TaskEither<Error, String> {
  return TE.right("John Doe");
}

function getAge(): TE.TaskEither<Error, number> {
  return TE.right(30);
}

export function seqArrayTest(): TE.TaskEither<Error, string> {
  return pipe(
    sequenceT(TE.ApplyPar)(getName(), getAge()),
    TE.chain(([name, age]) => {
      return TE.right(`Name: ${name}, Age: ${age}`);
    }),
    TE.mapLeft((e) => e)
  );
}

Here, TE.ApplyPar: Runs computations in parallel. If we want sequential, then we may use TE.ApplySeq.

In TE.chain(([name, age]) parameter name is a string type, and age is a number type. And response sequence will based on the calling sequence.

Answer 2

Looking at the docs, TE.sequenceArray is expecting an array of TaskEithers with the same Right types.

export declare const sequenceArray: <A, E>(arr: readonly TaskEither<E, A>[]) =>
   TaskEither<E, readonly A[]>

You could specify that the array is of type Array<TE.TaskEither<Error, String | number>> explicitly and it should work as expected.

pipe(
  [getName(), getAge()] as Array<TE.TaskEither<Error, String | number>>,
  TE.sequenceArray,
  // ...
);

Unpacking those values in your call to TE.chain could theoretically be dangerous, however. You are not guaranteed from within the chain call that the array will have two elements. As written it will, but the typechecker cannot infer that. Do notation might be a better fit for these scenarios.