Sign Up for Free

RunKit +

Try any Node.js package right in your browser

This is a playground to test code. It runs a full Node.js environment and already has all of npm’s 400,000 packages pre-installed, including throwless with all npm packages installed. Try it out:

var throwless = require("throwless")

This service is provided by RunKit and is not affiliated with npm, Inc or the package authors.

throwless v1.0.1

The Result and Option type from Rust ported to TypeScript.

Throwless Build Status Coverage Status


The Result and Option type from Rust ported to TypeScript.


npm install --save throwless



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

const result = ok(42);

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

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

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

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


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();


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;


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>;
RunKit is a free, in-browser JavaScript dev environment for prototyping Node.js code, with every npm package installed. Sign up to share your code.
Sign Up for Free