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

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