Op

Op: object

Defined in: Core/Op.ts:114

Type Declaration

interpret

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

Interprets an Op blueprint with a concurrency and lifecycle strategy, returning a Manager.

Type Parameters

Args

Args extends readonly unknown[]

E

E

A

A

O

O extends AllInterpretOptions<Args, E>

Parameters

op

Op<Args, E, A>

options

O

Returns

InterpretResult<Args, E, A, O>

See

Op.make to construct an Op blueprint.

Example

const manager = Op.interpret(fetchUser, { strategy: "restartable" });

is

is: object

is.idle

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

Type guard that checks if an Op state is Idle.

Type Parameters

E

E = unknown

A

A = unknown

Parameters

state

State<E, A>

Returns

state is Idle

See

• Op.is.pending to check if an Op is actively executing.
• Op.is.settled to check if an Op has completed execution.

Example

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

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 = unknown

A

A = unknown

Parameters

state

State<E, A>

Returns

state is Pending

See

• Op.is.idle to check if an Op is waiting to execute.
• Op.is.settled to check if an Op has completed execution.

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 = unknown

A

A = unknown

Parameters

state

State<E, A>

Returns

state is Queued

See

Op.is.pending to check if an Op is actively executing.

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>

See

Op.is.pending to check if an Op is actively executing.

Example

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

is.settled

settled: <E, A>(state) => state is Outcome<E, A> = isSettled

Type guard that checks if an Op state has settled into an outcome (Ok, Err, or Nil).

Type Parameters

E

E

A

A

Parameters

state

State<E, A>

Returns

state is Outcome<E, A>

See

• Op.is.pending to check if an Op is actively executing.
• Op.is.idle to check if an Op has not yet run.

Example

if (Op.is.settled(manager.state)) {
  console.log("Operation completed with outcome:", manager.state.kind);
}

lift

lift: {<Fn>(factory, options?): Op<Parameters<Fn>, unknown, Awaited<ReturnType<Fn>>>; <Input, Out>(factory, options?): Op<NormalizeArgs<Input>, unknown, Awaited<Out>>; <Args, Out>(factory, options?): Op<Args, unknown, Awaited<Out>>; } = liftFn

Lifts an async action into an Op blueprint without requiring explicit error transformation. Unknown errors thrown by the async action are passed through untyped.

Arguments to the returned function can be inferred automatically or provided as explicit generics:

• Op.lift((signal) => (opts: Payload) => ...) (inferred)
• Op.lift<Payload, User>((signal) => (opts) => ...) (explicit input/output)
• Op.lift<typeof apiFn>((signal) => apiFn) (explicit function signature)

Call Signature

<Fn>(factory, options?): Op<Parameters<Fn>, unknown, Awaited<ReturnType<Fn>>>

Type Parameters

Fn

Fn extends (…args) => unknown

Parameters

factory

(signal) => Fn

options?

id?

string

Returns

Op<Parameters<Fn>, unknown, Awaited<ReturnType<Fn>>>

Call Signature

<Input, Out>(factory, options?): Op<NormalizeArgs<Input>, unknown, Awaited<Out>>

Type Parameters

Input

Input

Out

Out

Parameters

factory

(signal) => (…args) => Out | PromiseLike<Out>

options?

id?

string

Returns

Op<NormalizeArgs<Input>, unknown, Awaited<Out>>

Call Signature

<Args, Out>(factory, options?): Op<Args, unknown, Awaited<Out>>

Type Parameters

Args

Args extends readonly unknown[]

Out

Out

Parameters

factory

(signal) => (…args) => Out | PromiseLike<Out>

options?

id?

string

Returns

Op<Args, unknown, Awaited<Out>>

See

Op.make to construct an Op with a typed error transformation.

Example

const fetchOp = Op.lift((signal) => (url: string) => fetch(url, { signal }));

make

make: {<Fn, E>(factory, options): Op<Parameters<Fn>, E, Awaited<ReturnType<Fn>>>; <Input, Out, E>(factory, options): Op<NormalizeArgs<Input>, E, Awaited<Out>>; <Args, Out, E>(factory, options): Op<Args, E, Awaited<Out>>; } = makeFn

Creates an Op blueprint from a signal-accepting factory function that returns the async action, along with an error mapping handler.

Arguments to the returned function can be inferred automatically or provided as explicit generics:

• Op.make((signal) => (opts: Payload) => ...) (inferred)
• Op.make<Payload, User>((signal) => (opts) => ...) (explicit input/output)
• Op.make<typeof apiFn>((signal) => apiFn) (explicit function signature)

Call Signature

<Fn, E>(factory, options): Op<Parameters<Fn>, E, Awaited<ReturnType<Fn>>>

Type Parameters

Fn

Fn extends (…args) => unknown

E

E = unknown

Parameters

factory

(signal) => Fn

options

id?

string

onError

(error) => E

Returns

Op<Parameters<Fn>, E, Awaited<ReturnType<Fn>>>

Call Signature

<Input, Out, E>(factory, options): Op<NormalizeArgs<Input>, E, Awaited<Out>>

Type Parameters

Input

Input

Out

Out

E

E = unknown

Parameters

factory

(signal) => (…args) => Out | PromiseLike<Out>

options

id?

string

onError

(error) => E

Returns

Op<NormalizeArgs<Input>, E, Awaited<Out>>

Call Signature

<Args, Out, E>(factory, options): Op<Args, E, Awaited<Out>>

Type Parameters

Args

Args extends readonly unknown[]

Out

Out

E

E = unknown

Parameters

factory

(signal) => (…args) => Out | PromiseLike<Out>

options

id?

string

onError

(error) => E

Returns

Op<Args, E, Awaited<Out>>

See

Op.lift to construct an Op without explicit error transformation.

Example

const fetchUser = Op.make(
  (signal) => (id: string) => fetch(`/users/${id}`, { signal }).then(r => r.json() as Promise<User>),
  { onError: (error) => new ApiError(error) },
);

Outcome

Outcome: object = OpOutcome

Settled outcome value constructors, type guards, eliminators, and combinators.

Outcome.chain

chain: <A, B, E2>(transform) => <E1>(outcome) => Outcome<E2 | E1, B>

Sequences an operation that produces an Op.Outcome if the current outcome is Ok.

Type Parameters

A

A

B

B

E2

E2 = never

Parameters

transform

(value) => Outcome<E2, B>

Returns

<E1>(outcome) => Outcome<E2 | E1, B>

See

Op.Outcome.map to transform the inner value without returning a new Op.Outcome.

Example

pipe(outcome, Op.Outcome.chain((val) => validate(val)));

Outcome.from

from: object

Outcome.from.Maybe

Maybe: <A>(maybe, onNone?) => Outcome<never, A>

Creates an Op.Outcome from a Maybe, mapping Some to OpOk and None to OpNil.

Type Parameters

A

A

Parameters

maybe

Maybe<A>

The Maybe to convert.

onNone?

() => NilReason

Optional callback returning the cancellation or drop reason (defaults to “dropped”).

Returns

Outcome<never, A>

See

Op.Outcome.to.Maybe to convert an outcome to a Maybe.

Example

const outcome = Op.Outcome.from.Maybe(Maybe.make.some(42));
// { kind: "OpOk", value: 42 }

const dropped = Op.Outcome.from.Maybe(Maybe.make.none(), () => "aborted");
// { kind: "OpNil", reason: "aborted" }

Outcome.from.Result

Result: <E, A>(result) => Outcome<E, A>

Creates an Op.Outcome from a Result, mapping Ok to OpOk and Err to OpErr.

Type Parameters

E

E

A

A

Parameters

result

Result<E, A>

Returns

Outcome<E, A>

See

Op.Outcome.to.Result to convert an outcome to a Result.

Example

const outcome = Op.Outcome.from.Result(Result.make.ok(42));
// { kind: "OpOk", value: 42 }

Outcome.getOrElse

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

Returns the value if Ok, otherwise executes the fallback function and returns its result.

Type Parameters

B

B

Parameters

fallback

() => B

Returns

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

Example

pipe(outcome, Op.Outcome.getOrElse(() => defaultValue));

Outcome.is

is: object

Outcome.is.err

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

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

Type Parameters

E

E

A

A

Parameters

stateOrOutcome

State<E, A>

Returns

stateOrOutcome is Err<E>

See

• Op.Outcome.is.ok to check if an outcome or state is Ok.
• Op.Outcome.is.nil to check if an outcome or state is Nil.

Example

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

Outcome.is.nil

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

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

Type Parameters

E

E

A

A

Parameters

stateOrOutcome

State<E, A>

Returns

stateOrOutcome is Nil

See

• Op.Outcome.is.ok to check if an outcome or state is Ok.
• Op.Outcome.is.err to check if an outcome or state is Err.

Example

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

Outcome.is.ok

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

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

Type Parameters

E

E

A

A

Parameters

stateOrOutcome

State<E, A>

Returns

stateOrOutcome is Ok<A>

See

• Op.Outcome.is.err to check if an outcome or state is Err.
• Op.Outcome.is.nil to check if an outcome or state is Nil.

Example

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

Outcome.make

make: object

Outcome.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>

See

• Op.Outcome.make.ok to create an Ok outcome.
• Op.Outcome.make.nil to create a Nil outcome.

Example

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

Outcome.make.nil

nil: (reason) => Nil = makeNil

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

Parameters

reason

NilReason

Returns

Nil

See

• Op.Outcome.make.ok to create an Ok outcome.
• Op.Outcome.make.err to create an Err outcome.

Example

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

Outcome.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>

See

• Op.Outcome.make.err to create an Err outcome.
• Op.Outcome.make.nil to create a Nil outcome.

Example

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

Outcome.map

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

Transforms the value inside an Ok outcome using the provided function.

Type Parameters

A

A

B

B

Parameters

transform

(value) => B

Returns

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

See

• Op.Outcome.chain to sequence operations that themselves return an Op.Outcome.
• Op.Outcome.mapError to transform the error inside an Err outcome.

Example

pipe(outcome, Op.Outcome.map((x) => x * 2));

Outcome.mapError

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

Transforms the error inside an Err outcome using the provided function.

Type Parameters

E

E

F

F

Parameters

transform

(error) => F

Returns

<A>(outcome) => Outcome<F, A>

See

Op.Outcome.map to transform the value inside an Ok outcome.

Example

pipe(outcome, Op.Outcome.mapError((err) => new CustomError(err)));

Outcome.match

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

Matches on an Op outcome by providing handlers for each variant.

Type Parameters

E

E

A

A

B

B

Parameters

cases

err

(error) => B

nil

(reason) => B

ok

(value) => B

Returns

(outcome) => B

Example

pipe(
  outcome,
  Op.Outcome.match({
    ok: (value) => `Value: ${value}`,
    err: (error) => `Error: ${error}`,
    nil: (reason) => `Cancelled: ${reason}`,
  }),
);

Outcome.recover

recover: <E1, B, E2>(handler) => <A>(outcome) => Outcome<E2, B | A>

Recovers from an Err outcome by applying a recovery function that returns a new Op.Outcome.

Type Parameters

E1

E1

B

B

E2

E2 = never

Parameters

handler

(error) => Outcome<E2, B>

Returns

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

Example

pipe(outcome, Op.Outcome.recover((err) => Op.Outcome.make.ok(fallbackValue)));

Outcome.tap

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

Executes a side effect if the outcome is Ok and returns the original outcome unchanged.

Type Parameters

A

A

Parameters

sideEffect

(value) => void

Returns

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

See

Op.Outcome.tapError to execute a side effect on Err outcomes.

Example

pipe(outcome, Op.Outcome.tap((val) => console.log(val)));

Outcome.tapError

tapError: <E>(sideEffect) => <A>(outcome) => Outcome<E, A>

Executes a side effect if the outcome is Err and returns the original outcome unchanged.

Type Parameters

E

E

Parameters

sideEffect

(error) => void

Returns

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

See

Op.Outcome.tap to execute a side effect on Ok outcomes.

Example

pipe(outcome, Op.Outcome.tapError((err) => console.error(err)));

Outcome.to

to: object

Outcome.to.Maybe

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

Converts an Op.Outcome to a Maybe, mapping Ok to Some and both Err and Nil to None.

Type Parameters

E

E = never

A

A = never

Parameters

outcome

Outcome<E, A>

Returns

Maybe<A>

See

• Op.Outcome.to.Result to convert an outcome to a Result.
• Op.Outcome.from.Maybe to create an outcome from a Maybe.

Example

pipe(outcome, Op.Outcome.to.Maybe);

Outcome.to.Result

Result: <E2>(onNil) => <E1, A>(outcome) => Result<E2 | E1, A>

Converts an Op.Outcome to a Result.

Type Parameters

E2

E2

Parameters

onNil

(reason) => E2

Returns

<E1, A>(outcome) => Result<E2 | E1, A>

See

• Op.Outcome.to.Maybe to convert an outcome to a Maybe.
• Op.Outcome.from.Result to create an outcome from a Result.

Example

pipe(outcome, Op.Outcome.to.Result((reason) => new Error(`Skipped: ${reason}`)));

wire

wire: <Args, E, A, S>(source, sideEffect) => () => void

Subscribes to an Op manager and executes a side-effect whenever the manager emits an Ok outcome. Returns an unsubscribe callback.

Type Parameters

Args

Args extends readonly unknown[]

E

E

A

A

S

S extends State<E, A>

Parameters

source

Manager<Args, E, A, S>

sideEffect

(value) => void

Returns

() => void

Example

const unsubscribe = Op.wire(userManager, (user) => analyticsManager.run(user.id));