Aller au contenu principal

Result

Index

Accessor

Constructor

Type

Other

Accessor

get

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

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

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

getError

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

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

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

getOrElse

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

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

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

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

getOrThrow

  • getOrThrow<V>(self): V

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

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

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

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

Constructor

Error

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

  • Create a new Error object

    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): Result<V, never>

  • Create a new Ok object

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

Type

hasInstance

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

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

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

isError

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

  • Return true if anyValue is Result.Error

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

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

isOk

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

  • Return true if anyValue is Result.Ok

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

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

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, fn): 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.

    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')

map

  • map<VFrom, VTo, E>(self, fn): 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.

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

mapError

  • mapError<V, EFrom, ETo>(self, fn): 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.

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

orElse

  • orElse<VFrom, EFrom, VTo, ETo>(self, fn): 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.

    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)

tryCall

  • tryCall<V, E>(block, onError): Promise<Result<V, E>>
  • tryCall<V, E>(block, onError): Result<V, E>

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

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