monads-lite

A TypeScript monad library with only the things you'll actually use.

Is this you?

I'm a JS/TS developer interested in using some more functional programming patterns in my code, but all these FP libs don't fit with the way I work!

Then mondas-lite is what you need!

monads-lite is JS/TS library that brings mondic functional programming tools that don't take over your code, and let you expore the benifits functional programming without re-writing your codebase.

Install

npm i monads-lite

Library

Result

The Result<T, E> type is a monadic construct that can represent the result of an operation which can either succeed or fail.

i.e. type OperationResult = Result.Result<number, 'oh no, I failed'>;

A Result can be infered from a Promise if a error type is provided:

1import { Result } from 'monads-lite';
2
3const promise = Promise.resolve(123);
4const result: Result<number, CustomErrorType> = 
5    inferFrom(promise).resultify<CustomErrorType>();

A Result can be matched on if it is an Ok or Err:

1import { Result } from 'monads-lite';
2
3// This is a powerful tool for program flow control.
4const value = Result.match(result, [
5    (okValue) => handleOk(okValue),
6    (errValue) => handleErr(errValue),
7]);

Actions can be run inside the Result monadic container so that they will only apply if the Result is of type Ok:

1import { Result } from 'monads-lite';
2
3const value = Result.act(result, (okValue) => doNextThing(okValue));

These actions can be chained:

1import { Result } from 'monads-lite';
2
3const value = Result.onResult(result)
4    // These actions will only execute if the Result is Ok.
5    .act(n => n + 1)
6    .act(n => n * 2)
7    // Unwrap the value from inside the Result.
8    .done();

Actions can also be run asynchronously:

1import { Result } from 'monads-lite';
2
3const result = await Result.onResult(result)
4    .actAsync(async (n) => n + 1)
5    .actAsync(async (n) => n * 2)
6    .done();

Errors thrown anywhere in the act chain will be resolve out as Err:

1import { Result } from 'monads-lite';
2
3const result = Result.onValue<number, Error>(2)
4    .act((n) => n + 1) // This will run.
5    .act(() => {
6        // This will be caught and converted into an Err.
7        throw new Error('fail 1');
8    })
9    .act((n) => n * 2) // This will not run.
10    .act(() => {
11        // This will not run.
12        throw new Error('fail 2');
13    })
14    // This unwrap the Result.
15    .done();
16
17// or
18
19const result = await Result.onValue<number, Error>(2)
20    .act((n) => n + 1) // This will run.
21    .act(() => {
22        // This will be caught and converted into an Err.
23        throw new Error('fail 1');
24    })
25    .act((n) => n * 2) // This will not run.
26    .actAsync(async () => {
27        // This will not run.
28        throw new Error('fail 2');
29    })
30    // This unwrap the Result.
31    .done();

Maybe

The Maybe<A> type is a monadic construct that can represent a value that is either present or not present.

i.e. type Username = Maybe<string>;

Actions can be run inside the Maybe monadic container so that they will only apply if the Result is of type Ok:

1import { Maybe } from 'monads-lite';
2
3const value = Maybe.act(maybe, (existingValue) => doNextThing(existingValue));

These actions can be chained:

1import { Maybe } from 'monads-lite';
2
3const value = Maybe.onResult(maybe)
4    // These actions will only execute if the Result is Ok.
5    .act(n => n + 1)
6    .act(n => n * 2)
7    // Unwrap the value from inside the Result.
8    .done();

A Maybe can be matched against cases:

1import { Maybe } from 'monads-lite';
2
3// If 2, 3 or 9, repeat the digit 5 times.
4const value = Maybe.match(maybe, [
5    n => (n === 2 && (() => 22222)),
6    n => (n === 3 && (() => 33333)),
7    n => (n === 9 && (() => 99999)),
8]);

When matching a Maybe a default case can also be provided:

1import { Maybe } from 'monads-lite';
2
3// If 2, 3 or 9, repeat the digit 5 times,
4// otherwise leave value unchanges.
5const value = Maybe.match(maybe, [
6    n => (n === 2 && (() => 22222)),
7    n => (n === 3 && (() => 33333)),
8    n => (n === 9 && (() => 99999)),
9], n => n);

curry

The curry function can be used to split a multi-argument function into a nested set of single argument functions. This technique is called currying.

1import { curry } from 'monads-lite';
2
3const add = (a: number, b: number, c: number) => {
4    return a + b + c;
5};
6
7const curriedAdd = curry(add);
8const addFive = curriedAdd(5);
9const addTwenty = addFive(15);
10
11const thirty: number = addTwenty(10);