this repo has no description
lewis.moe
1export type Option<T> = T | null | undefined;
2
3export function isSome<T>(opt: Option<T>): opt is T {
4 return opt != null;
5}
6
7export function isNone<T>(opt: Option<T>): opt is null | undefined {
8 return opt == null;
9}
10
11export function map<T, U>(opt: Option<T>, fn: (t: T) => U): Option<U> {
12 return isSome(opt) ? fn(opt) : null;
13}
14
15export function flatMap<T, U>(
16 opt: Option<T>,
17 fn: (t: T) => Option<U>,
18): Option<U> {
19 return isSome(opt) ? fn(opt) : null;
20}
21
22export function filter<T>(
23 opt: Option<T>,
24 predicate: (t: T) => boolean,
25): Option<T> {
26 return isSome(opt) && predicate(opt) ? opt : null;
27}
28
29export function getOrElse<T>(opt: Option<T>, defaultValue: T): T {
30 return isSome(opt) ? opt : defaultValue;
31}
32
33export function getOrElseLazy<T>(opt: Option<T>, fn: () => T): T {
34 return isSome(opt) ? opt : fn();
35}
36
37export function getOrThrow<T>(opt: Option<T>, error?: string | Error): T {
38 if (isSome(opt)) return opt;
39 if (error instanceof Error) throw error;
40 throw new Error(error ?? "Expected value but got null/undefined");
41}
42
43export function tap<T>(opt: Option<T>, fn: (t: T) => void): Option<T> {
44 if (isSome(opt)) fn(opt);
45 return opt;
46}
47
48export function match<T, U>(
49 opt: Option<T>,
50 handlers: { some: (t: T) => U; none: () => U },
51): U {
52 return isSome(opt) ? handlers.some(opt) : handlers.none();
53}
54
55export function toArray<T>(opt: Option<T>): T[] {
56 return isSome(opt) ? [opt] : [];
57}
58
59export function fromArray<T>(arr: T[]): Option<T> {
60 return arr.length > 0 ? arr[0] : null;
61}
62
63export function zip<T, U>(a: Option<T>, b: Option<U>): Option<[T, U]> {
64 return isSome(a) && isSome(b) ? [a, b] : null;
65}
66
67export function zipWith<T, U, R>(
68 a: Option<T>,
69 b: Option<U>,
70 fn: (t: T, u: U) => R,
71): Option<R> {
72 return isSome(a) && isSome(b) ? fn(a, b) : null;
73}
74
75export function or<T>(a: Option<T>, b: Option<T>): Option<T> {
76 return isSome(a) ? a : b;
77}
78
79export function orLazy<T>(a: Option<T>, fn: () => Option<T>): Option<T> {
80 return isSome(a) ? a : fn();
81}
82
83export function and<T, U>(a: Option<T>, b: Option<U>): Option<U> {
84 return isSome(a) ? b : null;
85}