title | nav_order | parent |
---|---|---|
TaskEither.ts |
105 |
Modules |
interface TaskEither<E, A> extends Task<Either<E, A>> {}
TaskEither<E, A>
represents an asynchronous computation that either yields a value of type A
or fails yielding an
error of type E
. If you want to represent an asynchronous computation that never fails, please see Task
.
Added in v2.0.0
- Alt
- Apply
- Bifunctor
- Functor
- Monad
- MonadTask
- Pointed
- combinators
- apFirst
- apSecond
- chainEitherK
- chainEitherKW
- chainFirst
- chainFirstIOK
- chainFirstTaskK
- chainFirstW
- chainIOEitherK
- chainIOEitherKW
- chainIOK
- chainOptionK
- chainTaskK
- chainTaskOptionK
- filterOrElse
- filterOrElseW
- flap
- flatten
- flattenW
- fromEitherK
- fromIOEitherK
- fromIOK
- fromOptionK
- fromTaskK
- fromTaskOptionK
- orElse
- orElseFirst
- orElseFirstW
- orElseW
- orLeft
- swap
- constructors
- destructors
- instances
- Alt
- ApplicativePar
- ApplicativeSeq
- ApplyPar
- ApplySeq
- Bifunctor
- Chain
- FromEither
- FromIO
- FromTask
- Functor
- Monad
- MonadIO
- MonadTask
- MonadThrow
- Pointed
- URI
- URI (type alias)
- getAltTaskValidation
- getApplicativeTaskValidation
- getCompactable
- getFilterable
getApplyMonoidgetApplySemigroupgetSemigroupgetTaskValidationtaskEitherSeqtaskEither
- interop
- model
- natural transformations
- utils
- ApT
- Do
- apS
- apSW
- bind
- bindTo
- bindW
- bracket
- sequenceArray
- sequenceSeqArray
- taskify
- traverseArray
- traverseArrayWithIndex
- traverseReadonlyArrayWithIndex
- traverseReadonlyArrayWithIndexSeq
- traverseReadonlyNonEmptyArrayWithIndex
- traverseReadonlyNonEmptyArrayWithIndexSeq
- traverseSeqArray
- traverseSeqArrayWithIndex
Identifies an associative operation on a type constructor. It is similar to Semigroup
, except that it applies to
types of kind * -> *
.
In case of TaskEither
returns fa
if is a Right
or the value returned by that
otherwise.
See also orElse.
Signature
export declare const alt: <E, A>(that: Lazy<TaskEither<E, A>>) => (fa: TaskEither<E, A>) => TaskEither<E, A>
Example
import * as E from 'fp-ts/Either'
import { pipe } from 'fp-ts/function'
import * as TE from 'fp-ts/TaskEither'
async function test() {
assert.deepStrictEqual(
await pipe(
TE.right(1),
TE.alt(() => TE.right(2))
)(),
E.right(1)
)
assert.deepStrictEqual(
await pipe(
TE.left('a'),
TE.alt(() => TE.right(2))
)(),
E.right(2)
)
assert.deepStrictEqual(
await pipe(
TE.left('a'),
TE.alt(() => TE.left('b'))
)(),
E.left('b')
)
}
test()
Added in v2.0.0
Less strict version of alt
.
Signature
export declare const altW: <E2, B>(
that: Lazy<TaskEither<E2, B>>
) => <E1, A>(fa: TaskEither<E1, A>) => TaskEither<E2, B | A>
Added in v2.9.0
Apply a function to an argument under a type constructor.
Signature
export declare const ap: <E, A>(fa: TaskEither<E, A>) => <B>(fab: TaskEither<E, (a: A) => B>) => TaskEither<E, B>
Added in v2.0.0
Less strict version of ap
.
Signature
export declare const apW: <E2, A>(
fa: TaskEither<E2, A>
) => <E1, B>(fab: TaskEither<E1, (a: A) => B>) => TaskEither<E2 | E1, B>
Added in v2.8.0
Map a pair of functions over the two type arguments of the bifunctor.
Signature
export declare const bimap: <E, G, A, B>(f: (e: E) => G, g: (a: A) => B) => (fa: TaskEither<E, A>) => TaskEither<G, B>
Added in v2.0.0
Map a function over the first type argument of a bifunctor.
Signature
export declare const mapLeft: <E, G>(f: (e: E) => G) => <A>(fa: TaskEither<E, A>) => TaskEither<G, A>
Added in v2.0.0
map
can be used to turn functions (a: A) => B
into functions (fa: F<A>) => F<B>
whose argument and return types
use the type constructor F
to represent some computational context.
Signature
export declare const map: <A, B>(f: (a: A) => B) => <E>(fa: TaskEither<E, A>) => TaskEither<E, B>
Added in v2.0.0
Composes computations in sequence, using the return value of one computation to determine the next computation.
Signature
export declare const chain: <E, A, B>(f: (a: A) => TaskEither<E, B>) => (ma: TaskEither<E, A>) => TaskEither<E, B>
Added in v2.0.0
Less strict version of chain
.
Signature
export declare const chainW: <E2, A, B>(
f: (a: A) => TaskEither<E2, B>
) => <E1>(ma: TaskEither<E1, A>) => TaskEither<E2 | E1, B>
Added in v2.6.0
Signature
export declare const throwError: <E, A>(e: E) => TaskEither<E, A>
Added in v2.7.0
Signature
export declare const of: <E = never, A = never>(a: A) => TaskEither<E, A>
Added in v2.0.0
Combine two effectful actions, keeping only the result of the first.
Derivable from Apply
.
Signature
export declare const apFirst: <E, B>(second: TaskEither<E, B>) => <A>(first: TaskEither<E, A>) => TaskEither<E, A>
Added in v2.0.0
Combine two effectful actions, keeping only the result of the second.
Derivable from Apply
.
Signature
export declare const apSecond: <E, B>(second: TaskEither<E, B>) => <A>(first: TaskEither<E, A>) => TaskEither<E, B>
Added in v2.0.0
Signature
export declare const chainEitherK: <E, A, B>(f: (a: A) => E.Either<E, B>) => (ma: TaskEither<E, A>) => TaskEither<E, B>
Added in v2.4.0
Less strict version of chainEitherK
.
Signature
export declare const chainEitherKW: <E2, A, B>(
f: (a: A) => E.Either<E2, B>
) => <E1>(ma: TaskEither<E1, A>) => TaskEither<E2 | E1, B>
Added in v2.6.1
Composes computations in sequence, using the return value of one computation to determine the next computation and keeping only the result of the first.
Derivable from Chain
.
Signature
export declare const chainFirst: <E, A, B>(f: (a: A) => TaskEither<E, B>) => (ma: TaskEither<E, A>) => TaskEither<E, A>
Added in v2.0.0
Signature
export declare const chainFirstIOK: <A, B>(f: (a: A) => IO<B>) => <E>(first: TaskEither<E, A>) => TaskEither<E, A>
Added in v2.10.0
Signature
export declare const chainFirstTaskK: <A, B>(f: (a: A) => T.Task<B>) => <E>(first: TaskEither<E, A>) => TaskEither<E, A>
Added in v2.10.0
Less strict version of chainFirst
.
Derivable from Chain
.
Signature
export declare const chainFirstW: <E2, A, B>(
f: (a: A) => TaskEither<E2, B>
) => <E1>(ma: TaskEither<E1, A>) => TaskEither<E2 | E1, A>
Added in v2.8.0
Signature
export declare const chainIOEitherK: <E, A, B>(
f: (a: A) => IOEither<E, B>
) => (ma: TaskEither<E, A>) => TaskEither<E, B>
Added in v2.4.0
Less strict version of chainIOEitherK
.
Signature
export declare const chainIOEitherKW: <E2, A, B>(
f: (a: A) => IOEither<E2, B>
) => <E1>(ma: TaskEither<E1, A>) => TaskEither<E2 | E1, B>
Added in v2.6.1
Signature
export declare const chainIOK: <A, B>(f: (a: A) => IO<B>) => <E>(first: TaskEither<E, A>) => TaskEither<E, B>
Added in v2.10.0
Signature
export declare const chainOptionK: <E>(
onNone: Lazy<E>
) => <A, B>(f: (a: A) => Option<B>) => (ma: TaskEither<E, A>) => TaskEither<E, B>
Added in v2.10.0
Signature
export declare const chainTaskK: <A, B>(f: (a: A) => T.Task<B>) => <E>(first: TaskEither<E, A>) => TaskEither<E, B>
Added in v2.10.0
Signature
export declare const chainTaskOptionK: <E>(
onNone: Lazy<E>
) => <A, B>(f: (a: A) => TaskOption<B>) => (ma: TaskEither<E, A>) => TaskEither<E, B>
Added in v2.11.0
Signature
export declare const filterOrElse: {
<E, A, B extends A>(refinement: Refinement<A, B>, onFalse: (a: A) => E): (ma: TaskEither<E, A>) => TaskEither<E, B>
<E, A>(predicate: Predicate<A>, onFalse: (a: A) => E): <B extends A>(mb: TaskEither<E, B>) => TaskEither<E, B>
<E, A>(predicate: Predicate<A>, onFalse: (a: A) => E): (ma: TaskEither<E, A>) => TaskEither<E, A>
}
Added in v2.0.0
Less strict version of filterOrElse
.
Signature
export declare const filterOrElseW: {
<A, B extends A, E2>(refinement: Refinement<A, B>, onFalse: (a: A) => E2): <E1>(
ma: TaskEither<E1, A>
) => TaskEither<E2 | E1, B>
<A, E2>(predicate: Predicate<A>, onFalse: (a: A) => E2): <E1, B extends A>(
mb: TaskEither<E1, B>
) => TaskEither<E2 | E1, B>
<A, E2>(predicate: Predicate<A>, onFalse: (a: A) => E2): <E1>(ma: TaskEither<E1, A>) => TaskEither<E2 | E1, A>
}
Added in v2.9.0
Derivable from Functor
.
Signature
export declare const flap: <A>(a: A) => <E, B>(fab: TaskEither<E, (a: A) => B>) => TaskEither<E, B>
Added in v2.10.0
Derivable from Chain
.
Signature
export declare const flatten: <E, A>(mma: TaskEither<E, TaskEither<E, A>>) => TaskEither<E, A>
Added in v2.0.0
Less strict version of flatten
.
Signature
export declare const flattenW: <E1, E2, A>(mma: TaskEither<E1, TaskEither<E2, A>>) => TaskEither<E1 | E2, A>
Added in v2.11.0
Signature
export declare const fromEitherK: <E, A extends readonly unknown[], B>(
f: (...a: A) => E.Either<E, B>
) => (...a: A) => TaskEither<E, B>
Added in v2.4.0
Signature
export declare const fromIOEitherK: <E, A extends readonly unknown[], B>(
f: (...a: A) => IOEither<E, B>
) => (...a: A) => TaskEither<E, B>
Added in v2.4.0
Signature
export declare const fromIOK: <A, B>(f: (...a: A) => IO<B>) => <E>(...a: A) => TaskEither<E, B>
Added in v2.10.0
Signature
export declare const fromOptionK: <E>(
onNone: Lazy<E>
) => <A, B>(f: (...a: A) => Option<B>) => (...a: A) => TaskEither<E, B>
Added in v2.10.0
Signature
export declare const fromTaskK: <A, B>(f: (...a: A) => T.Task<B>) => <E>(...a: A) => TaskEither<E, B>
Added in v2.10.0
Signature
export declare const fromTaskOptionK: <E>(
onNone: Lazy<E>
) => <A extends readonly unknown[], B>(f: (...a: A) => TaskOption<B>) => (...a: A) => TaskEither<E, B>
Added in v2.11.0
Returns ma
if is a Right
or the value returned by onLeft
otherwise.
See also alt.
Signature
export declare const orElse: <E1, A, E2>(
onLeft: (e: E1) => TaskEither<E2, A>
) => (ma: TaskEither<E1, A>) => TaskEither<E2, A>
Example
import * as E from 'fp-ts/Either'
import { pipe } from 'fp-ts/function'
import * as TE from 'fp-ts/TaskEither'
async function test() {
const errorHandler = TE.orElse((error: string) => TE.right(`recovering from ${error}...`))
assert.deepStrictEqual(await pipe(TE.right('ok'), errorHandler)(), E.right('ok'))
assert.deepStrictEqual(await pipe(TE.left('ko'), errorHandler)(), E.right('recovering from ko...'))
}
test()
Added in v2.0.0
Signature
export declare const orElseFirst: <E, B>(
onLeft: (e: E) => TaskEither<E, B>
) => <A>(ma: TaskEither<E, A>) => TaskEither<E, A>
Added in v2.11.0
Signature
export declare const orElseFirstW: <E1, E2, B>(
onLeft: (e: E1) => TaskEither<E2, B>
) => <A>(ma: TaskEither<E1, A>) => TaskEither<E1 | E2, A>
Added in v2.11.0
Less strict version of orElse
.
Signature
export declare const orElseW: <E1, E2, B>(
onLeft: (e: E1) => TaskEither<E2, B>
) => <A>(ma: TaskEither<E1, A>) => TaskEither<E2, B | A>
Added in v2.10.0
Signature
export declare const orLeft: <E1, E2>(onLeft: (e: E1) => T.Task<E2>) => <A>(fa: TaskEither<E1, A>) => TaskEither<E2, A>
Added in v2.11.0
Signature
export declare const swap: <E, A>(ma: TaskEither<E, A>) => TaskEither<A, E>
Added in v2.0.0
Signature
export declare const fromPredicate: {
<E, A, B extends A>(refinement: Refinement<A, B>, onFalse: (a: A) => E): (a: A) => TaskEither<E, B>
<E, A>(predicate: Predicate<A>, onFalse: (a: A) => E): <B>(b: B) => TaskEither<E, B>
<E, A>(predicate: Predicate<A>, onFalse: (a: A) => E): (a: A) => TaskEither<E, A>
}
Added in v2.0.0
Signature
export declare const left: <E = never, A = never>(e: E) => TaskEither<E, A>
Added in v2.0.0
Signature
export declare const leftIO: <E = never, A = never>(me: IO<E>) => TaskEither<E, A>
Added in v2.0.0
Signature
export declare const leftTask: <E = never, A = never>(me: T.Task<E>) => TaskEither<E, A>
Added in v2.0.0
Signature
export declare const right: <E = never, A = never>(a: A) => TaskEither<E, A>
Added in v2.0.0
Signature
export declare const rightIO: <E = never, A = never>(ma: IO<A>) => TaskEither<E, A>
Added in v2.0.0
Signature
export declare const rightTask: <E = never, A = never>(ma: T.Task<A>) => TaskEither<E, A>
Added in v2.0.0
Alias of matchE
.
Signature
export declare const fold: <E, A, B>(
onLeft: (e: E) => T.Task<B>,
onRight: (a: A) => T.Task<B>
) => (ma: TaskEither<E, A>) => T.Task<B>
Added in v2.0.0
Alias of matchEW
.
Signature
export declare const foldW: <E, B, A, C>(
onLeft: (e: E) => T.Task<B>,
onRight: (a: A) => T.Task<C>
) => (ma: TaskEither<E, A>) => T.Task<B | C>
Added in v2.10.0
Signature
export declare const getOrElse: <E, A>(onLeft: (e: E) => T.Task<A>) => (ma: TaskEither<E, A>) => T.Task<A>
Added in v2.0.0
Less strict version of getOrElse
.
Signature
export declare const getOrElseW: <E, B>(onLeft: (e: E) => T.Task<B>) => <A>(ma: TaskEither<E, A>) => T.Task<B | A>
Added in v2.6.0
Signature
export declare const match: <E, B, A>(onLeft: (e: E) => B, onRight: (a: A) => B) => (ma: TaskEither<E, A>) => T.Task<B>
Added in v2.10.0
Signature
export declare const matchE: <E, A, B>(
onLeft: (e: E) => T.Task<B>,
onRight: (a: A) => T.Task<B>
) => (ma: TaskEither<E, A>) => T.Task<B>
Added in v2.10.0
Less strict version of matchE
.
Signature
export declare const matchEW: <E, B, A, C>(
onLeft: (e: E) => T.Task<B>,
onRight: (a: A) => T.Task<C>
) => (ma: TaskEither<E, A>) => T.Task<B | C>
Added in v2.10.0
Less strict version of match
.
Signature
export declare const matchW: <E, B, A, C>(
onLeft: (e: E) => B,
onRight: (a: A) => C
) => (ma: TaskEither<E, A>) => T.Task<B | C>
Added in v2.10.0
Signature
export declare const Alt: Alt2<'TaskEither'>
Added in v2.7.0
Signature
export declare const ApplicativePar: Applicative2<'TaskEither'>
Added in v2.7.0
Signature
export declare const ApplicativeSeq: Applicative2<'TaskEither'>
Added in v2.7.0
Signature
export declare const ApplyPar: Apply2<'TaskEither'>
Added in v2.10.0
Signature
export declare const ApplySeq: Apply2<'TaskEither'>
Added in v2.10.0
Signature
export declare const Bifunctor: Bifunctor2<'TaskEither'>
Added in v2.7.0
Signature
export declare const Chain: Chain2<'TaskEither'>
Added in v2.10.0
Signature
export declare const FromEither: FromEither2<'TaskEither'>
Added in v2.10.0
Signature
export declare const FromIO: FromIO2<'TaskEither'>
Added in v2.10.0
Signature
export declare const FromTask: FromTask2<'TaskEither'>
Added in v2.10.0
Signature
export declare const Functor: Functor2<'TaskEither'>
Added in v2.7.0
Signature
export declare const Monad: Monad2<'TaskEither'>
Added in v2.10.0
Signature
export declare const MonadIO: MonadIO2<'TaskEither'>
Added in v2.10.0
Signature
export declare const MonadTask: MonadTask2<'TaskEither'>
Added in v2.10.0
Signature
export declare const MonadThrow: MonadThrow2<'TaskEither'>
Added in v2.10.0
Signature
export declare const Pointed: Pointed2<'TaskEither'>
Added in v2.10.0
Signature
export declare const URI: 'TaskEither'
Added in v2.0.0
Signature
export type URI = typeof URI
Added in v2.0.0
Signature
export declare function getAltTaskValidation<E>(S: Semigroup<E>): Alt2C<URI, E>
Added in v2.7.0
Signature
export declare function getApplicativeTaskValidation<E>(A: Apply1<T.URI>, S: Semigroup<E>): Applicative2C<URI, E>
Added in v2.7.0
Signature
export declare const getCompactable: <E>(M: Monoid<E>) => Compactable2C<'TaskEither', E>
Added in v2.10.0
Signature
export declare function getFilterable<E>(M: Monoid<E>): Filterable2C<URI, E>
Added in v2.1.0
Use getApplicativeMonoid
instead.
Signature
export declare const getApplyMonoid: <E, A>(M: Monoid<A>) => Monoid<TaskEither<E, A>>
Added in v2.0.0
Use getApplySemigroup
instead.
Signature
export declare const getApplySemigroup: <E, A>(S: Semigroup<A>) => Semigroup<TaskEither<E, A>>
Added in v2.0.0
Use getApplySemigroup
instead.
Signature
export declare const getSemigroup: <E, A>(S: Semigroup<A>) => Semigroup<TaskEither<E, A>>
Added in v2.0.0
Use getApplicativeTaskValidation
and getAltTaskValidation
instead.
Signature
export declare function getTaskValidation<E>(
SE: Semigroup<E>
): Monad2C<URI, E> & Bifunctor2<URI> & Alt2C<URI, E> & MonadTask2C<URI, E> & MonadThrow2C<URI, E>
Added in v2.0.0
Use small, specific instances instead.
Signature
export declare const taskEitherSeq: Monad2<'TaskEither'> &
Bifunctor2<'TaskEither'> &
Alt2<'TaskEither'> &
MonadTask2<'TaskEither'> &
MonadThrow2<'TaskEither'>
Added in v2.0.0
Use small, specific instances instead.
Signature
export declare const taskEither: Monad2<'TaskEither'> &
Bifunctor2<'TaskEither'> &
Alt2<'TaskEither'> &
MonadTask2<'TaskEither'> &
MonadThrow2<'TaskEither'>
Added in v2.0.0
Signature
export declare const chainNullableK: <E>(
e: E
) => <A, B>(f: (a: A) => B | null | undefined) => (ma: TaskEither<E, A>) => TaskEither<E, NonNullable<B>>
Added in v2.12.0
Signature
export declare const fromNullable: <E>(e: E) => <A>(a: A) => TaskEither<E, NonNullable<A>>
Added in v2.12.0
Signature
export declare const fromNullableK: <E>(
e: E
) => <A extends readonly unknown[], B>(
f: (...a: A) => B | null | undefined
) => (...a: A) => TaskEither<E, NonNullable<B>>
Added in v2.12.0
Signature
export declare const toUnion: <E, A>(fa: TaskEither<E, A>) => T.Task<E | A>
Added in v2.10.0
Transforms a Promise
that may reject to a Promise
that never rejects and returns an Either
instead.
Note: f
should never throw
errors, they are not caught.
See also tryCatchK
.
Signature
export declare const tryCatch: <E, A>(f: Lazy<Promise<A>>, onRejected: (reason: unknown) => E) => TaskEither<E, A>
Example
import { left, right } from 'fp-ts/Either'
import { tryCatch } from 'fp-ts/TaskEither'
tryCatch(() => Promise.resolve(1), String)().then((result) => {
assert.deepStrictEqual(result, right(1))
})
tryCatch(() => Promise.reject('error'), String)().then((result) => {
assert.deepStrictEqual(result, left('error'))
})
Added in v2.0.0
Converts a function returning a Promise
to one returning a TaskEither
.
Signature
export declare const tryCatchK: <E, A extends readonly unknown[], B>(
f: (...a: A) => Promise<B>,
onRejected: (reason: unknown) => E
) => (...a: A) => TaskEither<E, B>
Added in v2.5.0
Signature
export interface TaskEither<E, A> extends Task<Either<E, A>> {}
Added in v2.0.0
Signature
export declare const fromEither: NaturalTransformation22<'Either', 'TaskEither'>
Added in v2.0.0
Signature
export declare const fromIO: NaturalTransformation12<'IO', 'TaskEither'>
Added in v2.7.0
Signature
export declare const fromIOEither: NaturalTransformation22<'IOEither', 'TaskEither'>
Added in v2.0.0
Signature
export declare const fromOption: <E>(onNone: Lazy<E>) => NaturalTransformation12C<'Option', 'TaskEither', E>
Added in v2.0.0
Signature
export declare const fromTask: NaturalTransformation12<'Task', 'TaskEither'>
Added in v2.7.0
Signature
export declare const fromTaskOption: <E>(onNone: Lazy<E>) => NaturalTransformation12C<'TaskOption', 'TaskEither', E>
Added in v2.11.0
Signature
export declare const ApT: TaskEither<never, readonly []>
Added in v2.11.0
Signature
export declare const Do: TaskEither<never, {}>
Added in v2.9.0
Signature
export declare const apS: <N, A, E, B>(
name: Exclude<N, keyof A>,
fb: TaskEither<E, B>
) => (fa: TaskEither<E, A>) => TaskEither<E, { readonly [K in N | keyof A]: K extends keyof A ? A[K] : B }>
Added in v2.8.0
Signature
export declare const apSW: <A, N extends string, E2, B>(
name: Exclude<N, keyof A>,
fb: TaskEither<E2, B>
) => <E1>(fa: TaskEither<E1, A>) => TaskEither<E2 | E1, { readonly [K in N | keyof A]: K extends keyof A ? A[K] : B }>
Added in v2.8.0
Signature
export declare const bind: <N, A, E, B>(
name: Exclude<N, keyof A>,
f: (a: A) => TaskEither<E, B>
) => (ma: TaskEither<E, A>) => TaskEither<E, { readonly [K in N | keyof A]: K extends keyof A ? A[K] : B }>
Added in v2.8.0
Signature
export declare const bindTo: <N>(name: N) => <E, A>(fa: TaskEither<E, A>) => TaskEither<E, { readonly [K in N]: A }>
Added in v2.8.0
Signature
export declare const bindW: <N extends string, A, E2, B>(
name: Exclude<N, keyof A>,
f: (a: A) => TaskEither<E2, B>
) => <E1>(fa: TaskEither<E1, A>) => TaskEither<E2 | E1, { readonly [K in N | keyof A]: K extends keyof A ? A[K] : B }>
Added in v2.8.0
Make sure that a resource is cleaned up in the event of an exception (*). The release action is called regardless of whether the body action throws (*) or returns.
(*) i.e. returns a Left
Signature
export declare const bracket: <E, A, B>(
acquire: TaskEither<E, A>,
use: (a: A) => TaskEither<E, B>,
release: (a: A, e: E.Either<E, B>) => TaskEither<E, void>
) => TaskEither<E, B>
Added in v2.0.0
Signature
export declare const sequenceArray: <A, E>(arr: readonly TaskEither<E, A>[]) => TaskEither<E, readonly A[]>
Added in v2.9.0
Signature
export declare const sequenceSeqArray: <A, E>(arr: readonly TaskEither<E, A>[]) => TaskEither<E, readonly A[]>
Added in v2.9.0
Convert a node style callback function to one returning a TaskEither
Note. If the function f
admits multiple overloadings, taskify
will pick last one. If you want a different
behaviour, add an explicit type annotation
// readFile admits multiple overloadings
// const readFile: (a: string) => TaskEither<NodeJS.ErrnoException, Buffer>
const readFile = taskify(fs.readFile)
const readFile2: (filename: string, encoding: string) => TaskEither<NodeJS.ErrnoException, Buffer> = taskify(
fs.readFile
)
Signature
export declare function taskify<L, R>(f: (cb: (e: L | null | undefined, r?: R) => void) => void): () => TaskEither<L, R>
export declare function taskify<A, L, R>(
f: (a: A, cb: (e: L | null | undefined, r?: R) => void) => void
): (a: A) => TaskEither<L, R>
export declare function taskify<A, B, L, R>(
f: (a: A, b: B, cb: (e: L | null | undefined, r?: R) => void) => void
): (a: A, b: B) => TaskEither<L, R>
export declare function taskify<A, B, C, L, R>(
f: (a: A, b: B, c: C, cb: (e: L | null | undefined, r?: R) => void) => void
): (a: A, b: B, c: C) => TaskEither<L, R>
export declare function taskify<A, B, C, D, L, R>(
f: (a: A, b: B, c: C, d: D, cb: (e: L | null | undefined, r?: R) => void) => void
): (a: A, b: B, c: C, d: D) => TaskEither<L, R>
export declare function taskify<A, B, C, D, E, L, R>(
f: (a: A, b: B, c: C, d: D, e: E, cb: (e: L | null | undefined, r?: R) => void) => void
): (a: A, b: B, c: C, d: D, e: E) => TaskEither<L, R>
Example
import { taskify } from 'fp-ts/TaskEither'
import * as fs from 'fs'
// const stat: (a: string | Buffer) => TaskEither<NodeJS.ErrnoException, fs.Stats>
const stat = taskify(fs.stat)
assert.strictEqual(stat.length, 0)
Added in v2.0.0
Signature
export declare const traverseArray: <A, B, E>(
f: (a: A) => TaskEither<E, B>
) => (as: readonly A[]) => TaskEither<E, readonly B[]>
Added in v2.9.0
Signature
export declare const traverseArrayWithIndex: <A, B, E>(
f: (index: number, a: A) => TaskEither<E, B>
) => (as: readonly A[]) => TaskEither<E, readonly B[]>
Added in v2.9.0
Equivalent to ReadonlyArray#traverseWithIndex(ApplicativePar)
.
Signature
export declare const traverseReadonlyArrayWithIndex: <A, E, B>(
f: (index: number, a: A) => TaskEither<E, B>
) => (as: readonly A[]) => TaskEither<E, readonly B[]>
Added in v2.11.0
Equivalent to ReadonlyArray#traverseWithIndex(ApplicativeSeq)
.
Signature
export declare const traverseReadonlyArrayWithIndexSeq: <A, E, B>(
f: (index: number, a: A) => TaskEither<E, B>
) => (as: readonly A[]) => TaskEither<E, readonly B[]>
Added in v2.11.0
Equivalent to ReadonlyNonEmptyArray#traverseWithIndex(ApplicativePar)
.
Signature
export declare const traverseReadonlyNonEmptyArrayWithIndex: <A, E, B>(
f: (index: number, a: A) => TaskEither<E, B>
) => (as: ReadonlyNonEmptyArray<A>) => TaskEither<E, ReadonlyNonEmptyArray<B>>
Added in v2.11.0
Equivalent to ReadonlyArray#traverseWithIndex(ApplicativeSeq)
.
Signature
export declare const traverseReadonlyNonEmptyArrayWithIndexSeq: <A, E, B>(
f: (index: number, a: A) => TaskEither<E, B>
) => (as: ReadonlyNonEmptyArray<A>) => TaskEither<E, ReadonlyNonEmptyArray<B>>
Added in v2.11.0
Signature
export declare const traverseSeqArray: <A, B, E>(
f: (a: A) => TaskEither<E, B>
) => (as: readonly A[]) => TaskEither<E, readonly B[]>
Added in v2.9.0
Signature
export declare const traverseSeqArrayWithIndex: <A, B, E>(
f: (index: number, a: A) => TaskEither<E, B>
) => (as: readonly A[]) => TaskEither<E, readonly B[]>
Added in v2.9.0