fmt
This commit is contained in:
Pascal Perrenoud
+95
-98
@@ -4,110 +4,107 @@ import {Result} from './result'
|
||||
const log = logger('option')
|
||||
|
||||
export class Option<T> {
|
||||
// *****************************************************************************************************************
|
||||
// Constructors
|
||||
private constructor(
|
||||
private readonly data: T | null,
|
||||
private readonly _state: State,
|
||||
) {}
|
||||
public static some<T>(data: T) : Option<T> {
|
||||
return new Option(data, State.Some)
|
||||
}
|
||||
public static none<T>() : Option<T> {
|
||||
return new Option<T>(null, State.None)
|
||||
// *****************************************************************************************************************
|
||||
// Constructors
|
||||
private constructor(private readonly data: T | null, private readonly _state: State) {}
|
||||
public static some<T>(data: T): Option<T> {
|
||||
return new Option(data, State.Some)
|
||||
}
|
||||
public static none<T>(): Option<T> {
|
||||
return new Option<T>(null, State.None)
|
||||
}
|
||||
|
||||
// *****************************************************************************************************************
|
||||
// some
|
||||
public is_some(): boolean {
|
||||
return this._state === State.Some
|
||||
}
|
||||
public is_some_and(f: (data: T) => boolean): boolean {
|
||||
return this._state === State.Some && f(this.data as T)
|
||||
}
|
||||
public expect(msg: string): T {
|
||||
log.trace('expect')
|
||||
|
||||
if (this._state === State.Some) {
|
||||
return this.data as T
|
||||
}
|
||||
|
||||
// *****************************************************************************************************************
|
||||
// some
|
||||
public is_some() : boolean {
|
||||
return this._state === State.Some
|
||||
}
|
||||
public is_some_and(f: (data: T) => boolean) : boolean {
|
||||
return this._state === State.Some && f(this.data as T)
|
||||
}
|
||||
public expect(msg: string) : T {
|
||||
log.trace("expect")
|
||||
log.warn(msg)
|
||||
throw new Error(msg)
|
||||
}
|
||||
public unwrap(): T {
|
||||
log.trace('unwrap')
|
||||
return this.expect('called unwrap on a None value')
|
||||
}
|
||||
public unwrap_or(default_: T): T {
|
||||
if (this._state === State.Some) return this.data as T
|
||||
return default_
|
||||
}
|
||||
public unwrap_or_else(f: () => T): T {
|
||||
if (this._state === State.Some) return this.data as T
|
||||
return f()
|
||||
}
|
||||
|
||||
if (this._state === State.Some) {
|
||||
return this.data as T
|
||||
}
|
||||
// *****************************************************************************************************************
|
||||
// none
|
||||
public is_none(): boolean {
|
||||
return this._state === State.None
|
||||
}
|
||||
|
||||
log.warn(msg)
|
||||
throw new Error(msg)
|
||||
}
|
||||
public unwrap() : T {
|
||||
log.trace("unwrap")
|
||||
return this.expect("called unwrap on a None value")
|
||||
}
|
||||
public unwrap_or(default_: T) : T {
|
||||
if (this._state === State.Some) return this.data as T
|
||||
return default_
|
||||
}
|
||||
public unwrap_or_else(f: () => T) : T {
|
||||
if (this._state === State.Some) return this.data as T
|
||||
return f()
|
||||
}
|
||||
// *****************************************************************************************************************
|
||||
// map
|
||||
public map<U>(f: (data: T) => U): Option<U> {
|
||||
if (this._state === State.Some) return Option.some(f(this.data as T))
|
||||
return Option.none()
|
||||
}
|
||||
public map_or<U>(default_: U, f: (data: T) => U): U {
|
||||
if (this._state === State.Some) return f(this.data as T)
|
||||
return default_
|
||||
}
|
||||
public map_or_else<U>(default_: () => U, f: (data: T) => U): U {
|
||||
if (this._state === State.Some) return f(this.data as T)
|
||||
return default_()
|
||||
}
|
||||
public ok_or<E>(err: E): Result<T, E> {
|
||||
if (this._state === State.Some) return Result.ok(this.data as T)
|
||||
return Result.error(err)
|
||||
}
|
||||
public ok_or_else<E>(err: () => E): Result<T, E> {
|
||||
if (this._state === State.Some) return Result.ok(this.data as T)
|
||||
return Result.error(err())
|
||||
}
|
||||
public and<U>(optb: Option<U>): Option<U> {
|
||||
if (this._state === State.Some) return optb
|
||||
return Option.none()
|
||||
}
|
||||
public and_then<U>(f: (data: T) => Option<U>): Option<U> {
|
||||
if (this._state === State.Some) return f(this.data as T)
|
||||
return Option.none()
|
||||
}
|
||||
public filter(f: (data: T) => boolean): Option<T> {
|
||||
if (this._state === State.Some && f(this.data as T)) return this
|
||||
return Option.none()
|
||||
}
|
||||
public or(optb: Option<T>): Option<T> {
|
||||
if (this._state === State.Some) return this
|
||||
return optb
|
||||
}
|
||||
public or_else(f: () => Option<T>): Option<T> {
|
||||
if (this._state === State.Some) return this
|
||||
return f()
|
||||
}
|
||||
public xor(optb: Option<T>): Option<T> {
|
||||
if (this._state === optb._state) return Option.none()
|
||||
else if (this._state === State.Some) return this
|
||||
return optb
|
||||
}
|
||||
|
||||
// *****************************************************************************************************************
|
||||
// none
|
||||
public is_none() : boolean {
|
||||
return this._state === State.None
|
||||
}
|
||||
|
||||
// *****************************************************************************************************************
|
||||
// map
|
||||
public map<U>(f: (data: T) => U) : Option<U> {
|
||||
if (this._state === State.Some) return Option.some(f(this.data as T))
|
||||
return Option.none()
|
||||
}
|
||||
public map_or<U>(default_: U, f: (data: T) => U) : U {
|
||||
if (this._state === State.Some) return f(this.data as T)
|
||||
return default_
|
||||
}
|
||||
public map_or_else<U>(default_: () => U, f: (data: T) => U) : U {
|
||||
if (this._state === State.Some) return f(this.data as T)
|
||||
return default_()
|
||||
}
|
||||
public ok_or<E>(err: E) : Result<T, E> {
|
||||
if (this._state === State.Some) return Result.ok(this.data as T)
|
||||
return Result.error(err)
|
||||
}
|
||||
public ok_or_else<E>(err: () => E) : Result<T, E> {
|
||||
if (this._state === State.Some) return Result.ok(this.data as T)
|
||||
return Result.error(err())
|
||||
}
|
||||
public and<U>(optb: Option<U>) : Option<U> {
|
||||
if (this._state === State.Some) return optb
|
||||
return Option.none()
|
||||
}
|
||||
public and_then<U>(f: (data: T) => Option<U>) : Option<U> {
|
||||
if (this._state === State.Some) return f(this.data as T)
|
||||
return Option.none()
|
||||
}
|
||||
public filter(f: (data: T) => boolean) : Option<T> {
|
||||
if (this._state === State.Some && f(this.data as T)) return this
|
||||
return Option.none()
|
||||
}
|
||||
public or(optb: Option<T>) : Option<T> {
|
||||
if (this._state === State.Some) return this
|
||||
return optb
|
||||
}
|
||||
public or_else(f: () => Option<T>) : Option<T> {
|
||||
if (this._state === State.Some) return this
|
||||
return f()
|
||||
}
|
||||
public xor(optb: Option<T>) : Option<T> {
|
||||
if (this._state === optb._state) return Option.none()
|
||||
else if (this._state === State.Some) return this
|
||||
return optb
|
||||
}
|
||||
|
||||
public get state() : State {
|
||||
return this._state
|
||||
}
|
||||
public get state(): State {
|
||||
return this._state
|
||||
}
|
||||
}
|
||||
|
||||
export enum State {
|
||||
Some,
|
||||
None,
|
||||
Some,
|
||||
None
|
||||
}
|
||||
|
||||
+173
-176
@@ -4,199 +4,196 @@ import {Option} from './option'
|
||||
const log = logger('result')
|
||||
|
||||
export class Result<T, E = []> {
|
||||
public constructor(
|
||||
protected readonly _data: T | E,
|
||||
private readonly _state: State,
|
||||
) {}
|
||||
public constructor(protected readonly _data: T | E, private readonly _state: State) {}
|
||||
|
||||
// Constructors
|
||||
static ok<T, E>(data: T) : Result<T, E> {
|
||||
log.trace('New Ok')
|
||||
return new Result<T, E>(data, State.OK)
|
||||
}
|
||||
static error<T, E>(err: E) : Result<T, E> {
|
||||
log.trace('New Error')
|
||||
log.debug(`Error : ${err}`)
|
||||
return new Result<T, E>(err, State.ERROR)
|
||||
}
|
||||
static fromObject<T, E>(res: Result<T, E>) : Result<T, E> {
|
||||
// @ts-expect-error
|
||||
return new Result(res._data, res._state)
|
||||
}
|
||||
public as_error() : Result<never, E> {
|
||||
return Result.error(this.unwrap_err())
|
||||
// Constructors
|
||||
static ok<T, E>(data: T): Result<T, E> {
|
||||
log.trace('New Ok')
|
||||
return new Result<T, E>(data, State.OK)
|
||||
}
|
||||
static error<T, E>(err: E): Result<T, E> {
|
||||
log.trace('New Error')
|
||||
log.debug(`Error : ${err}`)
|
||||
return new Result<T, E>(err, State.ERROR)
|
||||
}
|
||||
static fromObject<T, E>(res: Result<T, E>): Result<T, E> {
|
||||
// @ts-expect-error
|
||||
return new Result(res._data, res._state)
|
||||
}
|
||||
public as_error(): Result<never, E> {
|
||||
return Result.error(this.unwrap_err())
|
||||
}
|
||||
|
||||
// Getters
|
||||
public state(): State {
|
||||
return this._state
|
||||
}
|
||||
|
||||
// TODO : implements Iterable<...>
|
||||
|
||||
// *****************************************************************************************************************
|
||||
// Ok
|
||||
public is_ok(): boolean {
|
||||
return this._state === State.OK
|
||||
}
|
||||
public is_ok_and(f: (data: T) => boolean): boolean {
|
||||
return this._state === State.OK && f(this._data as T)
|
||||
}
|
||||
public expect(msg: string): T {
|
||||
log.trace('expect')
|
||||
|
||||
if (this._state === State.ERROR) {
|
||||
log.error('unwrapped an Error')
|
||||
log.error(msg)
|
||||
log.debug(`Error : ${this._data}`)
|
||||
throw msg
|
||||
}
|
||||
|
||||
// Getters
|
||||
public state() : State {
|
||||
return this._state
|
||||
return this._data as T
|
||||
}
|
||||
public unwrap(): T {
|
||||
log.trace('unwrap')
|
||||
|
||||
if (this._state === State.ERROR) {
|
||||
log.error('Unwrapped an Error')
|
||||
log.debug(`Error : ${this._data}`)
|
||||
throw 'Unwrapped an Error'
|
||||
}
|
||||
|
||||
// TODO : implements Iterable<...>
|
||||
return this._data as T
|
||||
}
|
||||
public ok(): Option<T> {
|
||||
if (this._state === State.OK) {
|
||||
return Option.some(this._data as T)
|
||||
} else {
|
||||
return Option.none()
|
||||
}
|
||||
}
|
||||
public map<U>(f: (data: T) => U): Result<U, E> {
|
||||
if (this._state === State.OK) {
|
||||
return Result.ok(f(this._data as T))
|
||||
} else {
|
||||
return Result.error<never, E>(this._data as E)
|
||||
}
|
||||
}
|
||||
public map_or<U>(default_: U, f: (data: T) => U): U {
|
||||
if (this._state === State.OK) {
|
||||
return f(this._data as T)
|
||||
} else {
|
||||
return default_
|
||||
}
|
||||
}
|
||||
public map_or_else<U>(fe: (err: E) => U, f: (data: T) => U): U {
|
||||
if (this._state === State.OK) {
|
||||
return f(this._data as T)
|
||||
} else {
|
||||
return fe(this._data as E)
|
||||
}
|
||||
}
|
||||
public inspect(f: (data: T) => void): Result<T, E> {
|
||||
if (this._state === State.OK) {
|
||||
f(this._data as T)
|
||||
}
|
||||
return this
|
||||
}
|
||||
public unwrap_or(default_: T): T {
|
||||
if (this._state === State.OK) {
|
||||
return this._data as T
|
||||
} else {
|
||||
return default_
|
||||
}
|
||||
}
|
||||
public unwrap_or_else(f: (err: E) => T): T {
|
||||
if (this._state === State.OK) {
|
||||
return this._data as T
|
||||
} else {
|
||||
return f(this._data as E)
|
||||
}
|
||||
}
|
||||
|
||||
// *****************************************************************************************************************
|
||||
// Ok
|
||||
public is_ok() : boolean {
|
||||
return this._state === State.OK
|
||||
}
|
||||
public is_ok_and(f: (data: T) => boolean) : boolean {
|
||||
return this._state === State.OK && f(this._data as T)
|
||||
}
|
||||
public expect(msg: string) : T {
|
||||
log.trace('expect')
|
||||
// *****************************************************************************************************************
|
||||
// Errors
|
||||
public is_err(): boolean {
|
||||
return this._state === State.ERROR
|
||||
}
|
||||
public is_err_and(f: (err: E) => boolean): boolean {
|
||||
return this._state === State.ERROR && f(this._data as E)
|
||||
}
|
||||
public expect_err(msg: string): E {
|
||||
log.trace('expect_err')
|
||||
|
||||
if (this._state === State.ERROR) {
|
||||
log.error('unwrapped an Error')
|
||||
log.error(msg)
|
||||
log.debug(`Error : ${this._data}`)
|
||||
throw msg
|
||||
}
|
||||
|
||||
return this._data as T
|
||||
}
|
||||
public unwrap() : T {
|
||||
log.trace('unwrap')
|
||||
|
||||
if (this._state === State.ERROR) {
|
||||
log.error("Unwrapped an Error")
|
||||
log.debug(`Error : ${this._data}`)
|
||||
throw "Unwrapped an Error"
|
||||
}
|
||||
|
||||
return this._data as T
|
||||
}
|
||||
public ok() : Option<T> {
|
||||
if (this._state === State.OK) {
|
||||
return Option.some(this._data as T)
|
||||
} else {
|
||||
return Option.none()
|
||||
}
|
||||
}
|
||||
public map<U>(f: (data: T) => U) : Result<U, E> {
|
||||
if (this._state === State.OK) {
|
||||
return Result.ok(f(this._data as T))
|
||||
} else {
|
||||
return Result.error<never, E>(this._data as E)
|
||||
}
|
||||
}
|
||||
public map_or<U>(default_: U, f: (data: T) => U) : U {
|
||||
if (this._state === State.OK) {
|
||||
return f(this._data as T)
|
||||
} else {
|
||||
return default_
|
||||
}
|
||||
}
|
||||
public map_or_else<U>(fe: (err: E) => U, f: (data: T) => U) : U {
|
||||
if (this._state === State.OK) {
|
||||
return f(this._data as T)
|
||||
} else {
|
||||
return fe(this._data as E)
|
||||
}
|
||||
}
|
||||
public inspect(f: (data: T) => void) : Result<T, E> {
|
||||
if (this._state === State.OK) {
|
||||
f(this._data as T)
|
||||
}
|
||||
return this
|
||||
}
|
||||
public unwrap_or(default_: T) : T {
|
||||
if (this._state === State.OK) {
|
||||
return this._data as T
|
||||
} else {
|
||||
return default_
|
||||
}
|
||||
}
|
||||
public unwrap_or_else(f: (err: E) => T) : T {
|
||||
if (this._state === State.OK) {
|
||||
return this._data as T
|
||||
} else {
|
||||
return f(this._data as E)
|
||||
}
|
||||
if (this._state === State.OK) {
|
||||
log.error('expect_err on Ok')
|
||||
log.error(msg)
|
||||
throw msg
|
||||
}
|
||||
|
||||
// *****************************************************************************************************************
|
||||
// Errors
|
||||
public is_err() : boolean {
|
||||
return this._state === State.ERROR
|
||||
}
|
||||
public is_err_and(f: (err: E) => boolean) : boolean {
|
||||
return this._state === State.ERROR && f(this._data as E)
|
||||
}
|
||||
public expect_err(msg: string) : E {
|
||||
log.trace('expect_err')
|
||||
return this._data as E
|
||||
}
|
||||
public unwrap_err(): E {
|
||||
log.trace('unwrap_err')
|
||||
|
||||
if (this._state === State.OK) {
|
||||
log.error('expect_err on Ok')
|
||||
log.error(msg)
|
||||
throw msg
|
||||
}
|
||||
|
||||
return this._data as E
|
||||
}
|
||||
public unwrap_err() : E {
|
||||
log.trace('unwrap_err')
|
||||
|
||||
if (this._state === State.OK) {
|
||||
log.error('unwrap_err on Ok')
|
||||
throw "Result wasn't in error"
|
||||
}
|
||||
|
||||
return this._data as E
|
||||
}
|
||||
public err() : Option<E> {
|
||||
if (this._state === State.ERROR) {
|
||||
return Option.some(this._data as E)
|
||||
} else {
|
||||
return Option.none()
|
||||
}
|
||||
}
|
||||
public map_err<F>(f: (err: E) => F) : Result<T, F> {
|
||||
if (this._state === State.ERROR) {
|
||||
return Result.error(f(this._data as E))
|
||||
} else {
|
||||
return Result.ok(this._data as T)
|
||||
}
|
||||
}
|
||||
public inspect_err(f: (err: E) => void) : Result<T, E> {
|
||||
if (this._state === State.ERROR) {
|
||||
f(this._data as E)
|
||||
}
|
||||
return this
|
||||
if (this._state === State.OK) {
|
||||
log.error('unwrap_err on Ok')
|
||||
throw "Result wasn't in error"
|
||||
}
|
||||
|
||||
// *****************************************************************************************************************
|
||||
// Combine
|
||||
public and<U>(res: Result<U, E>) : Result<U, E> {
|
||||
if (this._state === State.OK) {
|
||||
return res
|
||||
} else {
|
||||
return Result.error(this._data as E)
|
||||
}
|
||||
return this._data as E
|
||||
}
|
||||
public err(): Option<E> {
|
||||
if (this._state === State.ERROR) {
|
||||
return Option.some(this._data as E)
|
||||
} else {
|
||||
return Option.none()
|
||||
}
|
||||
public and_then<U>(f: (data: T) => Result<U, E>) : Result<U, E> {
|
||||
if (this._state === State.OK) {
|
||||
return f(this._data as T)
|
||||
} else {
|
||||
return Result.error(this._data as E)
|
||||
}
|
||||
}
|
||||
public map_err<F>(f: (err: E) => F): Result<T, F> {
|
||||
if (this._state === State.ERROR) {
|
||||
return Result.error(f(this._data as E))
|
||||
} else {
|
||||
return Result.ok(this._data as T)
|
||||
}
|
||||
public or<F>(res: Result<T, F>) : Result<T, F> {
|
||||
if (this._state === State.OK) {
|
||||
return new Result<T, F>(this._data as T, State.OK)
|
||||
} else {
|
||||
return res
|
||||
}
|
||||
}
|
||||
public inspect_err(f: (err: E) => void): Result<T, E> {
|
||||
if (this._state === State.ERROR) {
|
||||
f(this._data as E)
|
||||
}
|
||||
public or_else<F>(f: (err: E) => Result<T, F>) : Result<T, F> {
|
||||
if (this._state === State.OK) {
|
||||
return Result.ok(this._data as T)
|
||||
} else {
|
||||
return f(this._data as E)
|
||||
}
|
||||
return this
|
||||
}
|
||||
|
||||
// *****************************************************************************************************************
|
||||
// Combine
|
||||
public and<U>(res: Result<U, E>): Result<U, E> {
|
||||
if (this._state === State.OK) {
|
||||
return res
|
||||
} else {
|
||||
return Result.error(this._data as E)
|
||||
}
|
||||
}
|
||||
public and_then<U>(f: (data: T) => Result<U, E>): Result<U, E> {
|
||||
if (this._state === State.OK) {
|
||||
return f(this._data as T)
|
||||
} else {
|
||||
return Result.error(this._data as E)
|
||||
}
|
||||
}
|
||||
public or<F>(res: Result<T, F>): Result<T, F> {
|
||||
if (this._state === State.OK) {
|
||||
return new Result<T, F>(this._data as T, State.OK)
|
||||
} else {
|
||||
return res
|
||||
}
|
||||
}
|
||||
public or_else<F>(f: (err: E) => Result<T, F>): Result<T, F> {
|
||||
if (this._state === State.OK) {
|
||||
return Result.ok(this._data as T)
|
||||
} else {
|
||||
return f(this._data as E)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
export const enum State {
|
||||
OK,
|
||||
ERROR
|
||||
OK,
|
||||
ERROR
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user