Task

Task: object

Type Declaration

abortable

abortable: <A>(factory) => object

Creates a Task paired with an abort handle. Calling abort() cancels the current in-flight call immediately. Unlike a one-shot abort, calling task() again after abort() starts a fresh call with a new signal.

Each invocation of task() automatically cancels the previous in-flight call, making it safe to call repeatedly (e.g. on user input) without leaking promises.

If an outer signal is also present (passed at the call site), aborting it propagates into the internal controller.

Type Parameters

A

A

Parameters

factory

(signal) => Thenable<A>

Returns

object

abort

abort: () => void

Returns

void

task

task: Task<A>

Example

const { task: poll, abort } = Task.abortable(
  (signal) => waitForEvent(bus, "ready", { signal }),
);

onUnmount(abort);
await poll();

all

all: <T>(tasks, options?) => Task<{ [K in string | number | symbol]: T[K] extends Task<A> ? A : never }>

Runs multiple Tasks in parallel and collects their results. An optional concurrency option limits the number of tasks executing at any given time; a provided nonpositive or non-integer value clamps to 1, and omitting the option runs all tasks unbounded. An optional signal passed at the call site is forwarded to every task, including queued tasks.

Type Parameters

T

T extends readonly Task<unknown>[]

Parameters

tasks

readonly [T]

options?

concurrency?

number

Returns

Task<{ [K in string | number | symbol]: T[K] extends Task<A> ? A : never }>

See

Task.sequential to run an array of Tasks one after another in order.

Example

Task.all([loadConfig, detectLocale, loadTheme])();
// Deferred<[Config, string, Theme]>

Task.all([loadConfig, detectLocale, loadTheme], { concurrency: 2 })();

apply

apply: <A>(arg) => <B>(task) => Task<B>

Applies a function wrapped in a Task to a value wrapped in a Task. Both Tasks run in parallel.

Type Parameters

A

A

Parameters

arg

Task<A>

Returns

<B>(task) => Task<B>

See

Task.all to run multiple independent Tasks in parallel.

Example

const add = (a: number) => (b: number) => a + b;
pipe(
  Task.make(add),
  Task.apply(Task.make(5)),
  Task.apply(Task.make(3))
)(); // Deferred<8>

assign

assign: <K, A, B>(key, transform) => (task) => Task<A & { [P in string]: B }>

Evaluates a new Task using the current accumulator and attaches the output to a new key. The key must not already exist on the accumulator — use map to update an existing field. The accumulator is expected to be a plain object (own enumerable properties).

Type Parameters

K

K extends string

A

A extends object

B

B

Parameters

key

K extends KeysOfUnion<A> ? never : K

transform

(value) => Task<B>

Returns

(task) => Task<A & { [P in string]: B }>

Example

pipe(
  Task.make({ a: 1 }),
  Task.assign("b", ({ a }) => Task.make(a + 1))
); // Task({ a: 1, b: 2 })

assignTo

assignTo: <K>(key) => <A>(task) => Task<{ [P in string]: A }>

Converts a Task value into an object containing a single property. Initiates the pipeline accumulator record.

Type Parameters

K

K extends string

Parameters

key

K

Returns

<A>(task) => Task<{ [P in string]: A }>

Example

pipe(Task.make(42), Task.assignTo("value")); // Task({ value: 42 })

chain

chain: <A, B>(transform) => (task) => Task<B>

Chains Task computations. Passes the resolved value of the first Task to transform.

Type Parameters

A

A

B

B

Parameters

transform

(value) => Task<B>

Returns

(task) => Task<B>

See

Task.map to transform the resolved value without creating a new Task.

Example

const readUserId: Task<string> = Task.make(session.userId);
const loadPrefs = (id: string): Task<Preferences> =>
  Task.make(prefsCache.get(id));

pipe(
  readUserId,
  Task.chain(loadPrefs)
)(); // Deferred<Preferences>

delay

delay: (duration) => <A>(task) => Task<A>

Delays the execution of a Task by the specified duration. Useful for debouncing or rate limiting.

Parameters

duration

Duration

Returns

<A>(task) => Task<A>

Example

pipe(
  Task.make(42),
  Task.delay(Duration.seconds(1))
)(); // Resolves after 1 second

from

from: object

from.sync

sync: <A>(fn) => Task<A> = syncTask

Creates a Task from a lazy synchronous thunk. Unlike Task.make(f()), from.sync does not evaluate f until the Task is called.

Type Parameters

A

A

Parameters

fn

() => A

Returns

Task<A>

Example

const t = Task.from.sync(() => Date.now()); // Date.now() not called yet
const ts = await t(); // called here, every time

make

make: <A>(value) => Task<A> = makeTask

Creates a Task that immediately resolves to the given value.

Type Parameters

A

A

Parameters

value

A

Returns

Task<A>

Example

const task = Task.make(42);
const value = await task(); // 42

map

map: <A, B>(transform) => (task) => Task<B>

Transforms the value inside a Task.

Type Parameters

A

A

B

B

Parameters

transform

(value) => B

Returns

(task) => Task<B>

See

Task.chain to sequence operations that return a Task.

Example

pipe(
  Task.make(5),
  Task.map(n => n * 2)
)(); // Deferred<10>

Maybe

Maybe: object = TaskMaybe

Maybe.apply

apply: <A>(arg) => <B>(task) => Maybe<B>

Applies a function wrapped in a Task.Maybe to a value wrapped in a Task.Maybe. Both Tasks run in parallel.

Type Parameters

A

A

Parameters

arg

Maybe<A>

Returns

<B>(task) => Maybe<B>

Example

const add = (a: number) => (b: number) => a + b;
pipe(
  Task.Maybe.make.some(add),
  Task.Maybe.apply(Task.Maybe.make.some(5)),
  Task.Maybe.apply(Task.Maybe.make.some(3)),
); // Task.Maybe resolving to Some(8)

Maybe.assign

assign: <K, A, B>(key, transform) => (task) => Maybe<A & { [P in string]: B }>

Evaluates a new Task.Maybe using the current accumulator and attaches the output to a new key.

Type Parameters

K

K extends string

A

A extends object

B

B

Parameters

key

K extends KeysOfUnion<A> ? never : K

transform

(value) => Maybe<B>

Returns

(task) => Maybe<A & { [P in string]: B }>

Example

pipe(
  Task.Maybe.make.some({ a: 1 }),
  Task.Maybe.assign("b", ({ a }) => Task.Maybe.make.some(a + 1))
); // Task.Maybe({ a: 1, b: 2 })

Maybe.assignTo

assignTo: <K>(key) => <A>(task) => Maybe<{ [P in string]: A }>

Lifts a Task.Maybe value into an accumulator object.

Type Parameters

K

K extends string

Parameters

key

K

Returns

<A>(task) => Maybe<{ [P in string]: A }>

Example

pipe(Task.Maybe.make.some(42), Task.Maybe.assignTo("value")); // Task.Maybe({ value: 42 })

Maybe.chain

chain: <A, B>(transform) => (task) => Maybe<B> = chainTaskMaybe

Chains Task.Maybe computations. If the first resolves to Some, passes the value to transform. If the first resolves to None, propagates None.

Type Parameters

A

A

B

B

Parameters

transform

(value) => Maybe<B>

Returns

(task) => Maybe<B>

See

Task.Maybe.map to transform the inner value without returning a new Task.Maybe.

Example

pipe(
  findUser("123"),
  Task.Maybe.chain(user => findOrg(user.orgId))
)();

Maybe.filter

filter: {<A, B>(refinement): (task) => Maybe<B>; <A>(predicate): (task) => Maybe<A>; }

Filters the value inside a Task.Maybe. Returns None if the predicate fails.

Call Signature

<A, B>(refinement): (task) => Maybe<B>

Type Parameters

A

A

B

B

Parameters

(value) => value is B

Returns

(task) => Maybe<B>

Call Signature

<A>(predicate): (task) => Maybe<A>

Type Parameters

A

A

Parameters

predicate

(value) => boolean

Returns

(task) => Maybe<A>

Example

pipe(
  Task.Maybe.make.some(42),
  Task.Maybe.filter(n => n > 50),
); // Task.Maybe resolving to None

Maybe.from

from: object

Maybe.from.Maybe

Maybe: <A>(maybe) => Maybe<A>

Lifts a Maybe into a Task.Maybe.

Type Parameters

A

A

Parameters

maybe

Maybe<A>

Returns

Maybe<A>

Example

Task.Maybe.from.Maybe(Maybe.make.some(42));

Maybe.from.nullable

nullable: <A>(value) => Maybe<NonNullable<A>>

Creates a Task.Maybe from a nullable value. Returns Some if the value is not null or undefined, None otherwise.

Type Parameters

A

A

Parameters

value

A | null | undefined

Returns

Maybe<NonNullable<A>>

Example

Task.Maybe.from.nullable(42);   // resolves to Some(42)
Task.Maybe.from.nullable(null); // resolves to None

Maybe.from.Result

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

Creates a Task.Maybe from a Result. Ok becomes Some, Error becomes None (the error value is discarded).

Type Parameters

E

E

A

A

Parameters

result

Result<E, A>

Returns

Maybe<A>

Example

Task.Maybe.from.Result(Result.make.ok(42)); // resolves to Some(42)
Task.Maybe.from.Result(Result.make.err("e")); // resolves to None

Maybe.from.Task

Task: <A>(task) => Maybe<A>

Lifts a Task into a Task.Maybe by wrapping its result in Some.

Type Parameters

A

A

Parameters

task

Task<A>

Returns

Maybe<A>

Example

Task.Maybe.from.Task(Task.make(42)); // resolves to Some(42)

Maybe.getOrElse

getOrElse: <B>(fallback) => <A>(task) => Task<B | A>

Returns the value or a default if the Task.Maybe resolves to None. The default can be a different type, widening the result to Task<A | B>.

Type Parameters

B

B

Parameters

fallback

() => B

Returns

<A>(task) => Task<B | A>

Example

pipe(
  Task.Maybe.make.none(),
  Task.Maybe.getOrElse(() => 0),
); // Task resolving to 0

Maybe.make

make: object

Wraps a value in a Some inside a Task.

Example

const task = Task.Maybe.make.some(42);
const res = await task(); // Some(42)

Maybe.make.none

none: <A>() => Maybe<A> = makeNone

Creates a Task.Maybe that resolves to None.

Type Parameters

A

A = never

Returns

Maybe<A>

Example

const task = Task.Maybe.make.none();
const res = await task(); // None

Maybe.make.some

some: <A>(value) => Maybe<A> = makeSome

Creates a Task.Maybe that resolves to Some(value).

Type Parameters

A

A

Parameters

value

A

Returns

Maybe<A>

Example

const task = Task.Maybe.make.some(42);
const res = await task(); // Some(42)

Maybe.map

map: <A, B>(transform) => (task) => Maybe<B> = mapTaskMaybe

Transforms the value inside a Task.Maybe.

Type Parameters

A

A

B

B

Parameters

transform

(value) => B

Returns

(task) => Maybe<B>

See

Task.Maybe.chain to sequence operations that themselves return a Task.Maybe.

Example

pipe(
  Task.Maybe.make.some(5),
  Task.Maybe.map(n => n * 2),
); // Task.Maybe resolving to Some(10)

Maybe.match

match: <A, B>(cases) => (task) => Task<B>

Pattern matches on a Task.Maybe, returning a Task of the result.

Type Parameters

A

A

B

B

Parameters

cases

none

() => B

some

(value) => B

Returns

(task) => Task<B>

Example

pipe(
  findUser("123"),
  Task.Maybe.match({
    some: user => `Hello, ${user.name}`,
    none: () => "User not found"
  })
)();

Maybe.recover

recover: <B>(fallback) => <A>(task) => Maybe<B | A>

Recovers from a None state by providing a fallback Task.Maybe.

Type Parameters

B

B = never

Parameters

fallback

() => Maybe<B>

Returns

<A>(task) => Maybe<B | A>

Example

pipe(
  Task.Maybe.make.none(),
  Task.Maybe.recover(() => Task.Maybe.make.some(42))
); // Task.Maybe(42)

Maybe.run

run: (signal?) => <A>(task) => Deferred<Maybe<A>>

Executes a Task.Maybe with an optional signal, returning Deferred<Maybe<A>>. Use as a terminal step in a pipe chain.

Parameters

signal?

AbortSignal

Returns

<A>(task) => Deferred<Maybe<A>>

Example

const result = await pipe(
  Task.Maybe.make.some(42),
  Task.Maybe.run(),
);

Maybe.struct

struct: <T>(fields) => Maybe<{ [K in string | number | symbol]: T[K] extends Maybe<A> ? A : never }>

Combines a record of Task.Maybes into a single Task.Maybe of a record. Own string and symbol keys are processed in key order; inherited fields are not supported. Evaluates fields in parallel and returns None if any task resolves to None.

Type Parameters

T

T extends Record<string, Maybe<unknown>>

Parameters

fields

T

Returns

Maybe<{ [K in string | number | symbol]: T[K] extends Maybe<A> ? A : never }>

Example

Task.Maybe.struct({
  name: Task.Maybe.make.some("Alice"),
  age: Task.Maybe.make.some(30)
}); // Task.Maybe({ name: "Alice", age: 30 })

Maybe.tap

tap: <A>(sideEffect) => (task) => Maybe<A>

Executes a side effect on the value without changing the Task.Maybe. Useful for logging or debugging.

Type Parameters

A

A

Parameters

sideEffect

(value) => void

Returns

(task) => Maybe<A>

Example

pipe(
  Task.Maybe.make.some(42),
  Task.Maybe.tap(n => console.log("Value:", n)),
);

Maybe.to

to: object

Maybe.to.Result

Result: <E>(onNone) => <A>(task) => Result<E, A>

Converts a Task.Maybe to a Task.Result, using onNone to produce the error value.

Type Parameters

E

E

Parameters

onNone

() => E

Returns

<A>(task) => Result<E, A>

Example

pipe(
  findUser("123"),
  Task.Maybe.to.Result(() => "User not found")
);

Maybe.tryCatch

tryCatch: <A>(fn) => Maybe<A>

Creates a Task.Maybe from a Promise-returning function. Returns Some if the promise resolves, None if the factory throws or the promise rejects. The factory optionally receives an AbortSignal forwarded from the call site.

Type Parameters

A

A

Parameters

fn

(signal?) => Thenable<A>

Returns

Maybe<A>

Example

const fetchUser = Task.Maybe.tryCatch((signal) =>
  fetch("/user/1", { signal }).then(r => r.json())
);

memoize

memoize: <A>(task) => Task<A>

Creates a memoized version of a Task. The task runs at most once, and the shared result is reused by every later call. Because the run is shared, it is not tied to any caller’s signal: cancellation of a memoized task is a no-op.

Type Parameters

A

A

Parameters

task

Task<A>

Returns

Task<A>

Example

const loadToken = Task.memoize(loadAuthToken);
const token1 = await loadToken(); // loads token
const token2 = await loadToken(); // returns cached token immediately

poll

poll: <A>(options) => (task) => Task<A>

Polls a Task repeatedly until the result satisfies a predicate, returning that result. An optional delay duration can be inserted between polling runs. An optional attempts cap of N calls stops the loop after N calls — the last value is returned regardless of whether the predicate was satisfied. attempts is a positive integer.

Type Parameters

A

A

Parameters

options

attempts?

number

delay?

Duration

until

(value) => boolean

Returns

(task) => Task<A>

See

Task.repeat to run a Task a fixed number of times.

Example

pipe(
  checkStatus,
  Task.poll({ until: (s) => s === "ready", delay: Duration.milliseconds(500) })
)(); // polls every 500ms until status is "ready"

race

race: (<T>(tasks) => Task<TaskValue<T[number]>>) & (<A>(tasks) => Task<A>) = raceTask

Resolves with the value of the first Task to complete. All Tasks start immediately. When one resolves, the other tasks are cancelled (aborted) downstream.

Example

const fast = Task.make("fast");
const slow = Task.delay(Duration.milliseconds(200))(Task.make("slow"));

await Task.race([fast, slow])(); // "fast"

repeat

repeat: (options) => <A>(task) => Task<readonly A[]>

Runs a Task a fixed number of times sequentially, collecting all results into an array. An optional delay duration can be inserted between runs.

Parameters

options

delay?

Duration

times

number

Returns

<A>(task) => Task<readonly A[]>

See

Task.poll to repeatedly run a Task until a predicate is satisfied.

Example

pipe(
  pollSensor,
  Task.repeat({ times: 5, delay: Duration.seconds(1) })
)(); // Task<Reading[]> — 5 readings, one per second

Result

Result: object = TaskResult

Result.all

all: <T>(tasks, options?) => Result<Aborted | TaskErrOf<T[number]>, { [K in string | number | symbol]: T[K] extends Result<unknown, A> ? A : never }>

Runs multiple fallible tasks in parallel and collects their successful values into a tuple.

An optional concurrency option limits the number of tasks executing at any given time; a provided nonpositive or non-integer value clamps to 1, and omitting the option runs all tasks unbounded.
Short-circuits on the first Err: cancels all currently active tasks and avoids starting queued tasks.
If caller’s signal is already aborted, returns Aborted immediately without starting work.
If caller’s signal aborts during execution, cancels active work and settles immediately with Aborted.

Type Parameters

T

T extends readonly Result<unknown, unknown>[]

Parameters

tasks

readonly [T]

options?

concurrency?

number

Returns

Result<Aborted | TaskErrOf<T[number]>, { [K in string | number | symbol]: T[K] extends Result<unknown, A> ? A : never }>

See

Task.Result.sequential to run an array of fallible tasks one at a time in order.
Task.Result.allSettled to collect all outcomes without short-circuiting on failure.

Example

const result = await Task.Result.all([loadUser, loadPreferences])();
if (Result.is.ok(result)) {
  const [user, preferences] = result.value;
}

Result.allSettled

allSettled: <T>(tasks) => Task<{ [K in string | number | symbol]: T[K] extends Result<E, A> ? Result<E, A> : never }>

Runs a list of fallible tasks in parallel and collects all outcomes (Ok and Err) without short-circuiting on failure.

Type Parameters

T

T extends readonly Result<any, any>[]

Parameters

tasks

readonly [T]

Returns

Task<{ [K in string | number | symbol]: T[K] extends Result<E, A> ? Result<E, A> : never }>

Example

const results = await Task.Result.allSettled([task1, task2, task3])();
// [Ok(val1), Err(err2), Ok(val3)]

Result.apply

apply: <E2, A>(arg) => <B, E1>(task) => Result<E2 | E1, B>

Applies a function wrapped in a Task.Result to a value wrapped in a Task.Result. Both Tasks run in parallel.

Type Parameters

E2

E2 = never

A

A = unknown

Parameters

arg

Result<E2, A>

Returns

<B, E1>(task) => Result<E2 | E1, B>

Example

const add = (a: number) => (b: number) => a + b;
pipe(
  Task.Result.make.ok(add),
  Task.Result.apply(Task.Result.make.ok(5)),
  Task.Result.apply(Task.Result.make.ok(3)),
); // Task.Result resolving to Ok(8)

Result.assign

assign: <K, E2, A, B>(key, transform) => <E1>(task) => Result<E2 | E1, A & { [P in string]: B }>

Evaluates a new Task.Result using the current accumulator and attaches the output to a new key.

Evaluates a new fallible Task using the current accumulator and attaches the output to a new key. The key must not already exist on the accumulator — use map to update an existing field. The accumulator is expected to be a plain object (own enumerable properties).

Type Parameters

K

K extends string

E2

E2

A

A extends object

B

B

Parameters

key

K extends KeysOfUnion<A> ? never : K

transform

(value) => Result<E2, B>

Returns

<E1>(task) => Result<E2 | E1, A & { [P in string]: B }>

Example

pipe(
  Task.Result.make.ok({ a: 1 }),
  Task.Result.assign("b", ({ a }) => Task.Result.make.ok(a + 1))
); // Task.Result({ a: 1, b: 2 })

Result.assignTo

assignTo: <K>(key) => <E, A>(task) => Result<E, { [P in string]: A }>

Converts a Task.Result value into an object containing a single property. Initiates the pipeline accumulator record.

Type Parameters

K

K extends string

Parameters

key

K

Returns

<E, A>(task) => Result<E, { [P in string]: A }>

Example

pipe(Task.Result.make.ok(42), Task.Result.assignTo("value")); // Task.Result({ value: 42 })

Result.chain

chain: <E2, A, B>(transform) => <E1>(task) => Result<E2 | E1, B> = chainTaskResult

Chains Task.Result computations. If the first succeeds, passes the value to transform. If the first fails, propagates the error.

Type Parameters

E2

E2 = never

A

A = unknown

B

B = unknown

Parameters

transform

(value) => Result<E2, B>

Returns

<E1>(task) => Result<E2 | E1, B>

See

Task.Result.map to transform the inner value without returning a new Task.Result.

Example

const loadUserId: Task.Result<string, number> = Task.Result.make.ok(42);
const loadProfile = (id: number): Task.Result<string, { id: number; name: string }> =>
  Task.Result.make.ok({ id, name: "Alice" });

pipe(
  loadUserId,
  Task.Result.chain(loadProfile),
); // Task.Result resolving to Ok({ id: 42, name: "Alice" })

Result.ensure

ensure: {<A, B, E2>(refinement, onFail): <E1>(task) => Result<E2 | E1, B>; <A, E2>(predicate, onFail): <E1>(task) => Result<E2 | E1, A>; }

Narrows the Ok value with a predicate or type guard. If the predicate returns false, converts the value to an Err using onFail.

Call Signature

<A, B, E2>(refinement, onFail): <E1>(task) => Result<E2 | E1, B>

Type Parameters

A

A

B

B

E2

E2

Parameters

(value) => value is B

onFail

(value) => E2

Returns

<E1>(task) => Result<E2 | E1, B>

Call Signature

<A, E2>(predicate, onFail): <E1>(task) => Result<E2 | E1, A>

Type Parameters

A

A

E2

E2

Parameters

predicate

(value) => boolean

onFail

(value) => E2

Returns

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

Example

pipe(
  Task.Result.make.ok(42),
  Task.Result.ensure(n => n > 50, () => "too small")
); // Task.Result resolving to Err("too small")

Result.from

from: object

Result.from.Maybe

Maybe: <E>(onNone) => <A>(maybe) => Result<E, A>

Creates a Task.Result from a Maybe. Some becomes Ok, None becomes err from onNone.

Type Parameters

E

E

Parameters

onNone

() => E

Returns

<A>(maybe) => Result<E, A>

Example

Task.Result.from.Maybe(() => "empty")(Maybe.make.some(42)); // resolves to Ok(42)
Task.Result.from.Maybe(() => "empty")(Maybe.make.none());   // resolves to Err("empty")

Result.from.nullable

nullable: <E>(onNull) => <A>(value) => Result<E, NonNullable<A>>

Creates a Task.Result from a nullable value. Returns Ok if the value is not null or undefined, err from onNull otherwise.

Type Parameters

E

E

Parameters

onNull

() => E

Returns

<A>(value) => Result<E, NonNullable<A>>

Example

Task.Result.from.nullable(() => "missing")(42);   // resolves to Ok(42)
Task.Result.from.nullable(() => "missing")(null); // resolves to Err("missing")

Result.from.Result

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

Lifts a Result into a Task.Result.

Type Parameters

E

E

A

A

Parameters

result

Result<E, A>

Returns

Result<E, A>

Example

Task.Result.from.Result(Result.make.ok(42)); // resolves to Ok(42)

Result.from.Task

Task: <A>(task) => Result<never, A>

Lifts an infallible Task into a Task.Result with error type never.

Type Parameters

A

A

Parameters

task

Task<A>

Returns

Result<never, A>

Example

Task.Result.from.Task(Task.make(42)); // resolves to Ok(42)

Result.getOrElse

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

Returns the success value or a default value if the Task.Result is an error. The default can be a different type, widening the result to Task<A | B>.

Type Parameters

B

B

Parameters

fallback

() => B

Returns

<A, E>(task) => Task<B | A>

Example

pipe(
  Task.Result.make.err("oops"),
  Task.Result.getOrElse(() => 0),
); // Task resolving to 0

Result.make

make: object

Result.make.err

err: <E>(error) => Result<E, never> = makeErr

Creates a failed Task.Result with the given error.

Type Parameters

E

E

Parameters

error

E

Returns

Result<E, never>

Example

const task = Task.Result.make.err("failed");
const res = await task(); // Err("failed")

Result.make.ok

ok: <A>(value) => Result<never, A> = makeOk

Wraps a value in a successful Task.Result.

Type Parameters

A

A

Parameters

value

A

Returns

Result<never, A>

Example

const task = Task.Result.make.ok(42);
const res = await task(); // Ok(42)

Result.map

map: <A, B>(transform) => <E>(task) => Result<E, B> = mapTaskResult

Transforms the success value inside a Task.Result.

Type Parameters

A

A

B

B

Parameters

transform

(value) => B

Returns

<E>(task) => Result<E, B>

See

Task.Result.chain to sequence operations that themselves return a Task.Result.
Task.Result.mapError to transform the error value instead of the success value.

Example

pipe(
  Task.Result.make.ok(5),
  Task.Result.map(n => n * 2),
); // Task.Result resolving to Ok(10)

Result.mapBoth

mapBoth: <E1, E2, A, B>(onErr, onOk) => (task) => Result<E2, B>

Maps both the Err and Ok channels simultaneously.

Type Parameters

E1

E1

E2

E2

A

A

B

B

Parameters

onErr

(error) => E2

onOk

(value) => B

Returns

(task) => Result<E2, B>

Example

pipe(
  Task.Result.make.ok(42),
  Task.Result.mapBoth(
    (err: string) => new Error(err),
    (n: number) => n * 2
  )
); // Task.Result resolving to Ok(84)

Result.mapError

mapError: <E, F>(transform) => <A>(task) => Result<F, A>

Transforms the error value inside a Task.Result.

Type Parameters

E

E

F

F

Parameters

transform

(error) => F

Returns

<A>(task) => Result<F, A>

See

Task.Result.map to transform the success value instead of the error value.

Example

pipe(
  Task.Result.make.err("not found"),
  Task.Result.mapError(e => `Error: ${e}`),
); // Task.Result resolving to Err("Error: not found")

Result.match

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

Pattern matches on a Task.Result, returning a Task of the result.

Type Parameters

E

E

A

A

B

B

Parameters

cases

err

(error) => B

ok

(value) => B

Returns

(task) => Task<B>

Example

pipe(
  Task.Result.make.ok(42),
  Task.Result.match({
    err: e => `Error: ${e}`,
    ok: v => `Got ${v}`,
  }),
); // Task resolving to "Got 42"

Result.paginate

paginate: <E, A, C>(load) => Result<Aborted | E, readonly A[]>

Runs a cursor-driven loader until a page reports no next cursor, collecting every item.

Pages are requested sequentially, because each cursor comes from the page before it. The first Err ends the run and returns that error; pages already collected are not returned. The loader receives the caller’s signal, and the run settles with Aborted when the signal aborts before the next page starts.

Type Parameters

E

E

A

A

C

C

Parameters

load

(cursor) => Result<E, { items: readonly A[]; next?: C; }>

Returns

Result<Aborted | E, readonly A[]>

See

Task.Result.all to run independent tasks instead of a cursor chain.
Task.Result.poll to repeat one task until its value is ready.

Example

const loadAllIssues = Task.Result.paginate(fetchIssuePage);

const issues = await loadAllIssues();
if (Result.is.ok(issues)) {
  console.log(issues.value.length);
}

Result.poll

poll: <A>(options) => <E>(task) => Result<E, A>

Repeats a fallible task until its value satisfies until, keeping the value that satisfied it.

until, delay, and attempts behave exactly as they do in Task.poll: attempts is a positive integer, and the last value is returned when it runs out. The difference is the error channel: the first Err ends the loop, because retrying a failed attempt belongs to Task.Result.retry.

Type Parameters

A

A

Parameters

options

attempts?

number

delay?

Duration

until

(value) => boolean

Returns

<E>(task) => Result<E, A>

See

Task.poll for the infallible form.
Task.Result.retry to repeat a failed attempt rather than a successful one.

Example

const waitForExport = pipe(
  fetchExportJob,
  Task.Result.poll({ until: (job) => job.status !== "pending", delay: Duration.seconds(2) }),
);

Result.recover

recover: <E1, E2, B>(fallback) => <A>(task) => Result<E2, B | A>

Recovers from an error by providing a fallback Task.Result. The fallback can produce a different success type or resolve with a different error type.

Type Parameters

E1

E1

E2

E2 = never

B

B = never

Parameters

fallback

(error) => Result<E2, B>

Returns

<A>(task) => Result<E2, B | A>

See

Task.Result.recoverUnless to conditionally recover based on the error value.

Example

pipe(
  Task.Result.make.err("disk error"),
  Task.Result.recover(() => Task.Result.make.ok("cached value")),
); // Task.Result resolving to Ok("cached value")

Result.recoverUnless

recoverUnless: <E1, E2, B>(isBlocked, fallback) => <A>(task) => Result<E1 | E2, B | A>

Recovers from an error unless the predicate isBlocked returns true for that error. The fallback can produce a different success type, widening the result to Task.Result<E1 | E2, A | B>.

Type Parameters

E1

E1

E2

E2 = never

B

B = never

Parameters

isBlocked

(error) => boolean

fallback

(error) => Result<E2, B>

Returns

<A>(task) => Result<E1 | E2, B | A>

See

Task.Result.recover for unconditional error recovery.

Example

pipe(
  fetchTask,
  Task.Result.recoverUnless(
    (e) => e === "fatal",
    () => Task.Result.make.ok("fallback")
  )
);

Result.retry

retry: <E>(policy) => <E1, A>(task) => Result<E1, A>

Retries a fallible Task.Result according to a RetryPolicy. If the task succeeds, returns Ok immediately. If the task fails, retries up to policy.attempts times with delays generated by policy. Any optional when predicate or onRetry callback configured on the RetryPolicy will filter retriable errors and emit telemetry events before each backoff delay.

Type Parameters

E

E = unknown

Parameters

policy

RetryPolicy<E>

Returns

<E1, A>(task) => Result<E1, A>

Example

const policy = RetryPolicy.exponential({
  attempts: 3,
  initial: Duration.milliseconds(100),
  when: (err) => isTransient(err),
  onRetry: ({ attempt, error, delay }) => console.warn(`Retry ${attempt}: ${error}`),
});
const retryableFetch = pipe(
  fetchData,
  Task.Result.retry(policy),
);

Result.run

run: (signal?) => <E, A>(task) => Deferred<Result<E, A>>

Executes a Task.Result with an optional signal, returning Deferred<Result<E, A>>. Use as a terminal step in a pipe chain.

Parameters

signal?

AbortSignal

Returns

<E, A>(task) => Deferred<Result<E, A>>

Example

const controller = new AbortController();
const result = await pipe(
    fetchUser("42"),
    Task.Result.chain(user => fetchPosts(user.id)),
    Task.Result.run(controller.signal),
);
if (Result.is.ok(result)) render(result.value);

Result.struct

struct: <T>(fields) => Result<TaskErrOf<T[keyof T]>, { [K in string | number | symbol]: T[K] extends Result<unknown, A> ? A : never }>

Combines a record of Task.Results into a single Task.Result of a record. Own string and symbol keys are processed in key order; inherited fields are not supported. Evaluates all tasks in parallel, forwarding the AbortSignal down to each sub-task. Returns the first Err encountered in key order.

Type Parameters

T

T extends Record<string, Result<unknown, unknown>>

Parameters

fields

T

Returns

Result<TaskErrOf<T[keyof T]>, { [K in string | number | symbol]: T[K] extends Result<unknown, A> ? A : never }>

Example

Task.Result.struct({
  name: Task.Result.make.ok("Alice"),
  age: Task.Result.make.ok(30)
}); // Task.Result({ name: "Alice", age: 30 })

Result.tap

tap: <A>(sideEffect) => <E>(task) => Result<E, A>

Executes a side effect on the success value without changing the Task.Result. Useful for logging or debugging.

Type Parameters

A

A

Parameters

sideEffect

(value) => void

Returns

<E>(task) => Result<E, A>

See

Task.Result.tapError to perform a side effect on the error value.

Example

pipe(
  Task.Result.make.ok({ status: "done" }),
  Task.Result.tap(v => console.log("Success:", v)),
);

Result.tapError

tapError: <E>(sideEffect) => <A>(task) => Result<E, A>

Executes a side effect on the error value without changing the Task.Result. Useful for logging or reporting async errors.

Type Parameters

E

E

Parameters

sideEffect

(error) => void

Returns

<A>(task) => Result<E, A>

See

Task.Result.tap to perform a side effect on the success value.

Example

pipe(
  fetchUser(id),
  Task.Result.tapError(e => console.error("fetch failed:", e)),
  Task.Result.chain(saveToCache),
)

Result.timeout

timeout: <E2>(options) => <E1, A>(task) => Result<E2 | E1, A>

Times out a fallible task, resolving to Err(onTimeout()) if the duration elapses before the task completes.

Type Parameters

E2

E2

Parameters

options

duration

Duration

onTimeout

() => E2

Returns

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

Example

const fetchWithTimeout = pipe(
  fetchTask,
  Task.Result.timeout({ duration: Duration.seconds(5), onTimeout: () => "Request timed out" })
);

Result.to

to: object

Result.to.Maybe

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

Converts a Task.Result to a Task.Maybe, dropping the error value on Err.

Type Parameters

E

E

A

A

Parameters

task

Result<E, A>

Returns

Maybe<A>

Example

const taskResult = Task.Result.make.ok(42);
const taskMaybe = pipe(taskResult, Task.Result.to.Maybe);

Result.tryCatch

tryCatch: <E, A>(fn, options) => Result<E, A>

Creates a Task.Result from a Promise-returning thunk that may throw or reject. Catches any errors and transforms them using the onError function into an Err. The thunk optionally receives an AbortSignal forwarded from the call site.

Type Parameters

E

E

A

A

Parameters

fn

(signal?) => Thenable<A>

options

onError

(error) => E

Returns

Result<E, A>

Example

const loadUser = Task.Result.tryCatch(
  (signal) => userStore.get("u_123", { signal }),
  { onError: (e) => new DbError(e) }
);

run

run: (signal?) => <A>(task) => Deferred<A>

Executes a task with an optional signal. Use as a terminal step in a pipe chain.

Parameters

signal?

AbortSignal

Returns

<A>(task) => Deferred<A>

Example

const name = await pipe(
    loadConfig,
    Task.map(config => config.name),
    Task.run(),
);

tap

tap: <A>(sideEffect) => (task) => Task<A>

Executes a side effect on the value without changing the Task. Useful for logging or debugging.

Type Parameters

A

A

Parameters

sideEffect

(value) => void

Returns

(task) => Task<A>

Example

pipe(
  loadConfig,
  Task.tap(cfg => console.log("Config:", cfg)),
  Task.map(buildReport)
);

timeout

timeout: <E>(options) => <A>(task) => Task<Result<E, A>>

Converts a Task<A> into a Task<Result<E, A>>, resolving to Err if the Task does not complete within the given duration. The inner Task receives an AbortSignal that fires when the deadline passes, so asynchronous operations that accept a signal are cancelled rather than left dangling.

Type Parameters

E

E

Parameters

options

duration

Duration

onTimeout

() => E

Returns

<A>(task) => Task<Result<E, A>>

Example

pipe(
  heavyComputation,
  Task.timeout({ duration: Duration.seconds(5), onTimeout: () => "timed out" }),
  Task.Result.chain(processResult)
);

tryCatch

tryCatch: <A, B>(fn, options) => Task<A | B>

Wraps a Promise-returning thunk that may throw or reject, trapping errors with a fallback function and returning a guaranteed Task<A>.

Type Parameters

A

A

B

B = A

Parameters

fn

(signal?) => Thenable<A>

options

onError

(error) => B

Returns

Task<A | B>

Example

const loadConfig = Task.tryCatch(
  () => configStore.get("default"),
  { onError: () => DEFAULT_CONFIG }
);

Validation

Validation: object = TaskValidation

Validation.apply

apply: <E2, A>(arg) => <B, E1>(task) => Validation<E2 | E1, B>

Applies a function wrapped in a Task.Validation to a value wrapped in a Task.Validation. Both Tasks run in parallel and errors from both sides are accumulated.

Type Parameters

E2

E2 = never

A

A = unknown

Parameters

arg

Validation<E2, A>

Returns

<B, E1>(task) => Validation<E2 | E1, B>

See

Task.Validation.struct to combine multiple validations into a record.

Example

pipe(
  Task.Validation.make.passed((name: string) => (age: number) => ({ name, age })),
  Task.Validation.apply(validateName(name)),
  Task.Validation.apply(validateAge(age))
)();

Validation.from

from: object

Validation.from.Maybe

Maybe: <E>(onNone) => <A>(maybe) => Validation<E, A>

Creates a Task.Validation from a Maybe. Some becomes Passed, None becomes Failed with the error from onNone.

Type Parameters

E

E

Parameters

onNone

() => E

Returns

<A>(maybe) => Validation<E, A>

Example

Task.Validation.from.Maybe(() => "empty")(Maybe.make.some(42)); // resolves to Passed(42)
Task.Validation.from.Maybe(() => "empty")(Maybe.make.none());   // resolves to Failed(["empty"])

Validation.from.nullable

nullable: <E>(onNull) => <A>(value) => Validation<E, NonNullable<A>>

Creates a Task.Validation from a nullable value. If the value is null or undefined, returns Failed with the error from onNull. Otherwise, returns Passed.

Type Parameters

E

E

Parameters

onNull

() => E

Returns

<A>(value) => Validation<E, NonNullable<A>>

Example

Task.Validation.from.nullable(() => "missing")(42);   // resolves to Passed(42)
Task.Validation.from.nullable(() => "missing")(null); // resolves to Failed(["missing"])

Validation.from.Result

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

Creates a Task.Validation from a Result. Ok becomes Passed, Err(e) becomes Failed([e]).

Type Parameters

E

E

A

A

Parameters

result

Result<E, A>

Returns

Validation<E, A>

Example

Task.Validation.from.Result(Result.make.ok(42));     // resolves to Passed(42)
Task.Validation.from.Result(Result.make.err("bad")); // resolves to Failed(["bad"])

Validation.from.Validation

Validation: <E, A>(validation) => Validation<E, A>

Lifts a Validation into a Task.Validation.

Type Parameters

E

E

A

A

Parameters

validation

Validation<E, A>

Returns

Validation<E, A>

Example

Task.Validation.from.Validation(Validation.make.passed(42));

Validation.getOrElse

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

Returns the success value or a default value if the Task.Validation is failed. The default can be a different type, widening the result to Task<A | B>.

Type Parameters

B

B

Parameters

fallback

() => B

Returns

<A, E>(task) => Task<B | A>

Example

pipe(
  Task.Validation.make.failed("invalid"),
  Task.Validation.getOrElse(() => 0),
); // Task resolving to 0

Validation.make

make: object

Validation.make.failed

failed: <E>(error) => Validation<E, never> = makeFailed

Creates a failed Task.Validation with a single error.

Type Parameters

E

E

Parameters

error

E

Returns

Validation<E, never>

Example

const task = Task.Validation.make.failed("invalid");
const res = await task(); // Failed(["invalid"])

Validation.make.failedAll

failedAll: <E>(errors) => Validation<E, never> = makeFailedAll

Creates a failed Task.Validation from multiple errors.

Type Parameters

E

E

Parameters

errors

NonEmptyArr<E>

Returns

Validation<E, never>

Example

const task = Task.Validation.make.failedAll(["err1", "err2"]);
const res = await task(); // Failed(["err1", "err2"])

Validation.make.passed

passed: <A>(value) => Validation<never, A> = makePassed

Wraps a value in a passed Task.Validation.

Type Parameters

A

A

Parameters

value

A

Returns

Validation<never, A>

Example

const task = Task.Validation.make.passed(42);
const res = await task(); // Passed(42)

Validation.map

map: <A, B>(transform) => <E>(task) => Validation<E, B>

Transforms the success value inside a Task.Validation.

Type Parameters

A

A

B

B

Parameters

transform

(value) => B

Returns

<E>(task) => Validation<E, B>

See

Task.Validation.mapError to transform accumulated errors.
Task.Validation.apply to combine multiple validations in parallel.

Example

pipe(
  Task.Validation.make.passed(5),
  Task.Validation.map(n => n * 2),
); // Task.Validation resolving to Passed(10)

Validation.mapError

mapError: <E, F>(transform) => <A>(task) => Validation<F, A>

Transforms all accumulated errors inside a Task.Validation.

Type Parameters

E

E

F

F

Parameters

transform

(error) => F

Returns

<A>(task) => Validation<F, A>

See

Task.Validation.map to transform the success value.

Example

pipe(
  Task.Validation.make.failed("oops"),
  Task.Validation.mapError(e => e.toUpperCase())
); // Task.Validation(Failed(["OOPS"]))

Validation.match

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

Pattern matches on a Task.Validation, returning a Task of the result.

Type Parameters

E

E

A

A

B

B

Parameters

cases

failed

(errors) => B

passed

(value) => B

Returns

(task) => Task<B>

Example

pipe(
  validateForm(input),
  Task.Validation.match({
    passed: data => save(data),
    failed: errors => showErrors(errors)
  })
)();

Validation.recover

recover: <E1, B, E2>(fallback) => <A>(task) => Validation<E2, B | A>

Recovers from a Failed state by providing a fallback Task.Validation. The fallback receives the accumulated error list so callers can inspect which errors occurred. The fallback can produce a different success type or resolve with a different error type.

Type Parameters

E1

E1

B

B

E2

E2 = never

Parameters

fallback

(errors) => Validation<E2, B>

Returns

<A>(task) => Validation<E2, B | A>

See

Task.Validation.recoverUnless to conditionally recover based on accumulated errors.

Example

pipe(
  Task.Validation.make.failed("missing"),
  Task.Validation.recover(() => Task.Validation.make.passed("default")),
); // Task.Validation resolving to Passed("default")

Validation.recoverUnless

recoverUnless: <E1, B, E2>(isBlocked, fallback) => <A>(task) => Validation<E1 | E2, B | A>

Recovers from a Failed state unless the predicate isBlocked returns true for the accumulated errors. The fallback receives the accumulated errors and can produce a different success type, widening the result to Task.Validation<E1 | E2, A | B>.

Type Parameters

E1

E1

B

B

E2

E2 = never

Parameters

isBlocked

(errors) => boolean

fallback

(errors) => Validation<E2, B>

Returns

<A>(task) => Validation<E1 | E2, B | A>

See

Task.Validation.recover for unconditional error recovery.

Example

pipe(
  validationTask,
  Task.Validation.recoverUnless(
    (errors) => errors.includes("fatal"),
    (errors) => Task.Validation.make.passed("fallback")
  )
);

Validation.run

run: (signal?) => <E, A>(task) => Deferred<Validation<E, A>>

Executes a Task.Validation with an optional signal, returning Deferred<Validation<E, A>>. Use as a terminal step in a pipe chain.

Parameters

signal?

AbortSignal

Returns

<E, A>(task) => Deferred<Validation<E, A>>

Example

const result = await pipe(
  Task.Validation.make.passed(42),
  Task.Validation.run(),
);

Validation.struct

struct: <T>(fields) => Validation<TaskValidationErrOf<T[keyof T]>, { [K in string | number | symbol]: T[K] extends Validation<unknown, A> ? A : never }>

Combines a record of Task.Validations into a single Task.Validation of a record. Own string and symbol keys are processed in key order; inherited fields are not supported. Evaluates fields in parallel and accumulates all validation errors.

Type Parameters

T

T extends Record<string, Validation<unknown, unknown>>

Parameters

fields

T

Returns

Validation<TaskValidationErrOf<T[keyof T]>, { [K in string | number | symbol]: T[K] extends Validation<unknown, A> ? A : never }>

Example

Task.Validation.struct({
  name: Task.Validation.make.passed("Alice"),
  age: Task.Validation.make.passed(30)
}); // Task.Validation({ name: "Alice", age: 30 })

Validation.tap

tap: <A>(sideEffect) => <E>(task) => Validation<E, A>

Executes a side effect on the success value without changing the Task.Validation. Useful for logging or debugging.

Type Parameters

A

A

Parameters

sideEffect

(value) => void

Returns

<E>(task) => Validation<E, A>

See

Task.Validation.tapError to perform a side effect on accumulated errors.

Example

pipe(
  Task.Validation.make.passed(42),
  Task.Validation.tap(n => console.log("Validated:", n)),
);

Validation.tapError

tapError: <E>(sideEffect) => <A>(task) => Validation<E, A>

Executes a side effect on the accumulated errors without changing the Task.Validation.

Type Parameters

E

E

Parameters

sideEffect

(errors) => void

Returns

<A>(task) => Validation<E, A>

See

Task.Validation.tap to perform a side effect on the success value.

Example

pipe(
  Task.Validation.make.failed("invalid name"),
  Task.Validation.tapError(errs => logger.error(errs))
);

Validation.to

to: object

Validation.to.Maybe

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

Converts a Task.Validation to a Task.Maybe. Passed(a) becomes Some(a); Failed(errors) becomes None (errors are discarded).

Type Parameters

E

E

A

A

Parameters

task

Validation<E, A>

Returns

Maybe<A>

Example

Task.Validation.to.Maybe(validationTask);

Validation.to.Result

Result: <E1, E2>(combineErrors) => <A>(task) => Result<E2, A>

Converts a Task.Validation to a Task.Result, combining accumulated errors using combineErrors. Passed(a) becomes Ok(a); Failed(errors) becomes Err(combineErrors(errors)).

Type Parameters

E1

E1

E2

E2

Parameters

combineErrors

(errors) => E2

Returns

<A>(task) => Result<E2, A>

Example

Task.Validation.to.Result((errors) => errors.join(", "))(validationTask);

Validation.tryCatch

tryCatch: <E, A>(fn, options) => Validation<E, A>

Creates a Task.Validation from a Promise-returning thunk that may throw or reject. Catches any errors and transforms them using the onError function into a Failed validation. The thunk optionally receives an AbortSignal forwarded from the call site.

Type Parameters

E

E

A

A

Parameters

fn

(signal?) => Thenable<A>

options

onError

(error) => E

Returns

Validation<E, A>

Example

const loadConfig = Task.Validation.tryCatch(
  (signal) => configStore.get("default", { signal }),
  { onError: (e) => `Failed to load config: ${e}` }
);

withLabel

withLabel: <L>(label) => <A>(task) => LabeledTask<L, A>

Attaches a read-only .label property to a Task, preserving the literal string generic type for IDE tooltips.

Type Parameters

L

L extends string

Parameters

label

L

Returns

<A>(task) => LabeledTask<L, A>

Example

const labeledTask = pipe(readTask, Task.withLabel("readUser"));
console.log(labeledTask.label); // "readUser"

withProgress

withProgress: (onProgress) => <A>(task) => Task<A>

Monitors progress of a Task by calling onProgress(0) before execution and onProgress(1) upon completion.

Parameters

onProgress

(ratio) => void

Returns

<A>(task) => Task<A>

Example

const taskWithProgress = pipe(
  readTask,
  Task.withProgress((ratio) => console.log(`Progress: ${ratio * 100}%`))
);