interface IO<A> {
(): A
}
IO<A>
represents a non-deterministic synchronous computation that can cause side effects, yields a value of
type A
and never fails. If you want to represent a synchronous computation that may fail, please see
IOEither
.
Added in v2.0.0
Wrap a value into the type constructor.
Signature
export declare const of: <A>(a: A) => IO<A>
Added in v2.0.0
Apply a function to an argument under a type constructor.
Signature
export declare const ap: <A>(fa: IO<A>) => <B>(fab: IO<(a: A) => B>) => IO<B>
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) => (fa: IO<A>) => IO<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: <A, B>(f: (a: A) => IO<B>) => (ma: IO<A>) => IO<B>
Added in v2.0.0
Signature
export declare const fromIO: <A>(fa: IO<A>) => IO<A>
Added in v2.7.0
Combine two effectful actions, keeping only the result of the first.
Derivable from Apply
.
Signature
export declare const apFirst: <B>(fb: IO<B>) => <A>(fa: IO<A>) => IO<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: <B>(fb: IO<B>) => <A>(fa: IO<A>) => IO<B>
Added in v2.0.0
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 Monad
.
Signature
export declare const chainFirst: <A, B>(f: (a: A) => IO<B>) => (ma: IO<A>) => IO<A>
Added in v2.0.0
Derivable from Monad
.
Signature
export declare const flatten: <A>(mma: IO<IO<A>>) => IO<A>
Added in v2.0.0
Signature
export declare const Applicative: Applicative1<'IO'>
Added in v2.7.0
Signature
export declare const ChainRec: ChainRec1<'IO'>
Added in v2.7.0
Signature
export declare const Functor: Functor1<'IO'>
Added in v2.7.0
Signature
export declare const Monad: Monad1<'IO'>
Added in v2.7.0
Signature
export declare const MonadIO: MonadIO1<'IO'>
Added in v2.7.0
Signature
export declare const URI: 'IO'
Added in v2.0.0
Signature
export type URI = typeof URI
Added in v2.0.0
Signature
export declare function getMonoid<A>(M: Monoid<A>): Monoid<IO<A>>
Added in v2.0.0
Signature
export declare function getSemigroup<A>(S: Semigroup<A>): Semigroup<IO<A>>
Added in v2.0.0
Signature
export declare const io: Monad1<'IO'> & MonadIO1<'IO'> & ChainRec1<'IO'>
Added in v2.0.0
Signature
export interface IO<A> {
(): A
}
Added in v2.0.0
Signature
export declare const Do: IO<{}>
Added in v2.9.0
Signature
export declare const apS: <A, N extends string, B>(
name: Exclude<N, keyof A>,
fb: IO<B>
) => (fa: IO<A>) => IO<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }>
Added in v2.8.0
Signature
export declare const bind: <N extends string, A, B>(
name: Exclude<N, keyof A>,
f: (a: A) => IO<B>
) => (fa: IO<A>) => IO<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }>
Added in v2.8.0
Signature
export declare const bindTo: <N extends string>(name: N) => <A>(fa: IO<A>) => IO<{ [K in N]: A }>
Added in v2.8.0
transform Array of IO to IO of Array
this function has the same behavior of A.sequence(IO.io)
but it's stack safe
Signature
export declare const sequenceArray: <A>(arr: readonly IO<A>[]) => IO<readonly A[]>
Example
import * as RA from 'fp-ts/ReadonlyArray'
import { sequenceArray, IO } from 'fp-ts/IO'
import { pipe } from 'fp-ts/function'
const logger: Array<unknown> = []
const log: <A>(a: A) => IO<void> = (a) => () => {
logger.push(a)
}
pipe(RA.range(0, 100), RA.map(log), sequenceArray)()
assert.deepStrictEqual(logger, RA.range(0, 100))
Added in v2.9.0
runs an action for every element in array, and accumulates the results IO in the array.
this function has the same behavior of A.traverse(IO.io)
but it's stack safe
Signature
export declare const traverseArray: <A, B>(f: (a: A) => IO<B>) => (arr: readonly A[]) => IO<readonly B[]>
Example
import * as RA from 'fp-ts/ReadonlyArray'
import { traverseArray, IO } from 'fp-ts/IO'
import { pipe } from 'fp-ts/function'
const logger: Array<unknown> = []
const log: <A>(a: A) => IO<void> = (a) => () => {
logger.push(a)
}
pipe(RA.range(0, 100), traverseArray(log))()
assert.deepStrictEqual(logger, RA.range(0, 100))
Added in v2.9.0
Signature
export declare const traverseArrayWithIndex: <A, B>(
f: (index: number, a: A) => IO<B>
) => (arr: readonly A[]) => IO<readonly B[]>
Added in v2.9.0