Deferred

Deferred: object

Defined in: Core/Deferred.ts:24

Type Declaration

all

all: <T>(deferreds) => Deferred<{ [K in string | number | symbol]: T[K] extends Deferred<A> ? A : never }>

Combines an array or tuple of Deferred values into a single Deferred of a tuple. Resolves when all input Deferreds resolve.

Type Parameters

T

T extends readonly Deferred<unknown>[]

Parameters

deferreds

T

Returns

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

Example

const [a, b] = await Deferred.all([d1, d2]);

chain

chain: <A, B>(transform) => (deferred) => Deferred<B>

Chains a Deferred-returning step after the current one resolves.

The next step starts only after the previous value arrives, and only that value is passed forward. Use Deferred.all to run independent steps concurrently.

Type Parameters

A

A

B

B

Parameters

transform

(value) => Deferred<B>

Returns

(deferred) => Deferred<B>

See

• Deferred.map when the transform returns a plain value.
• Deferred.all to combine independent Deferred values.

Example

const orders = pipe(
  Task.run()(loadUser("u_1")),
  Deferred.chain((user) => Task.run()(loadOrders(user.id))),
);

from

from: object

from.Promise

Promise: <A>(p) => Deferred<A> = fromPromise

Wraps a Promise or Deferred into a Deferred, structurally excluding rejection handlers, .catch(), .finally(), and chainable .then().

Precondition: p must never reject. If p rejects, the returned Deferred will never resolve — await-ing it will hang indefinitely. Use Task.Result.tryCatch to handle operations that may fail before converting to a Deferred.

Type Parameters

A

A

Parameters

p

Thenable<A>

Returns

Deferred<A>

Example

const d = Deferred.from.Promise(Promise.resolve("hello"));
const value = await d; // "hello"

map

map: <A, B>(transform) => (deferred) => Deferred<B>

Transforms the resolved value of a Deferred.

Deferred is the type every asynchronous run settles into: Task.run, Op.Manager.run, Resource.use, and Graph.run all return one. Use map to reshape that settled value without converting back to a Promise.

Type Parameters

A

A

B

B

Parameters

transform

(value) => B

Returns

(deferred) => Deferred<B>

See

Deferred.chain when the transform itself returns another Deferred.

Example

const total = pipe(
  Task.run()(loadCart()),
  Deferred.map((cart) => cart.items.length),
);
console.log(await total); // 3

race

race: <A>(deferreds) => Deferred<A>

Races multiple Deferred values and resolves with the first one to settle.

Type Parameters

A

A

Parameters

deferreds

readonly Deferred<A>[]

Returns

Deferred<A>

Example

const winner = await Deferred.race([d1, d2]);

tap

tap: <A>(sideEffect) => (deferred) => Deferred<A>

Runs a side effect with the resolved value and passes that value through unchanged.

The callback must not throw. Use it to log, record metrics, or update a store after an operation settles without breaking the chain.

Type Parameters

A

A

Parameters

sideEffect

(value) => void

Returns

(deferred) => Deferred<A>

See

Deferred.map to transform the value instead of observing it.

Example

const outcome = pipe(
  Task.run()(chargeCard(payment)),
  Deferred.tap((receipt) => audit.record(receipt.id)),
);

to

to: object

to.Promise

Promise: <A>(d) => Promise<A> = toPromise

Converts a Deferred back into a Promise.

Type Parameters

A

A

Parameters

d

Deferred<A>

Returns

Promise<A>

Example

const p = Deferred.to.Promise(Deferred.from.Promise(Promise.resolve(42)));
// p is Promise<42>