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>(opt: Option<T>, fn: (t: T) => Option<U>): Option<U> {
16 return isSome(opt) ? fn(opt) : null
17}
18
19export function filter<T>(opt: Option<T>, predicate: (t: T) => boolean): Option<T> {
20 return isSome(opt) && predicate(opt) ? opt : null
21}
22
23export function getOrElse<T>(opt: Option<T>, defaultValue: T): T {
24 return isSome(opt) ? opt : defaultValue
25}
26
27export function getOrElseLazy<T>(opt: Option<T>, fn: () => T): T {
28 return isSome(opt) ? opt : fn()
29}
30
31export function getOrThrow<T>(opt: Option<T>, error?: string | Error): T {
32 if (isSome(opt)) return opt
33 if (error instanceof Error) throw error
34 throw new Error(error ?? 'Expected value but got null/undefined')
35}
36
37export function tap<T>(opt: Option<T>, fn: (t: T) => void): Option<T> {
38 if (isSome(opt)) fn(opt)
39 return opt
40}
41
42export function match<T, U>(
43 opt: Option<T>,
44 handlers: { some: (t: T) => U; none: () => U }
45): U {
46 return isSome(opt) ? handlers.some(opt) : handlers.none()
47}
48
49export function toArray<T>(opt: Option<T>): T[] {
50 return isSome(opt) ? [opt] : []
51}
52
53export function fromArray<T>(arr: T[]): Option<T> {
54 return arr.length > 0 ? arr[0] : null
55}
56
57export function zip<T, U>(a: Option<T>, b: Option<U>): Option<[T, U]> {
58 return isSome(a) && isSome(b) ? [a, b] : null
59}
60
61export function zipWith<T, U, R>(
62 a: Option<T>,
63 b: Option<U>,
64 fn: (t: T, u: U) => R
65): Option<R> {
66 return isSome(a) && isSome(b) ? fn(a, b) : null
67}
68
69export function or<T>(a: Option<T>, b: Option<T>): Option<T> {
70 return isSome(a) ? a : b
71}
72
73export function orLazy<T>(a: Option<T>, fn: () => Option<T>): Option<T> {
74 return isSome(a) ? a : fn()
75}
76
77export function and<T, U>(a: Option<T>, b: Option<U>): Option<U> {
78 return isSome(a) ? b : null
79}