Task

Task: object

Defined in: Core/Task.ts:59

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) => Task<{ [K in string | number | symbol]: T[K] extends Task<A> ? A : never }>

Runs multiple Tasks in parallel and collects their results.

Type Parameters

T

T extends readonly Task<unknown>[]

Parameters

tasks

T

Returns

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

Example

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

ap

ap: <A>(arg) => <B>(data) => 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>(data) => Task<B>

Example

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

bind

bind: <K, A, B>(key, f) => (data) => Task<A & { [P in string]: B }>

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

Type Parameters

K

K extends string

A

A

B

B

Parameters

key

K

f

(a) => Task<B>

Returns

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

Example

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

bindTo

bindTo: <K>(key) => <A>(data) => 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>(data) => Task<{ [P in string]: A }>

Example

pipe(Task.resolve(42), Task.bindTo("value")); // Task({ value: 42 })

chain

chain: <A, B>(f) => (data) => Task<B>

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

Type Parameters

A

A

B

B

Parameters

f

(a) => Task<B>

Returns

(data) => Task<B>

Example

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

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

delay

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

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

Parameters

duration

Duration

Returns

<A>(data) => Task<A>

Example

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

from

from: object

from.sync

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

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

Type Parameters

A

A

Parameters

f

() => 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

map

map: <A, B>(f) => (data) => Task<B>

Transforms the value inside a Task.

Type Parameters

A

A

B

B

Parameters

f

(a) => B

Returns

(data) => Task<B>

Example

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

Maybe

Maybe: object = TaskMaybe

Maybe.ap

ap: <A>(arg) => <B>(data) => 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>(data) => Maybe<B>

Maybe.bind

bind: <K, A, B>(key, f) => (data) => 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

B

B

Parameters

key

K

f

(a) => Maybe<B>

Returns

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

Example

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

Maybe.bindTo

bindTo: <K>(key) => <A>(data) => 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>(data) => Maybe<{ [P in string]: A }>

Example

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

Maybe.chain

chain: <A, B>(f) => (data) => Maybe<B> = chainTaskMaybe

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

Type Parameters

A

A

B

B

Parameters

f

(a) => Maybe<B>

Returns

(data) => Maybe<B>

Example

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

Maybe.filter

filter: <A>(predicate) => (data) => Maybe<A>

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

Type Parameters

A

A

Parameters

predicate

(a) => boolean

Returns

(data) => Maybe<A>

Maybe.fold

fold: <A, B>(onNone, onSome) => (data) => Task<B>

Extracts a value from a Task.Maybe by providing handlers for both cases.

Type Parameters

A

A

B

B

Parameters

onNone

() => B

onSome

(a) => B

Returns

(data) => Task<B>

Maybe.from

from: object

Maybe.from.Maybe

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

Lifts a Maybe into a Task.Maybe.

Type Parameters

A

A

Parameters

option

Maybe<A>

Returns

Maybe<A>

Example

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

Maybe.from.nullable

nullable: <A>(value) => Maybe<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<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.resolve(42)); // resolves to Some(42)

Maybe.getOrElse

getOrElse: <B>(defaultValue) => <A>(data) => 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

defaultValue

() => B

Returns

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

Maybe.make

make: object

Wraps a value in a Some inside a Task.

Example

const task = Task.Maybe.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>(f) => (data) => Maybe<B> = mapTaskMaybe

Transforms the value inside a Task.Maybe.

Type Parameters

A

A

B

B

Parameters

f

(a) => B

Returns

(data) => Maybe<B>

Maybe.match

match: <A, B>(cases) => (data) => 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

(a) => B

Returns

(data) => Task<B>

Example

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

Maybe.memoize

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

Creates a memoized version of a Task.Maybe. The task is executed at most once on first call, and its resolved Maybe is cached for all subsequent calls.

Type Parameters

A

A

Parameters

task

Maybe<A>

Returns

Maybe<A>

Example

const loadUser = Task.Maybe.memoize(fetchUserMaybeTask);

Maybe.recover

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

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

Type Parameters

B

B

Parameters

fallback

() => Maybe<B>

Returns

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

Example

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

Maybe.struct

struct: <R>(fields) => Maybe<R>

Combines a record of Task.Maybes into a single Task.Maybe of a record. Evaluates fields in parallel and returns None if any task resolves to None.

Type Parameters

R

R extends Record<string, any>

Parameters

fields

{ [K in string | number | symbol]: Maybe<R[K]> }

Returns

Maybe<R>

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>(f) => (data) => Maybe<A>

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

Type Parameters

A

A

Parameters

f

(a) => void

Returns

(data) => Maybe<A>

Maybe.to

to: object

Maybe.to.Result

Result: <E>(onNone) => <A>(data) => 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>(data) => Result<E, A>

Example

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

Maybe.tryCatch

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

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

Type Parameters

A

A

Parameters

f

(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 is executed at most once on first call, and its resolved value is cached for all subsequent calls.

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

race

race: <A>(tasks) => Task<A>

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

Type Parameters

A

A

Parameters

tasks

readonly Task<A>[]

Returns

Task<A>

Example

const fast = Task.resolve("fast");
const slow = Task.delay(Duration.milliseconds(200))(Task.resolve("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[]>

Example

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

repeatUntil

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

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

Type Parameters

A

A

Parameters

options

delay?

Duration

maxAttempts?

number

when

(a) => boolean

Returns

(task) => Task<A>

Example

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

resolve

resolve: <A>(value) => Task<A> = resolveTask

Creates a Task that immediately resolves to the given value.

Type Parameters

A

A

Parameters

value

A

Returns

Task<A>

Example

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

Result

Result: object = TaskResult

Result.allSettled

allSettled: <E, A>(tasks) => Task<readonly Result<E, A>[]>

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

Type Parameters

E

E

A

A

Parameters

tasks

readonly Result<E, A>[]

Returns

Task<readonly Result<E, A>[]>

Example

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

Result.ap

ap: <E, A>(arg) => <B>(data) => Result<E, B>

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

Type Parameters

E

E

A

A

Parameters

arg

Result<E, A>

Returns

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

Result.bind

bind: <K, E, A, B>(key, f) => (data) => Result<E, A & { [P in string]: B }>

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

Type Parameters

K

K extends string

E

E

A

A

B

B

Parameters

key

K

f

(a) => Result<E, B>

Returns

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

Example

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

Result.bindTo

bindTo: <K>(key) => <E, A>(data) => 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>(data) => Result<E, { [P in string]: A }>

Example

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

Result.chain

chain: <E2, A, B>(f) => <E1>(data) => Result<E2 | E1, B> = chainTaskResult

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

Type Parameters

E2

E2

A

A

B

B

Parameters

f

(a) => Result<E2, B>

Returns

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

Result.fold

fold: <E, A, B>(onErr, onOk) => (data) => Task<B>

Extracts the value from a Task.Result by providing handlers for both cases.

Type Parameters

E

E

A

A

B

B

Parameters

onErr

(e) => B

onOk

(a) => B

Returns

(data) => Task<B>

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, 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, 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.getOrElse

getOrElse: <B>(defaultValue) => <E, A>(data) => 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

defaultValue

() => B

Returns

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

Result.make

make: object

Result.make.err

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

Creates a failed Task.Result with the given error.

Type Parameters

E

E

A

A = never

Parameters

error

E

Returns

Result<E, A>

Example

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

Result.make.ok

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

Wraps a value in a successful Task.Result.

Type Parameters

E

E = never

A

A = unknown

Parameters

value

A

Returns

Result<E, A>

Example

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

Result.map

map: <E, A, B>(f) => (data) => Result<E, B> = mapTaskResult

Transforms the success value inside a Task.Result.

Type Parameters

E

E

A

A

B

B

Parameters

f

(a) => B

Returns

(data) => Result<E, B>

Result.mapError

mapError: <E, F, A>(f) => (data) => Result<F, A>

Transforms the error value inside a Task.Result.

Type Parameters

E

E

F

F

A

A

Parameters

f

(e) => F

Returns

(data) => Result<F, A>

Result.match

match: <E, A, B>(cases) => (data) => 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

(e) => B

ok

(a) => B

Returns

(data) => Task<B>

Result.memoize

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

Creates a memoized version of a Task.Result. The task is executed at most once on first call, and its resolved Result is cached for all subsequent calls.

Type Parameters

E

E

A

A

Parameters

task

Result<E, A>

Returns

Result<E, A>

Example

const loadConfig = Task.Result.memoize(fetchConfigTask);

Result.recover

recover: <E, B>(fallback) => <A>(data) => Result<E, B | A>

Recovers from an error by providing a fallback Task.Result. The fallback can produce a different success type, widening the result to Task.Result<E, A | B>.

Type Parameters

E

E

B

B

Parameters

fallback

(e) => Result<E, B>

Returns

<A>(data) => Result<E, B | A>

Result.recoverUnless

recoverUnless: <E, B>(isBlocked, fallback) => <A>(data) => Result<E, 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<E, A | B>.

Type Parameters

E

E

B

B

Parameters

isBlocked

(e) => boolean

fallback

(e) => Result<E, B>

Returns

<A>(data) => Result<E, B | A>

Example

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

Result.retry

retry: (policy) => <E, A>(task) => Result<E, 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.

Parameters

policy

RetryPolicy

Returns

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

Example

const policy = RetryPolicy.exponential({ attempts: 3, initial: Duration.milliseconds(100) });
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 Promise<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: <E, R>(fields) => Result<E, R>

Combines a record of Task.Results into a single Task.Result of a record. Evaluates all tasks in parallel, forwarding the AbortSignal down to each sub-task. Returns the first Err encountered in key order.

Type Parameters

E

E

R

R extends Record<string, any>

Parameters

fields

{ [K in string | number | symbol]: Result<E, R[K]> }

Returns

Result<E, R>

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: <E, A>(f) => (data) => Result<E, A>

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

Type Parameters

E

E

A

A

Parameters

f

(a) => void

Returns

(data) => Result<E, A>

Result.tapError

tapError: <E, A>(f) => (data) => 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

A

A

Parameters

f

(e) => void

Returns

(data) => Result<E, A>

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>(data) => Maybe<A>

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

Type Parameters

E

E

A

A

Parameters

data

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>(f, 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

f

(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(),
);

sequence

sequence: <A>(tasks) => Task<readonly A[]>

Runs an array of Tasks concurrently and collects their results in an array. Forward-propagates the call site’s AbortSignal to all subtasks concurrently.

Type Parameters

A

A

Parameters

tasks

readonly Task<A>[]

Returns

Task<readonly A[]>

Example

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

sequential

sequential: <A>(tasks) => Task<readonly A[]>

Runs an array of Tasks one at a time in order, collecting all results. Each Task starts only after the previous one resolves.

Type Parameters

A

A

Parameters

tasks

readonly Task<A>[]

Returns

Task<readonly A[]>

Example

let log: number[] = [];
const makeTask = (n: number) => Task.resolve(n);

await Task.sequential([makeTask(1), makeTask(2), makeTask(3)])();
// log = [1, 2, 3] — tasks ran in order

tap

tap: <A>(f) => (data) => Task<A>

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

Type Parameters

A

A

Parameters

f

(a) => void

Returns

(data) => 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>(f, options) => Task<A>

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

Parameters

f

(signal?) => Promise<A>

options

onError

(error) => A

Returns

Task<A>

Example

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

Validation

Validation: object = TaskValidation

Validation.ap

ap: <E, A>(arg) => <B>(data) => Validation<E, 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

E

E

A

A

Parameters

arg

Validation<E, A>

Returns

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

Example

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

Validation.fold

fold: <E, A, B>(onFailed, onPassed) => (data) => Task<B>

Extracts a value from a Task.Validation by providing handlers for both cases.

Type Parameters

E

E

A

A

B

B

Parameters

onFailed

(errors) => B

onPassed

(a) => B

Returns

(data) => Task<B>

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, 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, 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>(defaultValue) => <E, A>(data) => 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

defaultValue

() => B

Returns

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

Validation.make

make: object

Validation.make.failed

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

Creates a failed Task.Validation with a single error.

Type Parameters

E

E

A

A = never

Parameters

error

E

Returns

Validation<E, A>

Example

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

Validation.make.failedAll

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

Creates a failed Task.Validation from multiple errors.

Type Parameters

E

E

A

A = never

Parameters

errors

NonEmptyArr<E>

Returns

Validation<E, A>

Example

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

Validation.make.passed

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

Wraps a value in a passed Task.Validation.

Type Parameters

E

E = never

A

A = unknown

Parameters

value

A

Returns

Validation<E, A>

Example

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

Validation.map

map: <E, A, B>(f) => (data) => Validation<E, B>

Transforms the success value inside a Task.Validation.

Type Parameters

E

E

A

A

B

B

Parameters

f

(a) => B

Returns

(data) => Validation<E, B>

Validation.mapError

mapError: <E, F, A>(f) => (data) => Validation<F, A>

Transforms all accumulated errors inside a Task.Validation.

Type Parameters

E

E

F

F

A

A

Parameters

f

(e) => F

Returns

(data) => Validation<F, A>

Example

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

Validation.match

match: <E, A, B>(cases) => (data) => 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

(a) => B

Returns

(data) => Task<B>

Example

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

Validation.memoize

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

Creates a memoized version of a Task.Validation. The task is executed at most once on first call, and its resolved Validation is cached for all subsequent calls.

Type Parameters

E

E

A

A

Parameters

task

Validation<E, A>

Returns

Validation<E, A>

Example

const validate = Task.Validation.memoize(validateFormTask);

Validation.product

product: <E, A, B>(first, second) => Validation<E, readonly [A, B]>

Runs two Task.Validations concurrently and combines their results into a tuple. If both are Passed, returns Passed with both values. If either fails, accumulates errors from both sides.

Type Parameters

E

E

A

A

B

B

Parameters

first

Validation<E, A>

second

Validation<E, B>

Returns

Validation<E, readonly [A, B]>

Example

await Task.Validation.product(
  validateName(form.name),
  validateAge(form.age),
)(); // Passed(["Alice", 30]) or Failed([...errors])

Validation.productAll

productAll: <E, A>(data) => Validation<E, readonly A[]>

Runs all Task.Validations concurrently and collects results. If all are Passed, returns Passed with all values as an array. If any fail, returns Failed with all accumulated errors.

Type Parameters

E

E

A

A

Parameters

data

NonEmptyArr<Validation<E, A>>

Returns

Validation<E, readonly A[]>

Example

await Task.Validation.productAll([
  validateName(form.name),
  validateEmail(form.email),
  validateAge(form.age),
])(); // Passed([name, email, age]) or Failed([...all errors])

Validation.recover

recover: <E, B>(fallback) => <A>(data) => Validation<E, 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, widening the result to Task.Validation<E, A | B>.

Type Parameters

E

E

B

B

Parameters

fallback

(errors) => Validation<E, B>

Returns

<A>(data) => Validation<E, B | A>

Validation.recoverUnless

recoverUnless: <E, B>(isBlocked, fallback) => <A>(data) => Validation<E, 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<E, A | B>.

Type Parameters

E

E

B

B

Parameters

isBlocked

(errors) => boolean

fallback

(errors) => Validation<E, B>

Returns

<A>(data) => Validation<E, B | A>

Example

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

Validation.struct

struct: <E, R>(fields) => Validation<E, R>

Combines a record of Task.Validations into a single Task.Validation of a record. Evaluates fields in parallel and accumulates all validation errors.

Type Parameters

E

E

R

R extends Record<string, any>

Parameters

fields

{ [K in string | number | symbol]: Validation<E, R[K]> }

Returns

Validation<E, R>

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: <E, A>(f) => (data) => Validation<E, A>

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

Type Parameters

E

E

A

A

Parameters

f

(a) => void

Returns

(data) => Validation<E, A>

Validation.tapError

tapError: <E, A>(f) => (data) => Validation<E, A>

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

Type Parameters

E

E

A

A

Parameters

f

(errors) => void

Returns

(data) => Validation<E, A>

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>(data) => 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

data

Validation<E, A>

Returns

Maybe<A>

Example

Task.Validation.to.Maybe(validationTask);

Validation.to.Result

Result: <E1, E2, A>(combineErrors) => (data) => 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

A

A

Parameters

combineErrors

(errors) => E2

Returns

(data) => Result<E2, A>

Example

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

Validation.tryCatch

tryCatch: <E, A>(f, 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

f

(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: <A>(onProgress) => (task) => Task<A>

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

Type Parameters

A

A

Parameters

onProgress

(ratio) => void

Returns

(task) => Task<A>

Example

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