How to filter task either based on left type

[Hurtak]

I have array of TE

type Items = TE.TaskEither<Error1 | Error2, Data>[]

And I would like to filter the array to be like TE.TaskEither<Error1, Data>[]

What is the easiest way to do this?

At the moment I do

• Convert the right items to O.some
• Run TE.orElse on the array where I match the Error2 and convert it to O.none, and keep the rest as it was with TE.left(error)
• Then do some matching on the O.Option

This works but it seems clunky, is there some cleaner way?

[xuanduc987]

Hm, I don't think you can filter Task/TaskEither array.

A TaskEither<E, A> is alias for () => Promise<Either<E, A>>, so without running the function, you can't get the value of type Either<E, A> to filter on.

The best you could do, I think is using Task. sequenceArray to get Task<Either<Error1 | Error2, Data>[]>, then call Task.map(Array.filter(e => Either.isRight(e) || isError1(e.left))) to get Task<Either<Error1, Data>[]>

[gcanti]

A TaskEither<E, A> is alias for () => Either<E, A>, so without running the function, you can't get the value of type Either<E, A> to filter on.

I agree.

p.s.

You can sequence + filter in one step using the Witherable instance of ReadonlyArray

import * as E from 'fp-ts/Either'
import { pipe } from 'fp-ts/function'
import { Separated } from 'fp-ts/lib/Separated'
import * as O from 'fp-ts/Option'
import * as RA from 'fp-ts/ReadonlyArray'
import * as T from 'fp-ts/Task'
import * as TE from 'fp-ts/TaskEither'

export const solution = <E1, E2, A>(
  tasks: ReadonlyArray<TE.TaskEither<E1 | E2, A>>,
  is: (e: E1 | E2) => e is E1
): T.Task<readonly E.Either<E1, A>[]> => {
  return pipe(
    tasks,
    RA.wither(T.ApplicativePar)(
      T.map(
        E.match(
          (e) => (is(e) ? O.some(E.left(e)) : O.none),
          (a) => O.some(E.right(a))
        )
      )
    )
  )
}

or

export const solution2 = <E1, E2, A>(
  tasks: ReadonlyArray<TE.TaskEither<E1 | E2, A>>,
  is: (e: E1 | E2) => e is E1
): T.Task<Separated<readonly E2[], readonly E.Either<E1, A>[]>> => {
  return pipe(
    tasks,
    RA.wilt(T.ApplicativePar)(
      T.map(
        E.match(
          (e) => (is(e) ? E.right(E.left(e)) : E.left(e)),
          (a) => E.right(E.right(a))
        )
      )
    )
  )
}