Interface ResultMethods<T, E>

All the methods available on Result<T, E>.

interface ResultMethods<T, E> {
 and: (other: Result<U, E>) => Result<U, E>;
 andThen: (fn: (value: T) => Result<U, E>) => Result<U, E>;
 equals: (other: Result<T, E>) => boolean;
 err: () => Option<E>;
 expect: (msg: string) => T;
 expectErr: (msg: string) => E;
 flatten: () => Result<T, E>;
 inspect: (fn: (value: T) => void) => Result<T, E>;
 inspectErr: (fn: (error: E) => void) => Result<T, E>;
 isErr: () => boolean;
 isErrAnd: (fn: (error: E) => boolean) => boolean;
 isOk: () => boolean;
 isOkAnd: (fn: (value: T) => boolean) => boolean;
 map: (fn: (value: T) => U) => Result<U, E>;
 mapErr: (fn: (error: E) => U) => Result<T, U>;
 mapOr: (defaultValue: U, fn: (value: T) => U) => Result<U, E>;
 mapOrElse: (defaultFn: () => U, mapFn: (value: T) => U) => Result<U, E>;
 ok: () => Option<T>;
 or: (other: Result<U, E>) => Result<U, E>;
 orElse: (fn: () => Result<U, E>) => Result<U, E>;
 strictEquals: (other: Result<T, E>) => boolean;
 unwrap: () => T;
 unwrapErr: () => E;
 unwrapOr: (defaultValue: T | U) => T | U;
 unwrapOrElse: (fn: () => T | U) => T | U;
}

Type Parameters

T
The type of the success value
E
The type of the error value

Index

Properties

equals

equals: (other: Result<T, E>) => boolean

Returns true if both results are Ok and their success values are equal using the JavaScript == operator, or if both results are Err and their error values are equal using the JavaScript == operator. If the inner values are Results or Options, they will be compared using their own equals method.

Example

Ok(1).equals(Ok(1)); // true
Ok(Ok(1)).equals(Ok(Ok(1))); // true
Ok(Some(1)).equals(Ok(Some(1))); // true
Ok(Err(1)).equals(Ok(Err(1))); // true
Err(1).equals(Err(1)); // true
Err(1).equals(Ok(1)); // false

@param other - The result to compare against.
@returns {boolean} Whether the results are equal.
@group Equality

Equality Checks

strictEquals

strictEquals: (other: Result<T, E>) => boolean

Returns true if both results are Ok and their success values are equal using the JavaScript === operator, or if both results are Err and their error values are equal using the JavaScript === operator. If the inner values are Results or Options, they will be compared using their own strictEquals method.

Type declaration

- (other: Result<T, E>): boolean
- Parameters
 - other: Result<T, E>
 The result to compare against.
 Returns boolean
 Whether the results are strictly equal.

Example

const obj = {}

Ok(obj).strictEquals(Ok(obj)); // true
Ok(obj).strictEquals(Ok({})); // false
Err(obj).strictEquals(Err(obj)); // true
Err(obj).strictEquals(Err({})); // false
Ok(Some(obj)).strictEquals(Ok(Some(obj))); // true

Inspect Methods

inspect

inspect: (fn: (value: T) => void) => Result<T, E>

Calls fn with the success value if the result is Ok, otherwise does nothing. Returns the original result.

Type declaration

- (fn: (value: T) => void): Result<T, E>
- Parameters
 - fn: (value: T) => void
 A function that takes the success value.
 Returns Result<T, E>
 The original result.

Example

const result = Ok(1);
const result2 = Err("error");
const result3 = result.inspect(value => console.log(value)); // logs 1, returns result
const result4 = result2.inspect(value => console.log(value)); // Does nothing, returns result2

inspectErr

inspectErr: (fn: (error: E) => void) => Result<T, E>

Calls fn with the error value if the result is Err, otherwise does nothing. Returns the original result.

Type declaration

- (fn: (error: E) => void): Result<T, E>
- Parameters
 - fn: (error: E) => void
 A function that takes the error value.
 Returns Result<T, E>
 The original result.

Example

const result = Ok(1);
const result2 = Err("error");
const result3 = result.inspectErr(error => console.log(error)); // Does nothing, returns result
const result4 = result2.inspectErr(error => console.log(error)); // logs "error", returns result2

Query Methods

isErr

isErr: () => boolean

Returns true if the result is Err.

Type declaration

- (): boolean
- Returns boolean
  true if the result is Err, false otherwise.

Example

const result = Err("error");
const isErr = result.isErr(); // true

const result2 = Ok(1);
const isErr2 = result2.isErr(); // false

isErrAnd

isErrAnd: (fn: (error: E) => boolean) => boolean

Returns true if the result is Err and the given function returns true.

Type declaration

- (fn: (error: E) => boolean): boolean
- Parameters
  - fn: (error: E) => boolean
    A function that takes the error value and returns a boolean.
  Returns boolean
  true if the result is Err and the given function returns true, false otherwise.

Example

const result = Err("error");
const isErrAnd = result.isErrAnd(error => error === "error"); // true

const result2 = Ok(1);
const isErrAnd2 = result2.isErrAnd(error => error === "error"); // false

isOk

isOk: () => boolean

Returns true if the result is Ok.

Type declaration

- (): boolean
- Returns boolean
  true if the result is Ok, false otherwise.

Example

const result = Ok(1);
const isOk = result.isOk(); // true

const result2 = Err("error");
const isOk2 = result2.isOk(); // false

isOkAnd

isOkAnd: (fn: (value: T) => boolean) => boolean

Returns true if the result is Ok and the given function returns true.

Type declaration

- (fn: (value: T) => boolean): boolean
- Parameters
  - fn: (value: T) => boolean
    A function that takes the success value and returns a boolean.
  Returns boolean
  true if the result is Ok and the given function returns true, false otherwise.

Example

const result = Ok(1);
const isOkAnd = result.isOkAnd(value => value > 0); // true

const result2 = Err("error");
const isOkAnd2 = result2.isOkAnd(value => value > 0); // false

Transform Methods

and

and: (other: Result<U, E>) => Result<U, E>

Returns other if the result is Ok, otherwise returns the current error.

Type declaration

- (other: Result<U, E>): Result<U, E>
- Type Parameters
 - U
 The type of the success value in the new result.
 Parameters
 - other: Result<U, E>
 The result to return if this result is Ok.
 Returns Result<U, E>
 Either the provided result or an error result.

Example

const result = Ok(1);
const result2 = Err("error");
const result3 = result.and(result2); // Ok(1)
const result4 = result2.and(result); // Err("error")

andThen

andThen: (fn: (value: T) => Result<U, E>) => Result<U, E>

Returns None if the result is Err, otherwise calls fn with the success value and returns the result.

Type declaration

- (fn: (value: T) => Result<U, E>): Result<U, E>
- Type Parameters
 - U
 The type of the success value in the new result.
 Parameters
 - fn: (value: T) => Result<U, E>
 A function that takes the success value and returns a new result.
 Returns Result<U, E>
 The result of fn or an error result.

Example

const result = Ok(1);
const result2 = Err("error");
const result3 = result.andThen(value => Ok(value * 2)); // Ok(2)
const result4 = result2.andThen(value => Ok(value * 2)); // Err("error")

err

err: () => Option<E>

Converts the Result<T, E> into an Option<E>, mapping Ok(_) to None and Err(e) to Some(e).

Type declaration

- (): Option<E>
- Returns Option<E>
 An option containing the error value.

Example

const result = Ok(1);
const option = result.err(); // None
const result2 = Err("error");
const option2 = result2.err(); // Some("error")

flatten

flatten: () => Result<T, E>

Converts from Result<Result<T, E>, E> to Result<T, E>. Only one level of nesting is removed.

Type declaration

- (): Result<T, E>
- Returns Result<T, E>
 The flattened result.

Example

const result = Ok(Ok(1));
const result2 = Err(Err("error"));
const result3 = result.flatten(); // Ok(1)
const result4 = result2.flatten(); // Err("error")

map

map: (fn: (value: T) => U) => Result<U, E>

Maps a Result<T, E> to Result<U, E> by applying the function to the success value.

Type declaration

- (fn: (value: T) => U): Result<U, E>
- Type Parameters
 - U
 The type of the new success value.
 Parameters
 - fn: (value: T) => U
 A function that takes the success value and returns a new value.
 Returns Result<U, E>
 A new result with the transformed success value.

Example

const result = Ok(1);
const result2 = result.map(value => value * 2); // Ok(2)
const result3 = Err("error");
const result4 = result3.map(value => value * 2); // Err("error")

mapErr

mapErr: (fn: (error: E) => U) => Result<T, U>

Maps a Result<T, E> to Result<T, U> by applying the function to the error value.

Type declaration

- (fn: (error: E) => U): Result<T, U>
- Type Parameters
 - U
 The type of the new error value.
 Parameters
 - fn: (error: E) => U
 A function that takes the error value and returns a new error value.
 Returns Result<T, U>
 A new result with the transformed error value.

Example

const result = Ok(1);
const result2 = Err("error");
const result3 = result.mapErr(error => error.toUpperCase()); // Ok(1)
const result4 = result2.mapErr(error => error.toUpperCase()); // Err("ERROR")

mapOr

mapOr: (defaultValue: U, fn: (value: T) => U) => Result<U, E>

Returns a result wrapping the provided defaultValue if the result is Err, or calls fn with the success value and returns a new result wrapping its return value.

Type declaration

- (defaultValue: U, fn: (value: T) => U): Result<U, E>
- Type Parameters
 - U
 The type of the new success value.
 Parameters
 - defaultValue: U
 The value to use if the result is Err.
 - fn: (value: T) => U
 A function that takes the success value and returns a new value.
 Returns Result<U, E>
 A new result containing either the default or transformed value.

Example

const result = Ok(1);
const result2 = Err("error");
const result3 = result.mapOr(0, value => value * 2); // Ok(2)
const result4 = result2.mapOr(0, value => value * 2); // Ok(0)

mapOrElse

mapOrElse: (defaultFn: () => U, mapFn: (value: T) => U) => Result<U, E>

Returns a result wrapping the return value of defaultFn if the result is Err, or calls mapFn with the success value and returns a new result wrapping its return value. This function is useful for providing a default result that is expensive to compute or has side effects.

Type declaration

- (defaultFn: () => U, mapFn: (value: T) => U): Result<U, E>
- Type Parameters
 - U
 The type of the new success value.
 Parameters
 - defaultFn: () => U
 A function that returns the default value if the result is Err.
 - mapFn: (value: T) => U
 A function that takes the success value and returns a new value.
 Returns Result<U, E>
 A new result containing either the default or transformed value.

Example

const result = Ok(1);
const result2 = Err("error");
const result3 = result.mapOrElse(() => 0, value => value * 2); // Ok(2)
const result4 = result2.mapOrElse(() => 0, value => value * 2); // Ok(0)

ok

ok: () => Option<T>

Converts the Result<T, E> into an Option<T>, mapping Ok(v) to Some(v) and Err(_) to None.

Type declaration

- (): Option<T>
- Returns Option<T>
 An option containing the success value.

Example

const result = Ok(1);
const option = result.ok(); // Some(1)
const result2 = Err("error");
const option2 = result2.ok(); // None

or

or: (other: Result<U, E>) => Result<U, E>

Returns the current result if it is Ok, otherwise returns other.

Type declaration

- (other: Result<U, E>): Result<U, E>
- Type Parameters
 - U
 The type of the success value in the other result.
 Parameters
 - other: Result<U, E>
 The result to return if this result is Err.
 Returns Result<U, E>
 Either this result or the provided result.

Example

const result = Ok(1);
const result2 = Err("error");
const result3 = result.or(result2); // Ok(1)
const result4 = result2.or(result); // Ok(1)

orElse

orElse: (fn: () => Result<U, E>) => Result<U, E>

Returns the current result if it is Ok, otherwise calls fn and returns the result. This function is useful for providing a default result that is expensive to compute or has side effects.

Type declaration

- (fn: () => Result<U, E>): Result<U, E>
- Type Parameters
 - U
 The type of the success value in the new result.
 Parameters
 - fn: () => Result<U, E>
 A function that returns a new result.
 Returns Result<U, E>
 Either this result or the result of fn.

Example

const result = Ok(1);
const result2 = Err("error");
const result3 = result.orElse(() => result2); // Ok(1)
const result4 = result2.orElse(() => result); // Ok(1)

Unwrap Methods

expect

expect: (msg: string) => T

Returns the success value. If the result is Err, this will throw an error with the provided message.

Type declaration

- (msg: string): T
- Parameters
  - msg: string
    The message to throw if the result is Err.
  Returns T
  The success value.

Example

const result = Ok(1);
const value = result.expect("Expected a value"); // 1

const result2 = Err("error");
const value2 = result2.expect("Expected a value"); // throws Error

expectErr

expectErr: (msg: string) => E

Returns the error value. If the result is Ok, this will throw an error with the provided message.

Type declaration

- (msg: string): E
- Parameters
  - msg: string
    The message to throw if the result is Ok.
  Returns E
  The error value.

Example

const result = Ok(1);
const value = result.expectErr("Expected an error"); // throws Error

const result2 = Err("error");
const value2 = result2.expectErr("Expected an error"); // "error"

unwrap

unwrap: () => T

Returns the success value. If the result is Err, this will throw an error.

Type declaration

- (): T
- Returns T
  The success value.

Example

const result = Ok(1);
const value = result.unwrap(); // 1

const result2 = Err("error");
const value2 = result2.unwrap(); // throws Error

unwrapErr

unwrapErr: () => E

Returns the error value. If the result is Ok, this will throw an error.

Type declaration

- (): E
- Returns E
  The error value.

Example

const result = Err("error");
const error = result.unwrapErr(); // "error"

const result2 = Ok(1);
const error2 = result2.unwrapErr(); // throws Error

unwrapOr

unwrapOr: (defaultValue: T | U) => T | U

Returns the success value. If the result is Err, this will return the provided default value.

Type declaration

- (defaultValue: T | U): T | U
- Type Parameters
 - U
 Parameters
 - defaultValue: T | U
 The value to return if the result is Err.
 Returns T | U
 The success value or the default value.

Example

const result = Ok(1);
const value = result.unwrapOr(0); // 1

const result2 = Err("error");
const value2 = result2.unwrapOr(0); // 0

unwrapOrElse

unwrapOrElse: (fn: () => T | U) => T | U

Returns the success value. If the result is Err, this will call the provided function and return its result. This function is useful for providing a default value that is expensive to compute or has side effects.

Type declaration

- (fn: () => T | U): T | U
- Type Parameters
 - U
 Parameters
 - fn: () => T | U
 A function that returns the default value if the result is Err.
 Returns T | U
 The success value or the result of the function.

Example

const result = Ok(1);
const value = result.unwrapOrElse(() => 0); // 1

const result2 = Err("error");
const value2 = result2.unwrapOrElse(() => 0); // 0

Interface ResultMethods<T, E>

Type Parameters

Index

Properties

Equality Checks

Inspect Methods

Query Methods

Transform Methods

Unwrap Methods

Properties

equals

Example

Equality Checks

strictEquals

Type declaration

Parameters

Returns boolean

Example

Inspect Methods

inspect

Type declaration

Parameters

Returns Result<T, E>

Example

inspectErr

Type declaration

Parameters

Returns Result<T, E>

Example

Query Methods

isErr

Type declaration

Returns boolean

Example

isErrAnd

Type declaration

Parameters

Returns boolean

Example

isOk

Type declaration

Returns boolean

Example

isOkAnd

Type declaration

Parameters

Returns boolean

Example

Transform Methods

and

Type declaration

Type Parameters

Parameters

Returns Result<U, E>

Example

andThen

Type declaration

Type Parameters

Parameters

Returns Result<U, E>

Example

err

Type declaration

Returns Option<E>

Example

flatten

Type declaration

Returns Result<T, E>

Example

map

Type declaration

Type Parameters

Parameters

Returns Result<U, E>

Example

mapErr

Type declaration

Type Parameters

Parameters

Returns Result<T, U>