Result

Index

Accessor

• get
• getError
• getOrElse
• getOrThrow

Constructor

• Error
• Ok

Type

• hasInstance
• isError
• isOk

Other

• Error
• Ok
• andThen
• map
• mapError
• match
• orElse
• tryCall

Accessor

get

• get<V>(result: Result<V, never>): Option.Some<V>
• get(result: Result<never, unknown>): Option.None
• get<V>(result: Result<V, unknown>): Option<V>

• 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

• getError<E>(result: Result<never, E>): Option.Some<E>
• getError(result: Result<unknown, never>): Option.None
• getError<E>(result: Result<unknown, E>): Option<E>

• 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>(result: 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>(result: 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>(result: 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>(result: 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>(result: 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

match

• match<Value, Error, Return>(result: Result<Value, Error>, matchers: { Error: (error: Error) => Return; Ok: (value: Value) => Return }): Return

• Return matchers.Ok(value) if result is Ok, otherwise matchers.Error(error)

  @example

  const stringify = (opt: Result<{foo: string}, { bar: string}>) => Option.match(opt, {
   Ok: ({ foo }) => foo + '_ok',
   Error: ({ bar }) => bar + '_error',
  });
  
  const okString = stringify(Result.Ok({ foo: 'foo_value' })); // 'foo_value_ok'
  const errorString = stringify(Result.Error({ bar: 'bar_value' })); // 'bar_value_error'

  ---

  Type parameters

  • Value
  • Error
  • Return

orElse

• orElse<VFrom, EFrom, VTo, ETo>(result: 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