Type alias Result<R, E>

Result<R, E>: Readonly<{
    and: (<U>(res) => Result<U, E>);
    andThen: (<U>(getRes) => Result<U, E>);
    err: (() => Option<E>);
    expect: ((msg) => R);
    expectErr: ((msg) => E);
    isErr: (() => boolean);
    isErrAnd: ((fn) => boolean);
    isOk: (() => boolean);
    isOkAnd: ((fn) => boolean);
    map: (<U>(fn) => Result<U, E>);
    mapErr: (<F>(fn) => Result<R, F>);
    mapOr: (<U>(defaultValue, fn) => U);
    mapOrElse: (<U>(getDefaultValue, fn) => U);
    ok: (() => Option<R>);
    or: (<F>(res) => Result<R, F>);
    orElse: (<F>(getRes) => Result<R, F>);
    unwrap: (() => R);
    unwrapErr: (() => E);
    unwrapOr: ((defaultValue) => R);
    unwrapOrElse: ((getDefaultValue) => R);
}>

An implementation of Result from Rust stdlib

https://doc.rust-lang.org/std/result/enum.Result.html

Type Parameters

  • R

  • E

Type declaration

  • and: (<U>(res) => Result<U, E>)
    Ok('foo').and(otherResult); // returns `otherResult`
    Err('foo').and(otherResult); // returns `Err('foo')`
      • <U>(res): Result<U, E>
      • Ok('foo').and(otherResult); // returns `otherResult`
        Err('foo').and(otherResult); // returns `Err('foo')`

        Type Parameters

        • U

        Parameters

        Returns Result<U, E>

  • andThen: (<U>(getRes) => Result<U, E>)
    Ok(1).andThen((value) => Ok(value * 2)); // returns `Ok(2)`
    Ok(1).andThen((value) => Err(value * 2)); // returns `Err(2)`
    Err(1).andThen((value) => Ok(value * 2)); // returns `Err(1)`
      • <U>(getRes): Result<U, E>
      • Ok(1).andThen((value) => Ok(value * 2)); // returns `Ok(2)`
        Ok(1).andThen((value) => Err(value * 2)); // returns `Err(2)`
        Err(1).andThen((value) => Ok(value * 2)); // returns `Err(1)`

        Type Parameters

        • U

        Parameters

        Returns Result<U, E>

  • err: (() => Option<E>)
    Ok('foo').err(); // returns `None()`
    Err('foo').err(); // returns `Some('foo')`
      • (): Option<E>
      • Ok('foo').err(); // returns `None()`
        Err('foo').err(); // returns `Some('foo')`

        Returns Option<E>

  • expect: ((msg) => R)
    Ok('foo').expect('error message'); // returns `'foo'`
    Err('foo').expect('error message'); // throws `new Error('error message')`
      • (msg): R
      • Ok('foo').expect('error message'); // returns `'foo'`
        Err('foo').expect('error message'); // throws `new Error('error message')`

        Parameters

        • msg: string

        Returns R

  • expectErr: ((msg) => E)
    Ok('foo').expectErr('error message'); // throws `new Error('error message')`
    Err('foo').expectErr('error message'); // returns `'foo'`
      • (msg): E
      • Ok('foo').expectErr('error message'); // throws `new Error('error message')`
        Err('foo').expectErr('error message'); // returns `'foo'`

        Parameters

        • msg: string

        Returns E

  • isErr: (() => boolean)
    Ok('foo').isErr(); // returns `false`
    Err('foo').isErr(); // returns `true`
      • (): boolean
      • Ok('foo').isErr(); // returns `false`
        Err('foo').isErr(); // returns `true`

        Returns boolean

  • isErrAnd: ((fn) => boolean)
    Ok(123).isErrAnd((value) => value > 100); // returns `false`
    Err(123).isErrAnd((value) => value > 100); // returns `true`
    Err(12).isErrAnd((value) => value > 100); // returns `false`
      • (fn): boolean
      • Ok(123).isErrAnd((value) => value > 100); // returns `false`
        Err(123).isErrAnd((value) => value > 100); // returns `true`
        Err(12).isErrAnd((value) => value > 100); // returns `false`

        Parameters

        • fn: ((arg) => boolean)
            • (arg): boolean

            • Parameters

              • arg: E

              Returns boolean

        Returns boolean

  • isOk: (() => boolean)
    Ok('foo').isOk(); // returns `true`
    Err('foo').isOk(); // returns `false`
      • (): boolean
      • Ok('foo').isOk(); // returns `true`
        Err('foo').isOk(); // returns `false`

        Returns boolean

  • isOkAnd: ((fn) => boolean)
    Ok(123).isOkAnd((value) => value > 100); // returns `true`
    Ok(12).isOkAnd((value) => value > 100); // returns `false`
    Err(123).isOkAnd((value) => value > 100); // returns `false`
      • (fn): boolean
      • Ok(123).isOkAnd((value) => value > 100); // returns `true`
        Ok(12).isOkAnd((value) => value > 100); // returns `false`
        Err(123).isOkAnd((value) => value > 100); // returns `false`

        Parameters

        • fn: ((arg) => boolean)
            • (arg): boolean

            • Parameters

              • arg: R

              Returns boolean

        Returns boolean

  • map: (<U>(fn) => Result<U, E>)
    Ok(1).map((value) => value * 2); // returns `Ok(2)`
    Err(1).map((value) => value * 2); // returns `Err(1)`
      • <U>(fn): Result<U, E>
      • Ok(1).map((value) => value * 2); // returns `Ok(2)`
        Err(1).map((value) => value * 2); // returns `Err(1)`

        Type Parameters

        • U

        Parameters

        • fn: ((arg) => U)
            • (arg): U

            • Parameters

              • arg: R

              Returns U

        Returns Result<U, E>

  • mapErr: (<F>(fn) => Result<R, F>)
    Ok(1).mapErr((err) => err * 2); // returns `Ok(1)`
    Err(1).mapErr((err) => err * 2); // returns `Err(2)`
      • <F>(fn): Result<R, F>
      • Ok(1).mapErr((err) => err * 2); // returns `Ok(1)`
        Err(1).mapErr((err) => err * 2); // returns `Err(2)`

        Type Parameters

        • F

        Parameters

        • fn: ((arg) => F)
            • (arg): F

            • Parameters

              • arg: E

              Returns F

        Returns Result<R, F>

  • mapOr: (<U>(defaultValue, fn) => U)
    Ok(1).mapOr(10, (value) => value * 2); // returns `2`
    Err(1).mapOr(10, (value) => value * 2); // returns `10`
      • <U>(defaultValue, fn): U
      • Ok(1).mapOr(10, (value) => value * 2); // returns `2`
        Err(1).mapOr(10, (value) => value * 2); // returns `10`

        Type Parameters

        • U

        Parameters

        • defaultValue: U
        • fn: ((arg) => U)
            • (arg): U

            • Parameters

              • arg: R

              Returns U

        Returns U

  • mapOrElse: (<U>(getDefaultValue, fn) => U)
    Ok(1).mapOrElse((err) => err * 10, (value) => value * 2); // returns `2`
    Err(1).mapOrElse((err) => err * 10, (value) => value * 2); // returns `10`
      • <U>(getDefaultValue, fn): U
      • Ok(1).mapOrElse((err) => err * 10, (value) => value * 2); // returns `2`
        Err(1).mapOrElse((err) => err * 10, (value) => value * 2); // returns `10`

        Type Parameters

        • U

        Parameters

        • getDefaultValue: ((arg) => U)
            • (arg): U

            • Parameters

              • arg: E

              Returns U

        • fn: ((arg) => U)
            • (arg): U

            • Parameters

              • arg: R

              Returns U

        Returns U

  • ok: (() => Option<R>)
    Ok('foo').ok(); // returns `Some('foo')`
    Err('foo').ok(); // returns `None()`
      • (): Option<R>
      • Ok('foo').ok(); // returns `Some('foo')`
        Err('foo').ok(); // returns `None()`

        Returns Option<R>

  • or: (<F>(res) => Result<R, F>)
    Ok('foo').or(otherResult); // returns `Ok('foo').`
    Err('foo').or(otherResult); // returns `otherResult`
      • <F>(res): Result<R, F>
      • Ok('foo').or(otherResult); // returns `Ok('foo').`
        Err('foo').or(otherResult); // returns `otherResult`

        Type Parameters

        • F

        Parameters

        Returns Result<R, F>

  • orElse: (<F>(getRes) => Result<R, F>)
    Ok(1).orElse((value) => Ok(value * 2)); // returns `Ok(1)`
    Err(1).orElse((value) => Ok(value * 2)); // returns `Ok(2)`
    Err(1).orElse((value) => Err(value * 2)); // returns `Err(2)`
      • <F>(getRes): Result<R, F>
      • Ok(1).orElse((value) => Ok(value * 2)); // returns `Ok(1)`
        Err(1).orElse((value) => Ok(value * 2)); // returns `Ok(2)`
        Err(1).orElse((value) => Err(value * 2)); // returns `Err(2)`

        Type Parameters

        • F

        Parameters

        Returns Result<R, F>

  • unwrap: (() => R)
    Ok('foo').unwrap(); // returns `'foo'`
    Err('foo').unwrap(); // throws
      • (): R
      • Ok('foo').unwrap(); // returns `'foo'`
        Err('foo').unwrap(); // throws

        Returns R

  • unwrapErr: (() => E)
    Ok('foo').unwrapErr(); // throws
    Err('foo').unwrapErr(); // returns `'foo'`
      • (): E
      • Ok('foo').unwrapErr(); // throws
        Err('foo').unwrapErr(); // returns `'foo'`

        Returns E

  • unwrapOr: ((defaultValue) => R)
    Ok('foo').unwrapOr('bar'); // returns `'foo'`
    Err('foo').unwrapOr('bar'); // returns `'bar'`
      • (defaultValue): R
      • Ok('foo').unwrapOr('bar'); // returns `'foo'`
        Err('foo').unwrapOr('bar'); // returns `'bar'`

        Parameters

        • defaultValue: R

        Returns R

  • unwrapOrElse: ((getDefaultValue) => R)
    Ok(1).unwrapOrElse('bar'); // returns `1`
    Err(1).unwrapOrElse((err) => err * 2); // returns `2`
      • (getDefaultValue): R
      • Ok(1).unwrapOrElse('bar'); // returns `1`
        Err(1).unwrapOrElse((err) => err * 2); // returns `2`

        Parameters

        • getDefaultValue: ((arg) => R)
            • (arg): R

            • Parameters

              • arg: E

              Returns R

        Returns R

Settings

Member Visibility

Theme

Generated using TypeDoc