tsoid
v1.1.2
Published
Typed functional library to deal with async operations.
Downloads
43
Maintainers
Readme
Tsoid
Typed functional library to deal with async operations.
Getting Started
Install using npm:
npm install tsoid
Documentation
The 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.
Promise based functions
pure
Lift a value into a resolved Promise.
Example:
pure(42);
// Promise { 42 }
fail
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) };
when
Execute the action if the condition is true
.
Example:
const printOk = () => Promise.resolve(console.log('Ok'));
when(true, printOk); // Ok
when(false, printOk); //
unless
Is the opposite of when
.
either
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') };
map
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" }, ... ] }
filter
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
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 };
replicate
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] }
sequence
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] }
traverse
It is like the map
function, but with the arguments flipped.
lift
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.
flatMap
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' }
bind
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' }
exec
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);
Utilities
This module contains a serie of utility functions that you can use.
id
The identity function, it returns the argument.
Example:
const value = 40;
id(value); // 40
flip
For 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); // 2
It is also exported flip3
and flip4
functions that has 3 and 4-arity.
curry
Transform a function into an static curried function.
Example:
const add = (x, y) => x + y;
const add10 = curry(add);
add10(10); // 20
It is also exported curry3
and curry4
functions that deal with function that has 3 and 4-arity.
uncurry
Undo a curried function.
Example:
const lazyAdd = (x) => (y) => x + y;
const add = uncurry(lazyAdd);
add(1, 2); // 3
compose
Compose 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))))
pipe
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))))