Typed functional library to deal with async operations.
Install using npm:
npm install tsoidThe key difference is that this library self handles all errors that could be happen during the execution time. In cases that a computation of actions is composed (e.g. many actions run synchronously) if one error occur, it will be propagated till the end.
Lift a value into a resolved Promise.
Example:
pure(42);
// Promise { 42 }Helper function that receives an string or an instance of Error and return an Promise of Error.
Example:
fail('This is an error');
// Promise { Error('This is an error) };Execute the action if the condition is true.
Example:
const printOk = () => Promise.resolve(console.log('Ok'));
when(true, printOk); // Ok
when(false, printOk); //Is the opposite of when.
Given two callback functions, and a Promise that can resolve to an Error instance, it calls the first callback passing the promise result if the result is an Error, or it calls the second callback passing the promise result if the result is an instance of Error.
It could act as a default function call if there's any error involved in the computation:
const successCallback = jest.fn((n) => n + 1);
const errorCallback = jest.fn(() => 9);
const action = () => Promise.resolve(new Error('Some error'));
either(successCallback, errorCallback, action);
// Promise { 9 }But, if the computation throws an Error, that is the case of Promise.reject,
the flow will be stopped and the error will be returned as a resolved promise.
Example:
const successCallback = jest.fn((n) => n + 1);
const errorCallback = jest.fn(() => 9);
const action = () => Promise.reject(new Error('Some error'));
either(successCallback, errorCallback, action);
// Promise rejected { Error('Some error') };For a given action function and a list of values, applies the function to each element of the array, waits for each result and return a list of results.
Example:
const getUser = (id) => Promise.resolve({ id, user: 'User' });
map(getUser, [1, 2, 3]);
// Promise { [ { id: 1, user: "User"}, { id: 2, user: "User" }, ... ] }For a given predicate action function and a list of values, applies the predicate function to each element of the array, and return a list of all values that satisfies the predicate action function.
Example:
const userExist = (id) => Promise.resolve([1, 3].includes(id));
filter(userExist, [1, 2, 3]);
// Promise { [1, 3] };Reduce a list of items into a single item using an async function.
Example:
const add = (x, y) => Promise.resolve(x + y);
const list = [1, 2, 3, 4, 5];
reduce(add, 0, list);
// Promise { 15 };Performs the action function n times, gathering the results.
Example:
const getRandom = () => Promise.resolve(Math.trunc(Math.random() * 10));
replicate(3, getRandom);
// Promise { [8, 3, 4] }Evaluate synchronously each promise in the list from left to right, and collect the results.
Example:
const getTen = () => Promise.resolve(10);
const getTwenty = () => Promise.resolve(20);
sequence([getTen(), getTwenty()]);
// Promise { [10, 20] }It is like the map function, but with the arguments flipped.
Lift a pure function into a Promise value.
Example:
const future10 = Promise.resolve(10);
const isTen = (x) => x === 10;
lift(isTen, future10);
// Promise { true };It is also exported the functions liftP2, liftP3, liftP4
and a type unsafe version called liftPN, that resolves all
the promises then apply the n-ary function to its values.
Given a Promise and an action function that depends on the value of these promise, flatten the Promise and apply the value into the action, then await for the result.
Example:
const futureSelf = Promise.resolve({ name: 'User' });
const viewName = (user) => user.name;
flatMap(futureSelf, viewName);
// Promise { 'User' }Given a Promise and one or more actions, sequentially compose these actions,
passing any value produced by the first as an argument to the second and so on.
Similar to the Haskell >>= operator.
Example:
const initial = Promise.resolve(1);
const doubleP = (x) => Promise.resolve(x * 2);
const tripleP = (x) => Promise.resolve(x * 3);
const stringifyP = (x) => Promise.resolve('' + x);
bind(initial, doubleP, tripleP, stringifyP);
// Promise { '6' }Given one or more actions, sequentially compose them, discarding any value
produced by the first, like sequencing operators. Similar to the Haskell >> operator.
Example:
const updateDatabase = async () => true;
const notifyUsers = async () => true;
const dropInstance = async () => true;
exec(updateDatabase, notifyUsers, dropInstance);This module contains a serie of utility functions that you can use.
The identity function, it returns the argument.
Example:
const value = 40;
id(value); // 40For a given function, it return a new function that has the arguments flipped.
Example:
const div = (n, m) => n / m;
const fdiv = flip(div);
div(4, 2); // 2
fdiv(2, 4); // 2It is also exported flip3 and flip4 functions that has 3 and 4-arity.
Transform a function into an static curried function.
Example:
const add = (x, y) => x + y;
const add10 = curry(add);
add10(10); // 20It is also exported curry3 and curry4 functions that deal with function that has 3 and 4-arity.
Undo a curried function.
Example:
const lazyAdd = (x) => (y) => x + y;
const add = uncurry(lazyAdd);
add(1, 2); // 3Compose n pure functions into a single function, applying from right to left.
Example:
const fn1 = (arg) => `fn1(${arg})`;
const fn2 = (arg) => `fn2(${arg})`;
const fn3 = (arg) => `fn3(${arg})`;
const fn4 = (arg) => `fn4(${arg})`;
const composed = compose(fn1, fn2, fn3, fn4);
composed(); // fn1(fn2(fn3(fn4(1))))Compose n pure functions into a single function, applying from left to right.
Example:
const fn1 = (arg) => `fn1(${arg})`;
const fn2 = (arg) => `fn2(${arg})`;
const fn3 = (arg) => `fn3(${arg})`;
const fn4 = (arg) => `fn4(${arg})`;
const piped = pipe(fn1, fn2, fn3, fn4);
piped(1); // fn4(fn3(fn2(fn1(1))))