Op

Op: object

Defined in: Core/Op.ts:63

Type Declaration

all

all: <E, A>(invocations) => Deferred<readonly Outcome<E, A>[]>

Type Parameters

E

E

A

A

Parameters

invocations

readonly Deferred<Outcome<E, A>>[]

Returns

Deferred<readonly Outcome<E, A>[]>

chain

chain: <E, A, B>(f) => (outcome) => Outcome<E, B>

Type Parameters

E

E

A

A

B

B

Parameters

f

(a) => Outcome<E, B>

Returns

(outcome) => Outcome<E, B>

create

create: <E, A, I>(factory, onError) => Op<I, E, A>

Type Parameters

E

E

A

A

I

I = void

Parameters

factory

(signal) => (input) => Promise<A>

onError

(e) => E

Returns

Op<I, E, A>

fold

fold: <E, A, B>(onErr, onNil, onOk) => (outcome) => B

Type Parameters

E

E

A

A

B

B

Parameters

onErr

(e) => B

onNil

() => B

onOk

(a) => B

Returns

(outcome) => B

getOrElse

getOrElse: <E, A, B>(defaultValue) => (outcome) => A | B

Type Parameters

E

E

A

A

B

B

Parameters

defaultValue

() => B

Returns

(outcome) => A | B

interpret

interpret: <I, E, A, O>(op, options) => InterpretResult<I, E, A, O> = interpretFn

Type Parameters

I

I

E

E

A

A

O

O extends AllInterpretOptions<I, E>

Parameters

op

Op<I, E, A>

options

O

Returns

InterpretResult<I, E, A, O>

is

is: object

is.err

err: <E, A>(state) => state is Err<E> = isErr

Type guard that checks if an Op state or outcome is Err.

Type Parameters

E

E

A

A

Parameters

state

State<E, A>

Returns

state is Err<E>

Example

if (Op.is.err(outcome)) {
  showError(outcome.error);
}

is.idle

idle: <E, A>(state) => state is Idle = isIdle

Type guard that checks if an Op state is Idle.

Type Parameters

E

E

A

A

Parameters

state

State<E, A>

Returns

state is Idle

Example

if (Op.is.idle(manager.state)) {
  console.log("Ready to execute");
}

is.nil

nil: <E, A>(state) => state is Nil = isNil

Type guard that checks if an Op state or outcome is Nil.

Type Parameters

E

E

A

A

Parameters

state

State<E, A>

Returns

state is Nil

Example

if (Op.is.nil(outcome)) {
  console.log("Skipped due to:", outcome.reason);
}

is.ok

ok: <E, A>(state) => state is Ok<A> = isOk

Type guard that checks if an Op state or outcome is Ok.

Type Parameters

E

E

A

A

Parameters

state

State<E, A>

Returns

state is Ok<A>

Example

if (Op.is.ok(outcome)) {
  render(outcome.value);
}

is.pending

pending: <E, A>(state) => state is Pending = isPending

Type guard that checks if an Op state is Pending (actively executing).

Type Parameters

E

E

A

A

Parameters

state

State<E, A>

Returns

state is Pending

Example

if (Op.is.pending(manager.state)) {
  showSpinner();
}

is.queued

queued: <E, A>(state) => state is Queued = isQueued

Type guard that checks if an Op state is Queued (waiting in a concurrency queue).

Type Parameters

E

E

A

A

Parameters

state

State<E, A>

Returns

state is Queued

Example

if (Op.is.queued(manager.state)) {
  console.log("Position in queue:", manager.state.position);
}

is.retrying

retrying: <E, A>(state) => state is Retrying<E> = isRetrying

Type guard that checks if an Op state is Retrying after a failure.

Type Parameters

E

E

A

A

Parameters

state

State<E, A>

Returns

state is Retrying<E>

Example

if (Op.is.retrying(manager.state)) {
  console.log("Retry attempt:", manager.state.attempt);
}

lift

lift: <I, A>(f) => Op<I, unknown, A>

Type Parameters

I

I

A

A

Parameters

f

(input, signal) => Promise<A>

Returns

Op<I, unknown, A>

make

make: object

make.err

err: <E>(error) => Err<E> = makeErr

Creates an Err outcome with the given error.

Type Parameters

E

E

Parameters

error

E

Returns

Err<E>

Example

Op.make.err("Something went wrong"); // { kind: "OpErr", error: "Something went wrong" }

make.nil

nil: (reason) => Nil = makeNil

Creates a Nil outcome with the given cancellation/drop reason.

Parameters

reason

NilReason

Returns

Nil

Example

Op.make.nil("aborted"); // { kind: "OpNil", reason: "aborted" }

make.ok

ok: <A>(value) => Ok<A> = makeOk

Creates an Ok outcome with the given value.

Type Parameters

A

A

Parameters

value

A

Returns

Ok<A>

Example

Op.make.ok(42); // { kind: "OpOk", value: 42 }

map

map: <E, A, B>(f) => (outcome) => Outcome<E, B>

Type Parameters

E

E

A

A

B

B

Parameters

f

(a) => B

Returns

(outcome) => Outcome<E, B>

mapError

mapError: <E, F, A>(f) => (outcome) => Outcome<F, A>

Type Parameters

E

E

F

F

A

A

Parameters

f

(e) => F

Returns

(outcome) => Outcome<F, A>

match

match: <E, A, B>(cases) => (outcome) => B

Type Parameters

E

E

A

A

B

B

Parameters

cases

err

(e) => B

nil

() => B

ok

(a) => B

Returns

(outcome) => B

race

race: <E, A>(invocations) => Deferred<Outcome<E, A>>

Type Parameters

E

E

A

A

Parameters

invocations

readonly Deferred<Outcome<E, A>>[]

Returns

Deferred<Outcome<E, A>>

recover

recover: <E, A, B>(f) => (outcome) => Outcome<E, A | B>

Type Parameters

E

E

A

A

B

B

Parameters

f

(e) => Outcome<E, B>

Returns

(outcome) => Outcome<E, A | B>

tap

tap: <E, A>(f) => (outcome) => Outcome<E, A>

Type Parameters

E

E

A

A

Parameters

f

(a) => void

Returns

(outcome) => Outcome<E, A>

to

to: object

to.Maybe

Maybe: <E, A>(outcome) => Maybe<A>

Type Parameters

E

E

A

A

Parameters

outcome

Outcome<E, A>

Returns

Maybe<A>

to.Result

Result: <E, A>(onNil) => (outcome) => Result<E, A>

Type Parameters

E

E

A

A

Parameters

onNil

() => E

Returns

(outcome) => Result<E, A>

wire

wire: <I, E, A, S>(source, f) => () => void

Type Parameters

I

I

E

E

A

A

S

S extends State<E, A>

Parameters

source

Manager<I, E, A, S>

f

(a) => void

Returns

() => void