Skip to main content

Result

Index

Accessor

Constructor

Type

Other

Accessor

get

  • Returns the value if Result.Ok, Option.None if Result.Error

    @example
    let x = Ok('foo');
    Result.get(x);// Option.Some('foo')

    let x = Error('foo');
    Result.get(x);// Option.None

    Type parameters

    • V

getError

  • Returns the error if Result.Error, Option.None if Result.Ok

    @example
    let x = Ok('foo');
    Result.getError(x);// Option.None

    let x = Error('foo');
    Result.getError(x);// Option.Some('foo')

    Type parameters

    • E

getOrElse

  • getOrElse<V, VDefault>(self: Result<V, unknown>, getDefaultValue: () => VDefault): V | VDefault

  • Returns the value if Result.Ok, getDefaultValue() if Result.Error.

    @example
    let x = Ok('foo');
    Result.getOrElse(x, () => 'bar');// 'foo'

    let x = Error('foo');
    Result.getOrElse(x, () => 'bar');// 'bar'

    Type parameters

    • V
    • VDefault

getOrThrow

  • getOrThrow<V>(self: Result<V, unknown>): V

  • Returns the value if Result.Ok, throw error if Result.Error.

    ⚠ Impure function that may throw an error, its use is generally discouraged.

    @example
    let x = Ok('foo');
    Result.getOrThrow(x);// 'foo'

    let x = Error('foo');
    Result.getOrThrow(x);// throw 'error'

    Type parameters

    • V

Constructor

Error

  • Error(): Result<never, void>
  • Error<E>(resultError: E): Result<never, E>

  • Create a new Error object

    @example
    Error();// { _: 'Error', ok: false, value: undefined }
    Error(new globalThis.Error('my message'));// { _: 'Error', ok: false, error: Error}

Ok

  • Ok(): Result<void, never>
  • Ok<V>(resultValue: V): Result<V, never>

  • Create a new Ok object

    @example
    Ok();// { _: 'Ok', ok: true, value: undefined }
    Ok('value');// { _: 'Ok', ok: true, value: 'value'}

Type

hasInstance

  • hasInstance(anyValue: unknown): anyValue is Result<unknown, unknown>

  • Return true if anyValue is Result.Ok or Result.Error

    @example
    Result.hasInstance(null); // === false
    Result.hasInstance(Result.Ok(null)); // === true

isError

  • isError<V, E>(anyValue: Result<V, E>): anyValue is Error<E>

  • Return true if anyValue is Result.Error

    @example
    let x = Ok('foo');
    console.log(Result.isError(x));// false

    let x = Error('foo');
    console.log(Result.isError(x));// true

    Type parameters

    • V
    • E

isOk

  • isOk<V, E>(anyValue: Result<V, E>): anyValue is Ok<V>

  • Return true if anyValue is Result.Ok

    @example
    let x = Ok('foo');
    console.log(isOk(x));// true

    let x = Error('foo');
    console.log(isOk(x));// false

    Type parameters

    • V
    • E

Other

Error

Error<E>:

Type parameters

  • E

readonlyerror

error: E

The error value

readonlyok

ok: false

false only for Error objects

Ok

Ok<V>:

Type parameters

  • V

readonlyok

ok: true

true only for Ok objects

readonlyvalue

value: V

The success value

andThen

  • andThen<VFrom, EFrom, VTo, ETo>(self: Result<VFrom, EFrom>, fn: (value: VFrom) => Result<VTo, ETo>): Result<VTo, EFrom | ETo>

  • Calls fn if the result is Result.Ok, otherwise returns the Result.Error value of self. This function can be used for control flow based on Result values.

    @example
    const square = (num: number): Result<number, 'TestError'> => Result.Ok(num * num);
    Result.andThen(Result.Ok(4), square); // Result.Ok(16)
    Result.andThen(Result.Error('TestError'), square); // Result.Error('TestError')

    Type parameters

    • VFrom
    • EFrom
    • VTo
    • ETo

map

  • map<VFrom, VTo, E>(self: Result<VFrom, E>, fn: (value: VFrom) => VTo): Result<VTo, E>

  • Maps a Result<ValueFrom, Error> to Result<ValueTo, Error> by applying a function to a contained Result.Ok value, leaving a Result.Error value untouched. This function can be used to compose the results of two functions.

    @example
    const result = Ok('foo');
    Result.map(result, (value) => `${value}_bar`));// Ok('foo_bar')

    Type parameters

    • VFrom
    • VTo
    • E

mapError

  • mapError<V, EFrom, ETo>(self: Result<V, EFrom>, fn: (error: EFrom) => ETo): Result<V, ETo>

  • Maps a Result<Value, ErrorFrom> to Result<Value, ErrorTo> by applying a function to a contained Result.Error value, leaving a Result.Ok value untouched. This function can be used to pass through a successful result while handling an error.

    @example
    const result = Error('foo');
    Result.mapError(result, (value) => `${value}_bar`));// Error('foo_bar')

    Type parameters

    • V
    • EFrom
    • ETo

orElse

  • orElse<VFrom, EFrom, VTo, ETo>(self: Result<VFrom, EFrom>, fn: (error: EFrom) => Result<VTo, ETo>): Result<VFrom | VTo, ETo>

  • Calls fn if the result is Result.Error, otherwise returns the Result.Ok value of self. This function can be used for control flow based on result values.

    @example
    const handleError = (message: string) => Result.Ok(message + '_handled');
    Result.orElse(Result.Error('TestError'), square); // Result.Ok('TestError_handled')
    Result.orElse(Result.Ok(4), square); // Result.Ok(4)

    Type parameters

    • VFrom
    • EFrom
    • VTo
    • ETo

tryCall

  • tryCall<V, E>(block: () => Promise<V>, onError: (error: unknown) => Promise<E>): Promise<Result<V, E>>
  • tryCall<V, E>(block: () => Exclude<V, Promise<unknown>>, onError: (error: unknown) => Exclude<E, Promise<unknown>>): Result<V, E>

  • Returns Ok(block()). If an error was thrown then it returns Error(onError(<<thrown error>>)) instead

    @example
    const class InvalidURLError extends Error {}
    const result = Result.tryCall(
     () => new URL('my/url'),
     (error) => new InvalidURLError()
    );

    const class FetchError extends Error {}
    const result = Result.tryCall(
     () => fetch('my/url'),
     () => new FetchError()
    );

    Type parameters

    • V
    • E
Page Options