rust/src/result.ts

import logger from 'log'
import {Option} from './option'

const log = logger('result')

export class Result<T, E = []> {
    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())
    }

    // 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
        }

        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)
        }
    }

    // *****************************************************************************************************************
    // 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.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
    }

    // *****************************************************************************************************************
    // 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
}