@typed/effects

Generator-based effect management and reverse dependency injection.

Index

Namespaces

Effect

Enumerations

FiberState

Classes

Interfaces

Type aliases

Variables

FiberFailure

Functions

Object literals

Type aliases

Capabilities

Capabilities<A>: A extends Effects<infer R, any> ? R : never

Type parameters

CombinedCapabilities

CombinedCapabilities<A>: UnNest<Flatten<ToConsList<A>, {}>>

Type parameters

A: ReadonlyArray<Effect<any, any>>

CombinedValues

CombinedValues<A>: {}

Type parameters

A: ReadonlyArray<Effect<any, any>>

Type declaration

ErrorOf

ErrorOf<E, K>: FailuresOf<E>[K] extends Fail<infer R> ? R : never

Type parameters

E: Effects<any, any>
K: FailureTypes<E>

Fail

Fail<Err>: <A>(error: Err) => Resume<Failure<Err, A>>

Type parameters

Type declaration

- <A>(error: Err): Resume<Failure<Err, A>>
- Type parameters
  - A
  Parameters
  - error: Err
  Returns Resume<Failure<Err, A>>

FailEnv

FailEnv<K, Err>: {}

Type parameters

K: PropertyKey
Err

Type declaration

FailureTypes

FailureTypes<E>: keyof FailuresOf<E>

Type parameters

E: Effects<any, any>

FailuresOf

FailuresOf<E>: Pick<Capabilities<E>, FailureKeys<Capabilities<E>>>

Type parameters

E: Effects<any, any>

FiberFailure

FiberFailure: FailEnv<typeof FiberFailure, Error>

FiberInfo

FiberInfo<B>: { promise: Promise<B>; state: Running } | { error: Error; state: Error } | { state: Returned; value: B }

Type parameters

Fork

Fork: { fork: <A>(effect: A, c: Capabilities<A> & FiberFailure) => Resume<Fiber<Return<A>>> }

Type declaration

Readonly fork: <A>(effect: A, c: Capabilities<A> & FiberFailure) => Resume<Fiber<Return<A>>>
- - <A>(effect: A, c: Capabilities<A> & FiberFailure): Resume<Fiber<Return<A>>>
  - Type parameters
    - A: Effects
    Parameters
    - effect: A
    - c: Capabilities<A> & FiberFailure
    Returns Resume<Fiber<Return<A>>>

ForkAll

ForkAll<A>: {}

Type parameters

A: ReadonlyArray<Effect<any, any>>

Type declaration

IteratorResultOf

IteratorResultOf<A>: IteratorResult<Yield<A>, Return<A>>

Type parameters

Join

Join: { join: <A>(fiber: Fiber<A>) => Resume<Either<Error, A>> }

Type declaration

Readonly join: <A>(fiber: Fiber<A>) => Resume<Either<Error, A>>
- - <A>(fiber: Fiber<A>): Resume<Either<Error, A>>
  - Type parameters
    - A
    Parameters
    - fiber: Fiber<A>
    Returns Resume<Either<Error, A>>

JoinAll

JoinAll<A>: {}

Type parameters

A: ReadonlyArray<Fiber<any>>

Type declaration

Kill

Kill: { kill: <A>(f: Fiber<A>) => Resume<boolean> }

Type declaration

Readonly kill: <A>(f: Fiber<A>) => Resume<boolean>
- - <A>(f: Fiber<A>): Resume<boolean>
  - Type parameters
    - A
    Parameters
    - f: Fiber<A>
    Returns Resume<boolean>

PureEffect

PureEffect<A>: Effect<Pure<any>, A>

Type parameters

Return

Return<A>: A extends Effect<any, infer R> ? R : never

Type parameters

RunWith

RunWith<A, C>: C extends Capabilities<A> ? PureEffect<Return<A>> : Effects<Omit<Capabilities<A>, keyof C>, Return<A>>

Type parameters

A: Effects<any, any>
C

TimerEnv

TimerEnv: { timer: Timer }

Type declaration

Readonly timer: Timer

TypeOf

TypeOf<A>: A extends Effect<any, any> ? Effects<Capabilities<A>, Return<A>> : A extends (...args: keyof any[]) => Effects<any, any> ? Effects<Capabilities<ReturnType<A>>, Return<ReturnType<A>>> : unknown

Type parameters

Yield

Yield<A>: A extends Effect<infer R, any> ? R : never

Type parameters

Variables

Const FiberFailure

FiberFailure: unique symbol = Symbol.for('FiberFailure')

Functions

Const Fail

Fail<A>(error: any): { type: "value"; value: A } | { resume: (cb: (value: A) => Disposable) => Disposable; type: "lazy" }

- Defined in packages/effects/source/failures/Failure.ts:9
Type parameters
- A
Parameters
- error: any
Returns { type: "value"; value: A } | { resume: (cb: (value: A) => Disposable) => Disposable; type: "lazy" }

catchFailure

catchFailure<A, K>(effect: A, errorType: K, onError: (error: ErrorOf<A, K>) => Return<A>)

- Defined in packages/effects/source/failures/fail.ts:14
Type parameters
- A: Effect<any, any>
- K: FailureTypes<A>
Parameters
- effect: A
- errorType: K
- onError: (error: ErrorOf<A, K>) => Return<A>
  - - (error: ErrorOf<A, K>): Return<A>
    - Parameters
      - error: ErrorOf<A, K>
      Returns Return<A>

combine

combine<E>(...effects: E): Effects<CombinedCapabilities<E>, CombinedValues<E>>

- Defined in packages/effects/source/combinators/combine.ts:6
Type parameters
- E: ReadonlyArray<Effects<any, any>>
Parameters
- Rest ...effects: E
Returns Effects<CombinedCapabilities<E>, CombinedValues<E>>

createFiber

createFiber<A>(): Fiber<A>

- Defined in packages/effects/source/fibers/createFiber.ts:7
Type parameters
- A
Returns Fiber<A>

Const delay

delay(ms: number): Effects<TimerEnv, number>

- Defined in packages/effects/source/factories/delay.ts:7
Parameters
- ms: number
Returns Effects<TimerEnv, number>

fail

fail<A, Err>(errorType: A, error: Err): Effects<FailEnv<A, Err>, any>

- Defined in packages/effects/source/failures/fail.ts:7
Type parameters
- A: keyof any
- Err
Parameters
- errorType: A
- error: Err
Returns Effects<FailEnv<A, Err>, any>

fork

fork<A>(effect: A): Effects<Capabilities<A> & Fork & FiberFailure, Fiber<Return<A>>>

- Defined in packages/effects/source/fibers/fork.ts:35
Type parameters
- A: Effects
Parameters
- effect: A
Returns Effects<Capabilities<A> & Fork & FiberFailure, Fiber<Return<A>>>

forkAll

forkAll<A>(...effects: A): Effects<CombinedCapabilities<A> & FiberFailure & Fork, ForkAll<A>>

- Defined in packages/effects/source/fibers/forkAll.ts:6
Type parameters
- A: ReadonlyArray<Effect<any, any>>
Parameters
- Rest ...effects: A
Returns Effects<CombinedCapabilities<A> & FiberFailure & Fork, ForkAll<A>>

Const get

get<A>(): Effect<Env<A, A>, A>

- Defined in packages/effects/source/factories/get.ts:5
Type parameters
- A
Returns Effect<Env<A, A>, A>

join

join<A>(f: Fiber<A>): Effects<Join & FiberFailure, A>

- Defined in packages/effects/source/fibers/join.ts:37
Type parameters
- A
Parameters
- f: Fiber<A>
Returns Effects<Join & FiberFailure, A>

joinAll

joinAll<A>(...fibers: A): Effects<FiberFailure & Join, JoinAll<A>>

- Defined in packages/effects/source/fibers/joinAll.ts:6
Type parameters
- A: ReadonlyArray<Fiber<any>>
Parameters
- Rest ...fibers: A
Returns Effects<FiberFailure & Join, JoinAll<A>>

kill

kill<A>(f: Fiber<A>): Effects<Kill, void>

- Defined in packages/effects/source/fibers/kill.ts:25
Type parameters
- A
Parameters
- f: Fiber<A>
Returns Effects<Kill, void>

killAll

killAll<A>(...fibers: A): Effects<FiberFailure & Kill, void>

- Defined in packages/effects/source/fibers/killAll.ts:6
Type parameters
- A: ReadonlyArray<Fiber<any>>
Parameters
- Rest ...fibers: A
Returns Effects<FiberFailure & Kill, void>

map

map<E, A, B>(fn: Arity1<A, B>, effect: Effects<E, A>): Effects<E, B>

- Defined in packages/effects/source/combinators/map.ts:4
Type parameters
- E
- A
- B
Parameters
- fn: Arity1<A, B>
- effect: Effects<E, A>
Returns Effects<E, B>

orFail

orFail<F, A, B, C>(key: F, effect: Effects<A, Either<B, C>>): Effect<Env<A, any> | Env<FailEnv<F, B>, any>, C>

- Defined in packages/effects/source/failures/orFail.ts:7
Type parameters
- F: PropertyKey
- A
- B
- C
Parameters
- key: F
- effect: Effects<A, Either<B, C>>
Returns Effect<Env<A, any> | Env<FailEnv<F, B>, any>, C>

race

race<E>(...effects: E): Effect<Env<CombinedCapabilities<E>, Return<E[keyof E]>>, Return<E[keyof E]>>

- Defined in packages/effects/source/combinators/race.ts:6
Type parameters
- E: ReadonlyArray<Effect<any, any>>
Parameters
- Rest ...effects: E
Returns Effect<Env<CombinedCapabilities<E>, Return<E[keyof E]>>, Return<E[keyof E]>>

Const runEffect

runEffect<A>(effect: A): Env<Capabilities<A>, Return<A>>

- Defined in packages/effects/source/run/runEffect.ts:5
Type parameters
- A: Effect<any, any>
Parameters
- effect: A
Returns Env<Capabilities<A>, Return<A>>

runEffects

runEffects<A>(effect: A): Disposable
runEffects<A>(effect: A, resources: Capabilities<A>, onReturn?: undefined | ((value: Return<A>) => Disposable)): Disposable

- Defined in packages/effects/source/run/runEffects.ts:6
Type parameters
- A: PureEffect<any>
Parameters
- effect: A
Returns Disposable
- Defined in packages/effects/source/run/runEffects.ts:8
Type parameters
- A: Effects<any, any>
Parameters
- effect: A
- resources: Capabilities<A>
- Optional onReturn: undefined | ((value: Return<A>) => Disposable)
Returns Disposable

runWith

runWith<A, C>(effect: A, capabilities: C): RunWith<A, C>

- Defined in packages/effects/source/run/runWith.ts:9
Type parameters
- A: Effects<any, any>
- C
Parameters
- effect: A
- capabilities: C
Returns RunWith<A, C>

sequence

sequence<E, A, B>(fn: Arity1<A, Effect<E, B>>, as: keyof A[]): Effect<E, keyof B[]>

- Defined in packages/effects/source/factories/sequence.ts:4
Type parameters
- E
- A
- B
Parameters
- fn: Arity1<A, Effect<E, B>>
- as: keyof A[]
Returns Effect<E, keyof B[]>

Const startEffect

startEffect<A>(effect: A): Env<Capabilities<A>, A>

- Defined in packages/effects/source/run/startEffect.ts:4
Type parameters
- A: Effect<any, any>
Parameters
- effect: A
Returns Env<Capabilities<A>, A>

Object literals

Const Fork

Fork: object

fork

fork<A>(effect: A, c: Capabilities<A> & FiberFailure): { type: "value"; value: A } | { resume: (cb: (value: A) => Disposable) => Disposable; type: "lazy" }

- Defined in packages/effects/source/fibers/fork.ts:16
Type parameters
- A: Effects
Parameters
- effect: A
- c: Capabilities<A> & FiberFailure
Returns { type: "value"; value: A } | { resume: (cb: (value: A) => Disposable) => Disposable; type: "lazy" }

Const Join

Join: object

join

join<A>(fiber: Fiber<A>): Resume<Either<Error, A>>

- Defined in packages/effects/source/fibers/join.ts:11
Type parameters
- A
Parameters
- fiber: Fiber<A>
Returns Resume<Either<Error, A>>

Const Kill

Kill: object

kill

kill<A>(fiber: Fiber<A>): Resume<boolean>

- Defined in packages/effects/source/fibers/kill.ts:10
Type parameters
- A
Parameters
- fiber: Fiber<A>
Returns Resume<boolean>

@typed/effects

Index

Namespaces

Enumerations

Classes

Interfaces

Type aliases

Variables

Functions

Object literals

Type aliases

Capabilities

Type parameters

A

CombinedCapabilities

Type parameters

A: ReadonlyArray<Effect<any, any>>

CombinedValues

Type parameters

A: ReadonlyArray<Effect<any, any>>

Type declaration

ErrorOf

Type parameters

E: Effects<any, any>

K: FailureTypes<E>

Fail

Type parameters

Err

Type declaration

Type parameters

A

Parameters

error: Err

Returns Resume<Failure<Err, A>>

FailEnv

Type parameters

K: PropertyKey

Err

Type declaration

FailureTypes

Type parameters

E: Effects<any, any>

FailuresOf

Type parameters

E: Effects<any, any>

FiberFailure

FiberInfo

Type parameters

B

Fork

Type declaration

Readonly fork: <A>(effect: A, c: Capabilities<A> & FiberFailure) => Resume<Fiber<Return<A>>>

Type parameters

A: Effects

Parameters

effect: A

c: Capabilities<A> & FiberFailure

Returns Resume<Fiber<Return<A>>>

ForkAll

Type parameters

A: ReadonlyArray<Effect<any, any>>

Type declaration

IteratorResultOf

Type parameters

A

Join

Type declaration

Readonly join: <A>(fiber: Fiber<A>) => Resume<Either<Error, A>>

Type parameters

A

Parameters

fiber: Fiber<A>

Returns Resume<Either<Error, A>>

JoinAll

Type parameters

A: ReadonlyArray<Fiber<any>>

Type declaration

Kill

Type declaration

Readonly kill: <A>(f: Fiber<A>) => Resume<boolean>