Op

Op: object

Defined in: Core/Op.ts:113

Type Declaration

interpret

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

Creates a manager that runs an operation using the selected concurrency strategy.

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);
}

make

make: <Args, E, A>(task, options?) => Op<Args, E, A> = makeFn

Turns a task factory into an operation blueprint.

The factory receives the arguments passed to manager.run(...) and returns a Task.Result, so the error channel is already typed before Op sees it. Map raw promises at the boundary with Task.Result.tryCatch; Op never inspects thrown values.

Type Parameters

Args

Args extends readonly unknown[]

E

E

A

A

Parameters

task

(…args) => Result<E, A>

options?

id?

string

Returns

Op<Args, E, A>

See

Op.interpret to attach a concurrency strategy to the blueprint.

Example

const fetchUser = Op.make((id: string) =>
  Task.Result.tryCatch(
    (signal) => fetch(`/users/${id}`, { signal }).then((r) => r.json() as Promise<User>),
    { onError: (error): ApiError => new ApiError(String(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));