- Alt
- Applicative
- Apply
- Bifunctor
- Chain
- ChainRec
- FromEither
- FromReader
- Functor
- Monad
- MonadThrow
- Pointed
- alt
- altW
- getAltReaderValidation
- getApplicativeReaderValidation
- getOrElse
- getOrElseW
- mapBoth
- mapError
- orElse
- orElseW
- orLeft
- tapError
- bimap
- chain
- chainEitherK
- chainEitherKW
- chainFirst
- chainFirstEitherK
- chainFirstEitherKW
- chainFirstReaderK
- chainFirstReaderKW
- chainFirstW
- chainOptionK
- chainOptionKW
- chainReaderK
- chainReaderKW
- chainW
- fromOptionK
- mapLeft
- orElseFirst
- orElseFirstW
- sequenceArray
- traverseArray
- traverseArrayWithIndex
- traverseReadonlyArrayWithIndex
- traverseReadonlyNonEmptyArrayWithIndex
- ApT
- ap
- apFirst
- apFirstW
- apSecond
- apSecondW
- apW
- do
getApplyMonoid(deprecated)getApplySemigroup(deprecated)getReaderValidation(deprecated)getSemigroup(deprecated)- let
- local
readerEither(deprecated)- swap
- throwError
export declare const Alt: Alt3<URI>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const Applicative: Applicative3<URI>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const Apply: Apply3<URI>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const Bifunctor: Bifunctor3<URI>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const Chain: chainable.Chain3<URI>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
ChainRec for ReaderEither
export declare const ChainRec: ChainRec3<URI>
- Added in 0.1.0
- MIT – Copyright (c) 2022-present Jacob Alford
export declare const FromEither: FromEither3<URI>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const FromReader: FromReader3<URI>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const Functor: Functor3<URI>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const Monad: Monad3<URI>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const MonadThrow: MonadThrow3<URI>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const Pointed: Pointed3<URI>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Composes computations in sequence, using the return value of one computation to determine the next computation and keeping only the result of the first.
export declare const tap: {
<R1, E1, A, R2, E2, _>(
self: ReaderEither<R1, E1, A>,
f: (a: A) => ReaderEither<R2, E2, _>,
): ReaderEither<R1 & R2, E1 | E2, A>
<A, R2, E2, _>(
f: (a: A) => ReaderEither<R2, E2, _>,
): <R1, E1>(self: ReaderEither<R1, E1, A>) => ReaderEither<R1 & R2, E2 | E1, A>
}
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Composes computations in sequence, using the return value of one computation to determine the next computation and keeping only the result of the first.
export declare const tapEither: {
<A, E2, _>(f: (a: A) => Either<E2, _>): <R1, E1>(self: ReaderEither<R1, E1, A>) => ReaderEither<R1, E1 | E2, A>
<R1, E1, A, E2, _>(self: ReaderEither<R1, E1, A>, f: (a: A) => Either<E2, _>): ReaderEither<R1, E1 | E2, A>
}
- Added in 0.1.0
import * as E from '@fp-tx/core/Either'
import { pipe } from '@fp-tx/core/function'
import * as RE from '@fp-tx/core/ReaderEither'
const checkString = (value: string) =>
pipe(
RE.ask<number>(),
RE.tapEither(minLength => (value.length > minLength ? E.right('ok') : E.left('error'))),
)
assert.deepStrictEqual(checkString('')(1), E.left('error'))
assert.deepStrictEqual(checkString('fp-ts')(2), E.right(2))
- MIT – Copyright (c) 2017-present Giulio Canti
Composes computations in sequence, using the return value of one computation to determine the next computation and keeping only the result of the first.
export declare const tapReader: {
<R2, A, E, _>(f: (a: A) => Reader<R2, _>): <R1>(self: ReaderEither<R1, E, A>) => ReaderEither<R1 & R2, E, A>
<R1, R2, E, A, _>(self: ReaderEither<R1, E, A>, f: (a: A) => Reader<R2, _>): ReaderEither<R1 & R2, E, A>
}
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Reads the current context.
export declare const ask: <R, E = never>() => ReaderEither<R, E, R>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Projects a value from the global context in a ReaderEither
.
export declare const asks: <R, A, E = never>(f: (r: R) => A) => ReaderEither<R, E, A>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Effectfully accesses the environment.
export declare const asksReaderEither: <R, E, A>(f: (r: R) => ReaderEither<R, E, A>) => ReaderEither<R, E, A>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Less strict version of asksReaderEither
.
The W
suffix (short for Widening) means that the environment types will be merged.
export declare const asksReaderEitherW: <R1, R2, E, A>(
f: (r1: R1) => ReaderEither<R2, E, A>,
) => ReaderEither<R1 & R2, E, A>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const left: <R, E = never, A = never>(e: E) => ReaderEither<R, E, A>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const leftReader: <R, E = never, A = never>(me: Reader<R, E>) => ReaderEither<R, E, A>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const of: <R = unknown, E = never, A = never>(a: A) => ReaderEither<R, E, A>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const right: <R, E = never, A = never>(a: A) => ReaderEither<R, E, A>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const rightReader: <R, E = never, A = never>(ma: Reader<R, A>) => ReaderEither<R, E, A>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const fromEither: <E, A, R = unknown>(fa: Either<E, A>) => ReaderEither<R, E, A>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const fromOption: <E>(onNone: LazyArg<E>) => <A, R = unknown>(fa: Option<A>) => ReaderEither<R, E, A>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const fromReader: <R, A, E = never>(fa: Reader<R, A>) => ReaderEither<R, E, A>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const toUnion: <R, E, A>(fa: ReaderEither<R, E, A>) => Reader<R, E | A>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const Do: ReaderEither<unknown, never, {}>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const apS: <N extends string, A, R, E, B>(
name: Exclude<N, keyof A>,
fb: ReaderEither<R, E, B>,
) => (fa: ReaderEither<R, E, A>) => ReaderEither<R, E, { readonly [K in N | keyof A]: K extends keyof A ? A[K] : B }>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Less strict version of apS
.
The W
suffix (short for Widening) means that the environment types and the error types will be merged.
export declare const apSW: <A, N extends string, R2, E2, B>(
name: Exclude<N, keyof A>,
fb: ReaderEither<R2, E2, B>,
) => <R1, E1>(
fa: ReaderEither<R1, E1, A>,
) => ReaderEither<
R1 & R2,
E1 | E2,
{
readonly [K in keyof A | N]: K extends keyof A ? A[K] : B
}
>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const bind: <N extends string, A, R, E, B>(
name: Exclude<N, keyof A>,
f: (a: A) => ReaderEither<R, E, B>,
) => (ma: ReaderEither<R, E, A>) => ReaderEither<R, E, { readonly [K in N | keyof A]: K extends keyof A ? A[K] : B }>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const bindTo: <N extends string>(
name: N,
) => <R, E, A>(fa: ReaderEither<R, E, A>) => ReaderEither<R, E, { readonly [K in N]: A }>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
The W
suffix (short for Widening) means that the environment types and the error types will be merged.
export declare const bindW: <N extends string, A, R2, E2, B>(
name: Exclude<N, keyof A>,
f: (a: A) => ReaderEither<R2, E2, B>,
) => <R1, E1>(
fa: ReaderEither<R1, E1, A>,
) => ReaderEither<
R1 & R2,
E1 | E2,
{
readonly [K in keyof A | N]: K extends keyof A ? A[K] : B
}
>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Identifies an associative operation on a type constructor. It is similar to Semigroup
, except that it applies to types of kind * -> *
.
export declare const alt: <R, E, A>(
that: () => ReaderEither<R, E, A>,
) => (fa: ReaderEither<R, E, A>) => ReaderEither<R, E, A>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Less strict version of alt
.
The W
suffix (short for Widening) means that the environment, the error and the return types will be merged.
export declare const altW: <R2, E2, B>(
that: () => ReaderEither<R2, E2, B>,
) => <R1, E1, A>(fa: ReaderEither<R1, E1, A>) => ReaderEither<R1 & R2, E2, A | B>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
The default Alt
instance returns the last error, if you want to get all errors you need to provide a way to concatenate them via a Semigroup
.
See getAltValidation
.
export declare function getAltReaderValidation<E>(S: Semigroup<E>): Alt3C<URI, E>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
The default Applicative
instance returns the first error, if you want to get all errors you need to provide a way to concatenate them via a Semigroup
.
export declare function getApplicativeReaderValidation<E>(S: Semigroup<E>): Applicative3C<URI, E>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const getOrElse: <E, R, A>(onLeft: (e: E) => Reader<R, A>) => (ma: ReaderEither<R, E, A>) => Reader<R, A>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Less strict version of getOrElse
.
The W
suffix (short for Widening) means that the handler return type will be merged.
export declare const getOrElseW: <R2, E, B>(
onLeft: (e: E) => Reader<R2, B>,
) => <R1, A>(ma: ReaderEither<R1, E, A>) => Reader<R1 & R2, A | B>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Returns a ReaderEither
whose failure and success channels have been mapped by the specified pair of functions, f
and g
.
export declare const mapBoth: {
<E, G, A, B>(f: (e: E) => G, g: (a: A) => B): <R>(self: ReaderEither<R, E, A>) => ReaderEither<R, G, B>
<R, E, A, G, B>(self: ReaderEither<R, E, A>, f: (e: E) => G, g: (a: A) => B): ReaderEither<R, G, B>
}
- Added in 0.1.0
import * as ReaderEither from '@fp-tx/core/ReaderEither'
import * as Either from '@fp-tx/core/Either'
const f = (s: string) => new Error(s)
const g = (n: number) => n * 2
assert.deepStrictEqual(ReaderEither.mapBoth(ReaderEither.right(1), f, g)({}), Either.right(2))
assert.deepStrictEqual(ReaderEither.mapBoth(ReaderEither.left('err'), f, g)({}), Either.left(new Error('err')))
- MIT – Copyright (c) 2017-present Giulio Canti
Returns a ReaderEither
with its error channel mapped using the specified function.
export declare const mapError: {
<R, E, G>(f: (e: E) => G): <A>(self: ReaderEither<R, E, A>) => ReaderEither<R, G, A>
<R, E, A, G>(self: ReaderEither<R, E, A>, f: (e: E) => G): ReaderEither<R, G, A>
}
- Added in 0.1.0
import * as ReaderEither from '@fp-tx/core/ReaderEither'
import * as Either from '@fp-tx/core/Either'
const f = (s: string) => new Error(s)
assert.deepStrictEqual(ReaderEither.mapError(ReaderEither.right(1), f)({}), Either.right(1))
assert.deepStrictEqual(ReaderEither.mapError(ReaderEither.left('err'), f)({}), Either.left(new Error('err')))
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const orElse: <E1, R, E2, A>(
onLeft: (e: E1) => ReaderEither<R, E2, A>,
) => (ma: ReaderEither<R, E1, A>) => ReaderEither<R, E2, A>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Less strict version of orElse
.
The W
suffix (short for Widening) means that the environment types and the return types will be merged.
export declare const orElseW: <E1, R1, E2, B>(
onLeft: (e: E1) => ReaderEither<R1, E2, B>,
) => <R2, A>(ma: ReaderEither<R2, E1, A>) => ReaderEither<R1 & R2, E2, A | B>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const orLeft: <E1, R, E2>(
onLeft: (e: E1) => Reader<R, E2>,
) => <A>(fa: ReaderEither<R, E1, A>) => ReaderEither<R, E2, A>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Returns an effect that effectfully "peeks" at the failure of this effect.
export declare const tapError: {
<E1, R2, E2, _>(
onLeft: (e: E1) => ReaderEither<R2, E2, _>,
): <R1, A>(self: ReaderEither<R1, E1, A>) => ReaderEither<R1 & R2, E1 | E2, A>
<R1, E1, A, R2, E2, _>(
self: ReaderEither<R1, E1, A>,
onLeft: (e: E1) => ReaderEither<R2, E2, _>,
): ReaderEither<R1 & R2, E1 | E2, A>
}
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const filterOrElse: {
<E, A, B extends A>(
refinement: Refinement<A, B>,
onFalse: (a: A) => E,
): <R>(ma: ReaderEither<R, E, A>) => ReaderEither<R, E, B>
<E, A>(
predicate: Predicate<A>,
onFalse: (a: A) => E,
): <R, B extends A>(mb: ReaderEither<R, E, B>) => ReaderEither<R, E, B>
<E, A>(predicate: Predicate<A>, onFalse: (a: A) => E): <R>(ma: ReaderEither<R, E, A>) => ReaderEither<R, E, A>
}
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Less strict version of filterOrElse
.
The W
suffix (short for Widening) means that the error types will be merged.
export declare const filterOrElseW: {
<A, B extends A, E2>(
refinement: Refinement<A, B>,
onFalse: (a: A) => E2,
): <R, E1>(ma: ReaderEither<R, E1, A>) => ReaderEither<R, E1 | E2, B>
<A, E2>(
predicate: Predicate<A>,
onFalse: (a: A) => E2,
): <R, E1, B extends A>(mb: ReaderEither<R, E1, B>) => ReaderEither<R, E1 | E2, B>
<A, E2>(
predicate: Predicate<A>,
onFalse: (a: A) => E2,
): <R, E1>(ma: ReaderEither<R, E1, A>) => ReaderEither<R, E1 | E2, A>
}
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const getCompactable: <E>(M: Monoid<E>) => Compactable3C<'ReaderEither', E>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare function getFilterable<E>(M: Monoid<E>): Filterable3C<URI, E>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const chainRec: ChainRec3<URI>['chainRec']
- Added in 0.1.0
- MIT – Copyright (c) 2022-present Jacob Alford
Alias of mapBoth
.
export declare const bimap: <E, G, A, B>(
f: (e: E) => G,
g: (a: A) => B,
) => <R>(fa: ReaderEither<R, E, A>) => ReaderEither<R, G, B>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Alias of flatMap
.
export declare const chain: <R, E, A, B>(
f: (a: A) => ReaderEither<R, E, B>,
) => (ma: ReaderEither<R, E, A>) => ReaderEither<R, E, B>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Alias of flatMapEither
.
export declare const chainEitherK: <E, A, B>(
f: (a: A) => E.Either<E, B>,
) => <R>(ma: ReaderEither<R, E, A>) => ReaderEither<R, E, B>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Alias of flatMapEither
.
export declare const chainEitherKW: <E2, A, B>(
f: (a: A) => Either<E2, B>,
) => <R, E1>(ma: ReaderEither<R, E1, A>) => ReaderEither<R, E1 | E2, B>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Alias of tap
.
export declare const chainFirst: <R, E, A, B>(
f: (a: A) => ReaderEither<R, E, B>,
) => (ma: ReaderEither<R, E, A>) => ReaderEither<R, E, A>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Alias of tapEither
.
export declare const chainFirstEitherK: <A, E, B>(
f: (a: A) => E.Either<E, B>,
) => <R>(ma: ReaderEither<R, E, A>) => ReaderEither<R, E, A>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Alias of tapEither
.
Less strict version of chainFirstEitherK
.
The W
suffix (short for Widening) means that the environment types will be merged.
export declare const chainFirstEitherKW: <A, E2, B>(
f: (a: A) => Either<E2, B>,
) => <R, E1>(ma: ReaderEither<R, E1, A>) => ReaderEither<R, E1 | E2, A>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Alias of tapReader
.
export declare const chainFirstReaderK: <A, R, B>(
f: (a: A) => Reader<R, B>,
) => <E>(ma: ReaderEither<R, E, A>) => ReaderEither<R, E, A>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Alias of tapReader
.
Less strict version of chainReaderK
.
The W
suffix (short for Widening) means that the environment types will be merged.
export declare const chainFirstReaderKW: <A, R1, B>(
f: (a: A) => Reader<R1, B>,
) => <R2, E>(ma: ReaderEither<R2, E, A>) => ReaderEither<R1 & R2, E, A>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Alias of tap
.
export declare const chainFirstW: <R2, E2, A, B>(
f: (a: A) => ReaderEither<R2, E2, B>,
) => <R1, E1>(ma: ReaderEither<R1, E1, A>) => ReaderEither<R1 & R2, E1 | E2, A>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Use flatMapOption
.
export declare const chainOptionK: <E>(
onNone: LazyArg<E>,
) => <A, B>(f: (a: A) => Option<B>) => <R>(ma: ReaderEither<R, E, A>) => ReaderEither<R, E, B>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Use flatMapOption
.
export declare const chainOptionKW: <E2>(
onNone: LazyArg<E2>,
) => <A, B>(f: (a: A) => Option<B>) => <R, E1>(ma: ReaderEither<R, E1, A>) => ReaderEither<R, E1 | E2, B>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Alias of flatMapReader
.
export declare const chainReaderK: <A, R, B>(
f: (a: A) => Reader<R, B>,
) => <E>(ma: ReaderEither<R, E, A>) => ReaderEither<R, E, B>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Alias of flatMapReader
.
Less strict version of chainReaderK
.
The W
suffix (short for Widening) means that the environment types will be merged.
export declare const chainReaderKW: <A, R2, B>(
f: (a: A) => Reader<R2, B>,
) => <R1, E>(ma: ReaderEither<R1, E, A>) => ReaderEither<R1 & R2, E, B>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Alias of flatMap
.
export declare const chainW: <R2, E2, A, B>(
f: (a: A) => ReaderEither<R2, E2, B>,
) => <R1, E1>(ma: ReaderEither<R1, E1, A>) => ReaderEither<R1 & R2, E1 | E2, B>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Use liftOption
.
export declare const fromOptionK: <E>(
onNone: LazyArg<E>,
) => <A extends ReadonlyArray<unknown>, B>(f: (...a: A) => Option<B>) => <R = unknown>(...a: A) => ReaderEither<R, E, B>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Alias of mapError
.
export declare const mapLeft: <E, G>(f: (e: E) => G) => <R, A>(fa: ReaderEither<R, E, A>) => ReaderEither<R, G, A>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Alias of tapError
.
export declare const orElseFirst: <E, R, B>(
onLeft: (e: E) => ReaderEither<R, E, B>,
) => <A>(ma: ReaderEither<R, E, A>) => ReaderEither<R, E, A>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Alias of tapError
.
export declare const orElseFirstW: <E1, R2, E2, B>(
onLeft: (e: E1) => ReaderEither<R2, E2, B>,
) => <R1, A>(ma: ReaderEither<R1, E1, A>) => ReaderEither<R1 & R2, E1 | E2, A>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const fromEitherK: <E, A extends ReadonlyArray<unknown>, B>(
f: (...a: A) => E.Either<E, B>,
) => <R = unknown>(...a: A) => ReaderEither<R, E, B>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const fromPredicate: {
<E, A, B extends A>(refinement: Refinement<A, B>, onFalse: (a: A) => E): <R = unknown>(a: A) => ReaderEither<R, E, B>
<E, A>(predicate: Predicate<A>, onFalse: (a: A) => E): <R = unknown, B extends A = A>(b: B) => ReaderEither<R, E, B>
<E, A>(predicate: Predicate<A>, onFalse: (a: A) => E): <R = unknown>(a: A) => ReaderEither<R, E, A>
}
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const fromReaderK: <A extends ReadonlyArray<unknown>, R, B>(
f: (...a: A) => Reader<R, B>,
) => <E = never>(...a: A) => ReaderEither<R, E, B>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const liftNullable: <A extends ReadonlyArray<unknown>, B, E>(
f: (...a: A) => B | null | undefined,
onNullable: (...a: A) => E,
) => <R>(...a: A) => ReaderEither<R, E, NonNullable<B>>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const liftOption: <A extends ReadonlyArray<unknown>, B, E>(
f: (...a: A) => Option<B>,
onNone: (...a: A) => E,
) => <R>(...a: A) => ReaderEither<R, E, B>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Maps the Right
value of this ReaderEither
to the specified constant value.
export declare const as: {
<A>(a: A): <R, E, _>(self: ReaderEither<R, E, _>) => ReaderEither<R, E, A>
<R, E, _, A>(self: ReaderEither<R, E, _>, a: A): ReaderEither<R, E, A>
}
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Maps the Right
value of this ReaderEither
to the void constant value.
export declare const asUnit: <R, E, _>(self: ReaderEither<R, E, _>) => ReaderEither<R, E, void>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const flap: <A>(a: A) => <R, E, B>(fab: ReaderEither<R, E, (a: A) => B>) => ReaderEither<R, E, B>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
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.
export declare const map: <A, B>(f: (a: A) => B) => <R, E>(fa: ReaderEither<R, E, A>) => ReaderEither<R, E, B>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export interface ReaderEither<R, E, A> extends Reader<R, Either<E, A>> {}
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Alias of matchE
.
export declare const fold: <R, E, A, B>(
onLeft: (e: E) => R.Reader<R, B>,
onRight: (a: A) => R.Reader<R, B>,
) => (ma: ReaderEither<R, E, A>) => R.Reader<R, B>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Alias of matchEW
.
export declare const foldW: <E, R2, B, A, R3, C>(
onLeft: (e: E) => R.Reader<R2, B>,
onRight: (a: A) => R.Reader<R3, C>,
) => <R1>(ma: ReaderEither<R1, E, A>) => R.Reader<R1 & R2 & R3, B | C>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const match: <E, B, A>(
onLeft: (e: E) => B,
onRight: (a: A) => B,
) => <R>(ma: ReaderEither<R, E, A>) => Reader<R, B>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
The E
suffix (short for Effect) means that the handlers return an effect (Reader
).
export declare const matchE: <R, E, A, B>(
onLeft: (e: E) => Reader<R, B>,
onRight: (a: A) => Reader<R, B>,
) => (ma: ReaderEither<R, E, A>) => Reader<R, B>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Less strict version of matchE
.
The W
suffix (short for Widening) means that the handler return types will be merged.
export declare const matchEW: <E, R2, B, A, R3, C>(
onLeft: (e: E) => Reader<R2, B>,
onRight: (a: A) => Reader<R3, C>,
) => <R1>(ma: ReaderEither<R1, E, A>) => Reader<R1 & R2 & R3, B | C>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Less strict version of match
.
The W
suffix (short for Widening) means that the handler return types will be merged.
export declare const matchW: <E, B, A, C>(
onLeft: (e: E) => B,
onRight: (a: A) => C,
) => <R>(ma: Reader<R, Either<E, A>>) => Reader<R, B | C>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const flatMap: {
<A, R2, E2, B>(
f: (a: A) => ReaderEither<R2, E2, B>,
): <R1, E1>(ma: ReaderEither<R1, E1, A>) => ReaderEither<R1 & R2, E1 | E2, B>
<R1, E1, A, R2, E2, B>(
ma: ReaderEither<R1, E1, A>,
f: (a: A) => ReaderEither<R2, E2, B>,
): ReaderEither<R1 & R2, E1 | E2, B>
}
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const flatMapEither: {
<A, E2, B>(f: (a: A) => E.Either<E2, B>): <R, E1>(self: ReaderEither<R, E1, A>) => ReaderEither<R, E1 | E2, B>
<R, E1, A, E2, B>(self: ReaderEither<R, E1, A>, f: (a: A) => E.Either<E2, B>): ReaderEither<R, E1 | E2, B>
}
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const flatMapNullable: {
<A, B, E2>(
f: (a: A) => B | null | undefined,
onNullable: (a: A) => E2,
): <R, E1>(self: ReaderEither<R, E1, A>) => ReaderEither<R, E2 | E1, NonNullable<B>>
<R, E1, A, B, E2>(
self: ReaderEither<R, E1, A>,
f: (a: A) => B | null | undefined,
onNullable: (a: A) => E2,
): ReaderEither<R, E1 | E2, NonNullable<B>>
}
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const flatMapOption: {
<A, B, E2>(
f: (a: A) => Option<B>,
onNone: (a: A) => E2,
): <R, E1>(self: ReaderEither<R, E1, A>) => ReaderEither<R, E2 | E1, B>
<R, E1, A, B, E2>(
self: ReaderEither<R, E1, A>,
f: (a: A) => Option<B>,
onNone: (a: A) => E2,
): ReaderEither<R, E1 | E2, B>
}
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const flatMapReader: {
<A, R2, B>(f: (a: A) => Reader<R2, B>): <R1, E>(self: ReaderEither<R1, E, A>) => ReaderEither<R1 & R2, E, B>
<R1, E, A, R2, B>(self: ReaderEither<R1, E, A>, f: (a: A) => Reader<R2, B>): ReaderEither<R1 & R2, E, B>
}
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const flatten: <R, E, A>(mma: ReaderEither<R, E, ReaderEither<R, E, A>>) => ReaderEither<R, E, A>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Less strict version of flatten
.
The W
suffix (short for Widening) means that the environment types and the error types will be merged.
export declare const flattenW: <R1, R2, E1, E2, A>(
mma: ReaderEither<R1, E1, ReaderEither<R2, E2, A>>,
) => ReaderEither<R1 & R2, E1 | E2, A>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Equivalent to ReadonlyArray#sequence(Applicative)
.
export declare const sequenceArray: <R, E, A>(
arr: ReadonlyArray<ReaderEither<R, E, A>>,
) => ReaderEither<R, E, ReadonlyArray<A>>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Equivalent to ReadonlyArray#traverse(Applicative)
.
export declare const traverseArray: <R, E, A, B>(
f: (a: A) => ReaderEither<R, E, B>,
) => (as: readonly A[]) => ReaderEither<R, E, readonly B[]>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Equivalent to ReadonlyArray#traverseWithIndex(Applicative)
.
export declare const traverseArrayWithIndex: <R, E, A, B>(
f: (index: number, a: A) => ReaderEither<R, E, B>,
) => (as: ReadonlyArray<A>) => ReaderEither<R, E, ReadonlyArray<B>>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Equivalent to ReadonlyArray#traverseWithIndex(Applicative)
.
export declare const traverseReadonlyArrayWithIndex: <A, R, E, B>(
f: (index: number, a: A) => ReaderEither<R, E, B>,
) => (as: readonly A[]) => ReaderEither<R, E, readonly B[]>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Equivalent to ReadonlyNonEmptyArray#traverseWithIndex(Applicative)
.
export declare const traverseReadonlyNonEmptyArrayWithIndex: <A, R, E, B>(
f: (index: number, a: A) => ReaderEither<R, E, B>,
) => (as: ReadonlyNonEmptyArray<A>) => ReaderEither<R, E, ReadonlyNonEmptyArray<B>>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export type URI = typeof URI
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const URI = 'ReaderEither'
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const ApT: ReaderEither<unknown, never, readonly []>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const ap: <R, E, A>(
fa: ReaderEither<R, E, A>,
) => <B>(fab: ReaderEither<R, E, (a: A) => B>) => ReaderEither<R, E, B>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Combine two effectful actions, keeping only the result of the first.
export declare const apFirst: <R, E, B>(
second: ReaderEither<R, E, B>,
) => <A>(first: ReaderEither<R, E, A>) => ReaderEither<R, E, A>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Less strict version of apFirst
The W
suffix (short for Widening) means that the environment types and the error types will be merged.
export declare const apFirstW: <R2, E2, B>(
second: ReaderEither<R2, E2, B>,
) => <R1, E1, A>(first: ReaderEither<R1, E1, A>) => ReaderEither<R1 & R2, E1 | E2, A>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Combine two effectful actions, keeping only the result of the second.
export declare const apSecond: <R, E, B>(
second: ReaderEither<R, E, B>,
) => <A>(first: ReaderEither<R, E, A>) => ReaderEither<R, E, B>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Less strict version of apSecond
The W
suffix (short for Widening) means that the environment types and the error types will be merged.
export declare const apSecondW: <R2, E2, B>(
second: ReaderEither<R2, E2, B>,
) => <R1, E1, A>(first: ReaderEither<R1, E1, A>) => ReaderEither<R1 & R2, E1 | E2, B>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
Less strict version of ap
.
The W
suffix (short for Widening) means that the environment types and the error types will be merged.
export declare const apW: <R2, E2, A>(
fa: ReaderEither<R2, E2, A>,
) => <R1, E1, B>(fab: ReaderEither<R1, E1, (a: A) => B>) => ReaderEither<R1 & R2, E1 | E2, B>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const do_: <MA extends ReaderEitherIterable<any, any, any>, A>(
yieldFunction: (unwrap: <R, E, A>(ma: ReaderEither<R, E, A>) => ReaderEitherIterable<R, E, A>) => Generator<MA, A>,
) => ReaderEither<
_.UnionToIntersection<MA extends ReaderEitherIterable<infer R, any, any> ? R : never>,
MA extends ReaderEitherIterable<any, infer E, any> ? E : never,
A
>
Use getApplicativeMonoid
instead.
export declare const getApplyMonoid: <R, E, A>(M: Monoid<A>) => Monoid<ReaderEither<R, E, A>>
- Added in 0.1.0
- Deprecated
- MIT – Copyright (c) 2017-present Giulio Canti
Use getApplySemigroup
instead.
export declare const getApplySemigroup: <R, E, A>(S: Semigroup<A>) => Semigroup<ReaderEither<R, E, A>>
- Added in 0.1.0
- Deprecated
- MIT – Copyright (c) 2017-present Giulio Canti
Use getApplicativeReaderValidation
and getAltReaderValidation
instead.
export declare function getReaderValidation<E>(
SE: Semigroup<E>,
): Monad3C<URI, E> & Bifunctor3<URI> & Alt3C<URI, E> & MonadThrow3C<URI, E>
- Added in 0.1.0
- Deprecated
- MIT – Copyright (c) 2017-present Giulio Canti
Use getApplySemigroup
instead.
export declare const getSemigroup: <R, E, A>(S: Semigroup<A>) => Semigroup<ReaderEither<R, E, A>>
- Added in 0.1.0
- Deprecated
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const let_: <N extends string, A, B>(
name: Exclude<N, keyof A>,
f: (a: A) => B,
) => <R, E>(
fa: ReaderEither<R, E, A>,
) => ReaderEither<R, E, { readonly [K in N | keyof A]: K extends keyof A ? A[K] : B }>
Changes the value of the local context during the execution of the action ma
(similar to Contravariant
's contramap
).
export declare const local: <R2, R1>(f: (r2: R2) => R1) => <E, A>(ma: ReaderEither<R1, E, A>) => ReaderEither<R2, E, A>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
This instance is deprecated, use small, specific instances instead. For example if a function needs a Functor
instance, pass RE.Functor
instead of RE.readerEither
(where R
is from import R from 'fp-ts/ReaderEither'
)
export declare const readerEither: Monad3<URI> & Bifunctor3<URI> & Alt3<URI> & MonadThrow3<URI>
- Added in 0.1.0
- Deprecated
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const swap: <R, E, A>(ma: ReaderEither<R, E, A>) => ReaderEither<R, A, E>
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti
export declare const throwError: MonadThrow3<URI>['throwError']
- Added in 0.1.0
- MIT – Copyright (c) 2017-present Giulio Canti