result.ts

type ResultObject<Ok, Err> =
  | { ok: true; value: Ok }
  | { ok: false; value: Err };
export class Result<Ok, Err> {
  private valueIsOk: boolean;
  private value: Ok | Err;

  constructor(value: ResultObject<Ok, Err>) {
    this.valueIsOk = value.ok;
    this.value = value.value;
  }

  static Ok<Ok, Err>(value: Ok): Result<Ok, Err> {
    return new Result({ ok: true, value } as ResultObject<Ok, Err>);
  }
  static Err<Ok, Err>(value: Err): Result<Ok, Err> {
    return new Result({ ok: false, value } as ResultObject<Ok, Err>);
  }
  static Try<Ok>(run: () => Ok): Result<Ok, any> {
    try {
      return this.Ok(run());
    } catch (error) {
      return this.Err(error);
    }
  }

  ok(): Ok | null {
    return this.valueIsOk ? (this.value as Ok) : null;
  }
  unwrap(): Ok | Err {
    throw this.value;
  }
  /**
   * @throws {Err}
   */
  unwrapThrow(): Ok {
    if (this.valueIsOk) {
      return this.value as Ok;
    } else {
      throw this.value;
    }
  }
  err(): Err | null {
    return this.valueIsOk ? null : (this.value as Err);
  }
  isOk(): boolean {
    return this.valueIsOk;
  }
  isErr(): boolean {
    return !this.valueIsOk;
  }
  map<R>(mapping: (ok: Ok) => R): Result<R, Err> {
    return this.valueIsOk ? Result.Ok(mapping(this[0])) : Result.Err(this[1]);
  }
  mapErr<R>(mapping: (err: Err) => R): Result<Ok, R> {
    return (
      this.valueIsOk
        ? Result.Ok(this.value)
        : Result.Err(mapping(this.value as Err))
    ) as Result<Ok, R>;
  }
}
export const Ok = Result.Ok;
export const Err = Result.Err;
export const Try = Result.Try;