84 lines
1.9 KiB
TypeScript
84 lines
1.9 KiB
TypeScript
/**
|
|
* Uso:
|
|
*
|
|
* const maybeNumber = Maybe.some(10);
|
|
* const doubled = maybeNumber.map(n => n * 2);
|
|
* console.log(doubled.getValue()); // 20
|
|
|
|
* const noValue = Maybe.none<number>();
|
|
* console.log(noValue.isSome()); // false
|
|
**/
|
|
|
|
export interface IMaybe<T> {
|
|
isSome(): boolean;
|
|
isNone(): boolean;
|
|
unwrap(): T;
|
|
getOrUndefined(): T | undefined;
|
|
map<U>(fn: (value: T) => U): IMaybe<U>;
|
|
match<U>(someFn: (value: T) => U, noneFn: () => U): U;
|
|
equals(other: IMaybe<T>): boolean;
|
|
}
|
|
|
|
export function isMaybe<T = unknown>(input: unknown): input is Maybe<T> {
|
|
return input instanceof Maybe;
|
|
}
|
|
|
|
export class Maybe<T> implements IMaybe<T> {
|
|
private constructor(private readonly value?: T) {}
|
|
|
|
static fromNullable<T>(value?: T): Maybe<T> {
|
|
return value === undefined || value === null ? Maybe.none() : Maybe.some(value);
|
|
}
|
|
|
|
static some<T>(value: T): Maybe<T> {
|
|
if (value === undefined || value === null) {
|
|
throw new Error("Maybe.some cannot wrap null or undefined");
|
|
}
|
|
return new Maybe<T>(value);
|
|
}
|
|
|
|
static none<T>(): Maybe<T> {
|
|
return new Maybe<T>();
|
|
}
|
|
|
|
equals(other: IMaybe<T>): boolean {
|
|
if (this.isNone() && other.isNone()) {
|
|
return true;
|
|
}
|
|
|
|
if (this.isSome() && other.isSome()) {
|
|
return this.unwrap() === other.unwrap();
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
isSome(): boolean {
|
|
return this.value !== undefined;
|
|
}
|
|
|
|
isNone(): boolean {
|
|
return !this.isSome();
|
|
}
|
|
|
|
unwrap(): T {
|
|
if (this.value === undefined || this.value === null) {
|
|
throw new Error("Tried to unwrap a None value");
|
|
}
|
|
|
|
return this.value;
|
|
}
|
|
|
|
getOrUndefined(): T | undefined {
|
|
return this.isSome() ? this.value : undefined;
|
|
}
|
|
|
|
map<U>(fn: (value: T) => U): Maybe<U> {
|
|
return this.isSome() ? Maybe.some(fn(this.value as T)) : Maybe.none();
|
|
}
|
|
|
|
match<U>(someFn: (value: T) => U, noneFn: () => U): U {
|
|
return this.isSome() ? someFn(this.value as T) : noneFn();
|
|
}
|
|
}
|