Class Result<T, E>

Result allows you to show to a consumer that a function might throw and force them to handle it.

T Value type

E Error type

Usage

function functionThatMightFail(): Result<T, E>;

Examples

const functionThatMightFail = (): Result<string, string> => Ok("Hello, World!");

const result = functionThatMightFail();

console.log(result.unwrap()); // "Hello, World!"

Type Parameters

  • T
  • E

Constructors

constructor

Methods

expect expectErr isErr isOk map mapErr mapErrOr mapErrOrElse mapOr mapOrElse match unwrap unwrapErr unwrapErrOr unwrapErrOrElse unwrapOr unwrapOrElse

Constructors

constructor

Methods

expect

  • expect(message): T

  • Tries to return value if value is Err throws custom error message.

    Parameters

    • message: string

      Message to show when value is Err

    Returns T

    Usage

    result.expect("Custom message");

    Examples

    When Ok

    const functionThatMightFail = (): Result<string, string> => Ok("Hello!");

    const result = functionThatMightFail();

    console.log(result.expect("I failed!")); // "Hello!"

    When Err

    const functionThatMightFail = (): Result<string, string> => Err("oops!");

    const result = functionThatMightFail();

    result.expect("I failed!"); // Error: I failed!

expectErr

  • expectErr(message): E

  • Tries to return error value if value is Ok throws custom error message

    Parameters

    • message: string

    Returns E

    Usage

    result.expectErr("Custom message");

    Examples

    When Ok

    const functionThatMightFail = (): Result<string, string> => Ok("Hello!");

    const result = functionThatMightFail();

    console.log(result.expectErr("I failed!")); // Error: I failed!

    When Err

    const functionThatMightFail = (): Result<string, string> => Err("oops!");

    const result = functionThatMightFail();

    console.log(result.expectErr("I failed!")); // "oops!"

isErr

  • isErr(): boolean

  • Returns true if result is Err

    Returns boolean

    Usage

    result.isErr();

isOk

  • isOk(): boolean

  • Returns true if result is Ok

    Returns boolean

    Usage

    result.isOk();

map

  • map<A>(fn): Result<A, E>

  • Maps Result<T, E> to Result<A, E> using the passed mapping function

    Type Parameters

    • A

    Parameters

    • fn: ((val: T) => A)

      Mapping function

        • (val): A

        • Parameters

          • val: T

          Returns A

    Returns Result<A, E>

    Usage

    result.map((val) => val.length);

    Examples

    const functionThatMightFail = (): Result<string, string> => Ok("Hello, World!");

    const result = functionThatMightFail();

    const hello = result.map((val) => val.slice(0, 5));

    console.log(hello.unwrap()); // "Hello"

mapErr

  • mapErr<A>(fn): Result<T, A>

  • Maps Result<T, E> to Result<T, A> using the passed mapping function

    Type Parameters

    • A

    Parameters

    • fn: ((err: E) => A)

      Mapping function

        • (err): A

        • Parameters

          • err: E

          Returns A

    Returns Result<T, A>

    Usage

    result.mapErr((err) => getCodeMsg(err));

    Examples

    const functionThatMightFail = (): Result<string, string> => Err(10);

    const result = functionThatMightFail();

    const message = result.mapErr(() => "Error");

    console.log(message); // "Error"

mapErrOr

  • mapErrOr<A>(defaultVal, fn): A

  • In the Err case returns the mapped value using the function else returns defaultVal

    Type Parameters

    • A

    Parameters

    • defaultVal: A

      Value to be returned when Ok

    • fn: ((err: E) => A)

      Mapping function to map in case of Err

        • (err): A

        • Parameters

          • err: E

          Returns A

    Returns A

    Usage

    result.mapErrOr("Should've been error", (err) => getCodeMsg(err));

    Examples

    When Ok

    const functionThatMightFail = (): Result<string, string> => Ok("foo");

    const result = functionThatMightFail();

    const message = result.mapErrOr("Should've been error", () => "Error");

    console.log(message); // "Should've been error"

    When Err

    const functionThatMightFail = (): Result<string, string> => Err(10);

    const result = functionThatMightFail();

    const message = result.mapErrOr("Should've been error", () => "Error");

    console.log(message); // "Error"

mapErrOrElse

  • mapErrOrElse<A>(def, fn): A

  • In the Err case returns the mapped value using the function else returns value of def

    Type Parameters

    • A

    Parameters

    • def: ((val: T) => A)

      Mapping function called when Ok

        • (val): A

        • Parameters

          • val: T

          Returns A

    • fn: ((err: E) => A)

      Mapping function called when Err

        • (err): A

        • Parameters

          • err: E

          Returns A

    Returns A

    Usage

    result.mapErrOrElse(() => "Value", (_) => "Error!");

    Examples

    When Ok

    const functionThatMightFail = (): Result<string, string> => Ok("foo");

    const result = functionThatMightFail();

    const length = result.mapErrOrElse(() => 1, (val) => val.length);

    console.log(length); // 1

    When Err

    const functionThatMightFail = (): Result<string, string> => Err("oops!");

    const result = functionThatMightFail();

    const length = result.mapOr(() => 1, (val) => val.length);

    console.log(length); // 4

mapOr

  • mapOr<A>(defaultVal, fn): A

  • In the Ok case returns the mapped value using the function else returns defaultVal

    Type Parameters

    • A

    Parameters

    • defaultVal: A

      Value to be returned when Err

    • fn: ((val: T) => A)

      Mapping function to map in case of Ok

        • (val): A

        • Parameters

          • val: T

          Returns A

    Returns A

    Usage

    result.mapOr(1, (val) => val.length);

    Examples

    When Ok

    const functionThatMightFail = (): Result<string, string> => Ok("foo");

    const result = functionThatMightFail();

    const length = result.mapOr(1, (val) => val.length);

    console.log(length); // 3

    When Err

    const functionThatMightFail = (): Result<string, string> => Err("oops!");

    const result = functionThatMightFail();

    const length = result.mapOr(1, (val) => val.length);

    console.log(length); // 1

mapOrElse

  • mapOrElse<A>(def, fn): A

  • In the Ok case returns the mapped value using fn else returns value of def

    Type Parameters

    • A

    Parameters

    • def: ((err: E) => A)

      Mapping function called when Err

        • (err): A

        • Parameters

          • err: E

          Returns A

    • fn: ((val: T) => A)

      Mapping function called when Ok

        • (val): A

        • Parameters

          • val: T

          Returns A

    Returns A

    Usage

    result.mapOrElse(() => 1, (val) => val.length);

    Examples

    When Ok

    const functionThatMightFail = (): Result<string, string> => Ok("foo");

    const result = functionThatMightFail();

    const length = result.mapOrElse(() => 1, (val) => val.length);

    console.log(length); // 3

    When Err

    const functionThatMightFail = (): Result<string, string> => Err("oops!");

    const result = functionThatMightFail();

    const length = result.mapOr(() => 1, (val) => val.length);

    console.log(length); // 1

match

  • match<A, B>(success, failure): A | B

  • Allows you to run callbacks based on the result.

    Type Parameters

    • A
    • B = A

    Parameters

    • success: ((val: T) => A)

      callback to be run when result is success

        • (val): A

        • Parameters

          • val: T

          Returns A

    • failure: ((err: E) => B)

      callback to be run when result is failure

        • (err): B

        • Parameters

          • err: E

          Returns B

    Returns A | B

    Usage

    result.match(
    	(val) => val,
    	() => {
    		throw new Error('oops!')
    	}
    );

    Examples

    const functionThatMightFail = (): Result<string, string> => Ok("Hello, World!");

    const result = functionThatMightFail();

    const val = result.match(
    	(val) => val,
    	() => {
    		throw new Error('oops!')
    	}
    );

    console.log(val); // "Hello, World!"

unwrap

  • unwrap(): T

  • Tries to return value if value is Err throws generic error message.

    Returns T

    Usage

    result.unwrap();

    Examples

    When Ok

    const functionThatMightFail = (): Result<string, string> => Ok("Hello!");

    const result = functionThatMightFail();

    console.log(result.unwrap()); // "Hello!"

    When Err

    const functionThatMightFail = (): Result<string, string> => Err("oops!");

    const result = functionThatMightFail();

    result.unwrap(); // Error: Attempted to call `.unwrap()` on a non `Ok` value.

unwrapErr

  • unwrapErr(): E

  • Tries to return err if value is Ok throws generic error message.

    Returns E

    Usage

    result.unwrapErr();

    Examples

    When Ok

    const functionThatMightFail = (): Result<string, string> => Ok("Hello!");

    const result = functionThatMightFail();

    result.unwrapErr(); // Error: Attempted to call `.unwrapErr()` on a non `Err` value.

    When Err

    const functionThatMightFail = (): Result<string, string> => Err("oops!");

    const result = functionThatMightFail();

    console.log(result.unwrapErr()); // "oops!"

unwrapErrOr

  • unwrapErrOr(defaultVal): E

  • Tries to unwrap the error if vale is Ok returns defaultVal

    Parameters

    • defaultVal: E

    Returns E

    Usage

    result.unwrapErrOr("Error");

    Examples

    When Ok

    const functionThatMightFail = (): Result<string, string> => Ok("Hello!");

    const result = functionThatMightFail();

    console.log(result.unwrapErrOr("Yellow!")); // "Yellow!"

    When Err

    const functionThatMightFail = (): Result<string, string> => Err("oops!");

    const result = functionThatMightFail();

    console.log(result.unwrapErrOr("Yellow!")); // "oops!"

unwrapErrOrElse

  • unwrapErrOrElse(fn): E

  • Tries to return the error if value is Ok calls fn

    Parameters

    • fn: ((val: T) => E)

      Function called if Ok

      Usage

      result.unwrapErrOrElse(() => "Error!");

      Examples

      When Ok

      const functionThatMightFail = (): Result<string, string> => Ok("Hello!");

      const result = functionThatMightFail();

      console.log(result.unwrapErrOrElse(() => "oops!")); // "oops!"

      When Err

      const functionThatMightFail = (): Result<string, string> => Err("oops!");

      const result = functionThatMightFail();

      console.log(result.unwrapErrOrElse(() => "Hello!")); // "oops!"
        • (val): E

        • Parameters

          • val: T

          Returns E

    Returns E

unwrapOr

  • unwrapOr(defaultVal): T

  • Tries to unwrap the value if value is Err returns defaultVal

    Parameters

    • defaultVal: T

      Value to be returned if Err

    Returns T

    Usage

    result.unwrapOr(7);

    Examples

    When Ok

    const functionThatMightFail = (): Result<string, string> => Ok("Hello!");

    const result = functionThatMightFail();

    console.log(result.unwrapOr("Yellow!")); // "Hello!"

    When Err

    const functionThatMightFail = (): Result<string, string> => Err("oops!");

    const result = functionThatMightFail();

    console.log(result.unwrapOr("Yellow!")); // "Yellow!"

unwrapOrElse

  • unwrapOrElse(fn): T

  • Tries to return the value if value is Err calls fn

    Parameters

    • fn: ((err: E) => T)

      Function called if Err

      Usage

      result.unwrapOrElse(() => "Hello!");

      Examples

      When Ok

      const functionThatMightFail = (): Result<string, string> => Ok("Hello!");

      const result = functionThatMightFail();

      console.log(result.unwrapOrElse(() => "oops!")); // "Hello!"

      When Err

      const functionThatMightFail = (): Result<string, string> => Err("oops!");

      const result = functionThatMightFail();

      console.log(result.unwrapOrElse(() => "Hello!")); // "Hello!"
        • (err): T

        • Parameters

          • err: E

          Returns T

    Returns T

Settings

Member Visibility

On This Page

UsageExamples
Constructors
Methods