Examples

Basic usage:

const x = new Ok(2);
const y = new Err("late error");
expect(x.and(y)).toEqual(new Err("late error"));

const x = new Err("early error");
const y = new Ok("foo");
expect(x.and(y)).toEqual(new Err("early error"));

const x = new Err("not a 2");
const y = new Err("late error");
expect(x.and(y)).toEqual(new Err("not a 2"));

const x = new Ok(2);
const y = new Ok("different result type");
expect(x.and(y)).toEqual(new Ok("different result type"));

This function can be used for control flow based on Result values.

Examples

Basic usage:

const sq = (x: number) => new Ok(x * x);
const err = (x: number) => new Err(x);

expect(new Ok(2).andThen(sq).andThen(sq)).toEqual(new Ok(16));
expect(new Ok(2).andThen(sq).andThen(err)).toEqual(new Err(4));
expect(new Ok(2).andThen(err).andThen(sq)).toEqual(new Err(2));
expect(new Err(3).andThen(sq).andThen(sq)).toEqual(new Err(3));

Throws

Throws if the value is an Err, with an error message including the passed message, and the content of the Err.

Examples

Basic usage:

const x = new Err("emergency failure");
x.expect("Testing expect"); // throws an error with `Testing expect: emergency failure`

This function can be used to compose the results of two functions.

Examples

Print the number on each line of a string multiplied by two.

const lines = "1\n2\n3\n4\n";
const parse = (str: string): Result<number, typeof NaN> => {
  const num = parseInt(str, 10);
  return isNaN(num) ? new Err(num) : new Ok(num);
};

for (const num of lines.split("\n")) {
  const result = parse(num).map(n => n * 2);
  if (result.isOk()) console.log(result.unwrap())
}

This function can be used to pass through a successful result while handling an error.

Examples

Basic usage:

const stringify = (x: number) => `error code: ${x}`;

const x = new Ok(2);
expect(x.mapErr(stringify)).toEqual(new Ok(2));

const y = new Err(13);
expect(y.mapErr(stringify)).toEqual(new Err("error code: 13"));

Arguments passed to mapOr are eagerly evaluated; if you are passing the result of a function call, it is recommended to use mapOrElse, which is lazily evaluated.

Examples

const x = new Ok("foo");
expect(x.mapOr(42, str => str.length)).toBe(3);

const y = new Err("bar");
expect(y.mapOr(42, str => str.length)).toBe(42);

This function can be used to unpack a successful result while handling an error.

Examples

Basic usage:

const k = 21;

const x = new Ok("foo");
expect(x.mapOrElse(e => k * 2, str => str.length)).toBe(3);

const y = new Err("bar");
expect(y.mapOrElse(e => k * 2, str => str.length)).toBe(42);

Arguments passed to or are eagerly evaluated; if you are passing the result of a function call, it is recommended to use orElse, which is lazily evaluated.

Examples

Basic usage:

const x = new Ok(2);
const y = new Err("late error");
expect(x.or(y)).toEqual(new Ok(2));

const x = new Err("early error");
const y = new Ok(2);
expect(x.or(y)).toEqual(new Ok(2));

const x = new Err("not a 2");
const y = new Err("late error");
expect(x.or(y)).toEqual(new Err("late error"));

const x = new Ok(2);
const y = new Ok("100");
expect(x.or(y)).toEqual(new Ok(2));

This function can be used for control flow based on result values.

Examples

Basic usage:

const sq = (x: number) => new Ok(x * x);
const err = (x: number) => new Err(x);

expect(new Ok(2).orElse(sq).orElse(sq)).toEqual(new Ok(2));
expect(new Ok(2).orElse(err).orElse(sq)).toEqual(new Ok(2));
expect(new Err(3).orElse(sq).orElse(err)).toEqual(new Ok(9));
expect(new Err(3).orElse(err).orElse(err)).toEqual(new Err(3));

Because this function may throw, its use is generally discouraged. Instead, handle the Err case explicitly, or call unwrapOr or unwrapOrElse.

Throws

Throws if the value is an Err, with an error message provided by the Err's value.

Examples

Basic usage:

const x = new Ok(2);
expect(x.unwrap()).toBe(2);

const x = new Err("emergency failure");
x.unwrap(); // throws an Error with `emergency failure`

Arguments passed to unwrapOr are eagerly evaluated; if you are passing the result of a function call, it is recommended to use unwrapOrElse, which is lazily evaluated.

Examples

Basic usage:

const defaultValue = 2;
const x = new Ok(9);
expect(x.unwrapOr(defaultValue)).toBe(9);

const x = new Err("error");
expect(x.unwrapOr(defaultValue)).toBe(defaultValue);

Examples

Basic usage:

const count = (x: string) => x.length;

expect(new Ok(2).unwrapOrElse(count)).toBe(2);
expect(new Err("foo").unwrapOrElse(count)).toBe(3);