glowing-guacamole

Description

The Result and Option type from Rust ported to TypeScript.

Installation

npm install --save throwless

Usage

Result

import {ok, err, Result} from 'throwless';

const result = ok(42);

result.isOk(); // => true
result.isErr(); // => false

result.unwrap(); // => 42

result.map(i => i * 2).unwrap(); // => 84

const anotherResult = err(new Error('Something went wrong'));

if (anotherResult.isErr()) {
  // handle error here....
}

anotherResult.unwrap(); // => Throws Error "Something went wrong"

const mappedResult = anotherResult.mapErr(
  e => new Error('MyError: ' + e.message),
);

mappedResult.unwrap(); // => Throws Error "MyError: Something went wrong"

Option

import {some, none, Option} from 'throwless';

const result = some(42);

result.isSome(); // => true
...


const result2 = none<number>();

console.log(result.xor(result2)); // => Some(42)

Helper Functions for Result and Option

export const ok = <T, E>(value: T): Result<T, E> => new Ok(value);
export const err = <T, E>(error: E): Result<T, E> => new Err(error);

export const emptyOk = <E>(): Result<void, E> => new Ok(undefined);
export const emptyErr = <T>(): Result<T, void> => new Err(undefined);

export const some = <T>(value: T): Option<T> => new Some(value);
export const none = <T>(): Option<T> => new None();

Interfaces

Result<T, E>

interface Result<T, E> {
  isErr(): boolean;
  isOk(): boolean;

  ok(): Option<T>;
  err(): Option<E>;

  map<U>(fn: (value: T) => U): Result<U, E>;
  mapErr<F>(fn: (error: E) => F): Result<T, F>;

  mapOrElse<U>(fnMap: (value: T) => U, fnOrElse: (error: E) => U): U;

  and<U>(res: Result<U, E>): Result<U, E>;
  andThen<U>(fn: (value: T) => Result<U, E>): Result<U, E>;

  or<F>(res: Result<T, F>): Result<T, F>;
  orElse<F>(fn: (error: E) => Result<T, F>): Result<T, F>;

  expectErr(error: any): E;
  expect(error: any): T;

  unwrap(): T;
  unwrapErr(): E;

  unwrapOr(value: T): T;
  unwrapOrElse(fn: (error: E) => T): T;
}

Option<T>

interface Option<T> {
  isSome(): boolean;
  isNone(): boolean;

  expect(error: any): T;
  unwrap(): T;
  unwrapOr(value: T): T;
  unwrapOrElse(fn: () => T): T;

  map<U>(fn: (value: T) => U): Option<U>;
  mapOr<U>(value: U, fn: (value: T) => U): U;
  mapOrElse<U>(fnMap: (value: T) => U, fnOrElse: () => U): U;

  okOr<E>(error: E): Result<T, E>;
  okOrElse<E>(fn: () => E): Result<T, E>;

  and<U>(optb: Option<U>): Option<U>;
  andThen<U>(fn: (value: T) => Option<U>): Option<U>;

  filter(fn: (value: T) => boolean): Option<T>;

  or(optb: Option<T>): Option<T>;
  orElse(fn: () => Option<T>): Option<T>;

  xor(optb: Option<T>): Option<T>;
}