Result

Index

Accessor

• get
• getError
• getOrElse
• getOrThrow

Constructor

• Error
• Ok

Type

• hasInstance
• isError
• isOk

Other

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

Accessor

get

• get<V>(self): Option.Some<V>
• get(self): Option.None
• get<V>(self): 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

getError

• getError<E>(self): Option.Some<E>
• getError(self): Option.None
• getError<E>(self): 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')

getOrElse

• getOrElse<V, VDefault>(self, getDefaultValue): 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'

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.

  @example

  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

  @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): 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): 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): 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

isOk

• isOk<V, E>(anyValue): 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

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.

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

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.

  @example

  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.

  @example

  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.

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

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

  @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()
  );