mini-fn

The minimal functional programming library.

---

mini-fn provides simple, tiny library having functional features and its type declarations.

Examples

You can pipe your functions with Cat<T>'s feed<U>(f: (t: T) => U): Cat<U> method like this:

1import { Cat } from "@mikuroxina/mini-fn";
2
3const result = Cat.cat(-3)
4    .feed((x) => x ** 2)
5    .feed((x) => x.toString());
6console.log(result.value); // "9"

And there are some useful types such as Option<T>, Result<E, T>, and so on.

1import { Option } from "@mikuroxina/mini-fn";
2const sqrtThenToString = (num: number): Option.Option<string> => {
3    if (num < 0) {
4        return Option.none();
5    }
6    return Option.some(Math.sqrt(num).toString());
7};
8
9const applied = Option.andThen(sqrtThenToString);
10applied(Option.some(4)); // some("2")
11applied(Option.some(-1)); // none
12applied(Option.none()); // none

Some of them also provides its monad implementation, so you can combine and transform them like this:

1import { Cat, Option } from "@mikuroxina/mini-fn";
2
3const half = (x: number): Option.Option<number> => {
4    if (x % 2 != 0) {
5        return Option.none();
6    }
7    return Option.some(x / 2);
8};
9const liftedHalf = Option.monad.flatMap(half);
10
11Cat.cat(20)
12    .feed(Option.monad.pure)
13    .feed(liftedHalf)
14    .feed(Cat.log) // some(10)
15    .feed(liftedHalf)
16    .feed(Cat.log) // some(5)
17    .feed(liftedHalf)
18    .feed(Cat.log); // none

Also CatT allows you to compute with a Monad environment as:

1import { Cat, List } from "@mikuroxina/mini-fn";
2
3// Find patterns where `x + y + z == 5` for all natural number `x`, `y`, and `z`.
4const patterns = Cat.doT(List.monad)
5    .addM("x", List.range(0, 6))
6    .addMWith("y", ({ x }) => List.range(0, 6 - x))
7    .addWith("z", ({ x, y }) => 5 - (x + y))
8    .finish(({ x, y, z }) => [x, y, z] as const);
9
10console.dir(List.toArray(patterns));
11/* [
12    [0, 0, 5],
13    [0, 1, 4],
14    [0, 2, 3],
15    [0, 3, 2],
16    [0, 4, 1],
17    [0, 5, 0],
18    [1, 0, 4],
19    [1, 1, 3],
20    [1, 2, 2],
21    [1, 3, 1],
22    [1, 4, 0],
23    [2, 0, 3],
24    [2, 1, 2],
25    [2, 2, 1],
26    [2, 3, 0],
27    [3, 0, 2],
28    [3, 1, 1],
29    [3, 2, 0],
30    [4, 0, 1],
31    [4, 1, 0],
32    [5, 0, 0],
33] */