Task

Index

Constructor

Type

hasInstance

Other

Constructor

create

create<Value, Error>(sideEffect): Task<Value, Error>

Task constructor

const getTime = Task(() => Task.ok(Date.now()));
const fetchTask = (url: string) => Task(() => fetch(url).then(Task.ok, Task.error));
const delay = (ms: number) => Task(() => new Promise(resolve => { setTimeout(() => resolve(Task.ok()); }), ms));

reject

reject<Value>(): Task<Value, void>
reject<Value, Error>(errorValue): Task<Value, Error>

Constructor that always returns a failed Task that rejects void.

const task = Task.reject();
const result = Task.run(task);// Result.Error()

resolve

resolve<Error>(): Task<void, Error>
resolve<Value, Error>(value): Task<Value, Error>

Constructor that always returns a successful Task that resolves void.

const task = Task.resolve();
const result = Task.run(task);// Result.Ok()

Type

hasInstance

hasInstance(anyValue): anyValue is TaskLike<unknown, unknown>

Return true if anyValue is a valid Task

Task.hasInstance(Task.resolve(...)); // true
Task.hasInstance({}); // false

Other

ErrorOf

ErrorOf<T>: T extends Task<any, infer Error> ? Error : never

Extracts error type of task T

Type parameters

ValueOf

ValueOf<T>: T extends Task<infer V, any> ? V : never

Extracts value type of task T

Type parameters

error

error: any

ok

ok: any

all

all<T>(tasks): Task<{ [ K in keyof T ]: Task.ValueOf<T[K]> }, Task.ErrorOf<T[keyof T]>>
all<Value, Error>(tasks): Task<ReadonlyArray<Value>, Error>

Resolves with the array of all task values, or reject with the first error

const success = Task.all([
  Task.resolve(1),
  Task.resolve(2),
]);
const successResult = Task.run(success);// Result.Ok([1, 2])

const failure = Task.all([
  Task.resolve(1),
  Task.reject('error'),
]);
const failureResult = Task.run(failure);// Result.Error('error')

allKeyed

allKeyed<TaskRecord>(tasks): Task<{ [ K in keyof TaskRecord ]: Task.ValueOf<TaskRecord[K]> }, Task.ErrorOf<TaskRecord[keyof TaskRecord]>>

Resolves with the record of all task values, or reject with the first error

const success = Task.allKeyed({
  task1: Task.resolve(1),
  task2: Task.resolve(2),
});
const successResult = Task.run(success);// Result.Ok({ task1: 1, task2: 2 })

const failure = Task.allKeyed({
  task1: Task.resolve(1),
  task2: Task.reject('error'),
});
const failureResult = Task.run(failure);// Result.Error('error')

allSettled

allSettled<T>(tasks): Task<{ [ K in keyof T ]: Result<Task.ValueOf<T[K]>, Task.ErrorOf<T[K]>> }, never>
allSettled<Value, Error>(tasks): Task<ReadonlyArray<Result<Value, Error>>, never>

Resolves an array of all task results

const task = Task.allSettled([
  Task.reject(1),
  Task.resolve(2),
]);
const taskResults = Task.run(task);// [Result.Error(1), Result.Ok(2)]

allSettledKeyed

allSettledKeyed<TaskRecord>(tasks): Task<{ [ K in keyof TaskRecord ]: Result<Task.ValueOf<TaskRecord[K]>, Task.ErrorOf<TaskRecord[K]>> }, never>

Resolves with the record of all task values, or reject with the first error

const success = Task.allSettledKeyed({
  task1: Task.resolve(1),
  task2: Task.reject('error'),
});
const result = Task.run(success);// Result.Ok({
  task1: Result.Ok(1),
  task2: Result.Error('error'),
})

andRun

andRun<ValueFrom, ErrorFrom, ErrorTo>(self, fn): Task<ValueFrom, ErrorFrom | ErrorTo>

Similar to andThen but the task keep task resolved value

const success = Task.resolve('foo');
Task.andRun(success, (value) => Console.log('result=', value));// console.log('result=foo'); then resolves 'foo'
Task.andRun(success, (value) => Task.reject(`SomeError`));// Task.reject('SomeError')

const failure = Task.reject('PreviousError');
Task.andRun(failure, (value) => Task.resolve(`never_used`));// Task.reject('PreviousError')

andThen

andThen<ValueFrom, ErrorFrom, ValueTo, ErrorTo>(self, fn): Task<ValueTo, ErrorFrom | ErrorTo>

Calls fn if the task is successful, otherwise returns the failed task untouched. This function can be used for control flow based on Task values.

const success = Task.resolve('foo');
Task.andThen(success, (value) => Task.resolve(`${value}_then`));// Task.resolve('foo_then')

const failure = Task.reject('PreviousError');
Task.andThen(failure, (value) => Task.resolve(`never_used`));// Task.reject('PreviousError')

any

any<T>(tasks): Task<Task.ValueOf<T[keyof T]>, AggregateError<{ [ K in keyof T ]: Task.ErrorOf<T[K]> }>>
any<Value, Error>(tasks): Task<Value, AggregateError<Error[]>>

Resolves with the first value, or reject with an aggregated error

const success = Task.any([
  Task.reject(1),
  Task.resolve(2),
]);
const successResult = Task.run(success);// Result.Ok(2)

const failure = Task.any([
  Task.reject('error1'),
  Task.reject('error2'),
]);
const failureResult = Task.run(failure);// Result.Error(AggregateError({ errors: ['error1', 'error2']}))

from

from<Value, Error>(taskLike): Task<Value, Error>

Create a Task from a Symbol.run function or a TaskLike

const task = Task.from(({ resolve }) => resolve('hello'));// from a callback
const task = Task.from({ [Symbol.run]: ({ resolve }) => resolve('hello') });// from a TaskLike

ignore

ignore<Error>(self): Task<void, Error>

Ignores value of task

const task = Task.resolve('foo');
Task.ignore(task);// Task.resolve()

map

map<ValueFrom, ErrorFrom, ValueTo>(self, fn): Task<ValueTo, ErrorFrom>

Maps a Task<Value, Error> to Task<NewValue, Error> by applying a function to a success value, leaving a failure untouched. This function can be used to compose the results of two functions.
const task = Task.resolve('foo'); Task.map(task, (value) => `${value}_bar`));// Task.resolve('foo_bar')

mapError

mapError<ValueFrom, ErrorFrom, ErrorTo>(self, fn): Task<ValueFrom, ErrorTo>

Maps a Task<Value, ErrorFrom> to Task<Value, ErrorTo> by applying a function to a contained failure error, leaving a success value untouched. This function can be used to pass through a successful result while handling an error.
const task = Task.reject('error'); Task.mapError(task, (value) => `${value}_bar`));// Task.reject('error_bar')

mapResult

mapResult<ValueFrom, ErrorFrom, ValueTo, ErrorTo>(self, mapFn): Task<ValueTo, ErrorTo>

Maps a Task<ValueFrom, ErrorFrom> to Task<ValueTo, ErrorTo> by applying a function to the result of the task.

const task = Task.reject('error');
const handledTask = Task.mapResult(task, (result) =>
   Result.isOk(result) ? result : Result.Ok('handled_value') )
); // Task.resolve('handled_value')

orElse

orElse<ValueFrom, ErrorFrom, ValueTo, ErrorTo>(self, fn): Task<ValueFrom | ValueTo, ErrorTo>

Calls fn if the task is failed, otherwise returns the successful task untouched. This function can be used for control flow based on Task values.

const success = Task.resolve('foo');
Task.orElse(success, (value) => Task.resolve(`never_used`));// Task.resolve('foo')

const failure = Task.reject('PreviousError');
Task.orElse(failure, (error) => Task.reject(`${error}_caught`));// Task.reject('PreviousError_caught')

run

run<Value, Error>(self, options): Awaitable<Result<Value, Error>>

Run task and return the result or a promise of the result

⚠ Impure function that may throw an error, it should be used on the edge of the program.
const getMessage = Task.resolve('Hello World!'); const messageResult = Task.run(getMessage);// Result.Ok('Hello World!')

tryCall

tryCall<Value, Error>(sideEffect, onError): Task<Value, Error>

Creates a new Task that resolves sideEffect(). When an exception is thrown then it rejects onError([thrown error]).

const class ResponseError extends Error {}
const fetch = Task.tryCall(
 () => fetch('my/url'), // Task will resolve Ok(fetch('my/url'))
 (error) => new ResponseError(), // Task will reject Error(new ResponseError())
);// Task<Response, ResponseError>

const randomNumber = Task.tryCall(async () => Math.random());// Task<number, never>