Result

Result: object

Defined in: Core/Result.ts:27

Type Declaration

apply

apply: <E2, A>(arg) => <B, E1>(result) => Result<E2 | E1, B>

Applies a function wrapped in a Result to a value wrapped in a Result.

Type Parameters

E2

E2 = never

A

A = unknown

Parameters

arg

Result<E2, A>

Returns

<B, E1>(result) => Result<E2 | E1, B>

See

Result.map to apply a plain unary function to an Ok value.

Example

const add = (a: number) => (b: number) => a + b;
pipe(
  Result.make.ok(add),
  Result.apply(Result.make.ok(5)),
  Result.apply(Result.make.ok(3))
); // Ok(8)

assign

assign: <K, E2, A, B>(key, transform) => <E1>(result) => Result<E2 | E1, A & { [P in string]: B }>

Evaluates a new Result using the current accumulator and attaches the output to a new key.

Type Parameters

K

K extends string

E2

E2

A

A

B

B

Parameters

key

K

transform

(value) => Result<E2, B>

Returns

<E1>(result) => Result<E2 | E1, A & { [P in string]: B }>

See

Result.assignTo to initialize a pipeline accumulator record.

Example

pipe(
  Result.make.ok({ a: 1 }),
  Result.assign("b", ({ a }) => Result.make.ok(a + 1))
); // Ok({ a: 1, b: 2 })

assignTo

assignTo: <K>(key) => <E, A>(result) => Result<E, { [P in string]: A }>

Converts a Result value into an object containing a single property. Initiates the pipeline accumulator record.

Type Parameters

K

K extends string

Parameters

key

K

Returns

<E, A>(result) => Result<E, { [P in string]: A }>

See

Result.assign to append additional fields to an accumulator record.

Example

pipe(Result.make.ok(42), Result.assignTo("value")); // Ok({ value: 42 })

bimap

bimap: <E1, E2, A, B>(onErr, onOk) => (result) => Result<E2, B>

Transforms both branches of a Result simultaneously. Applies onErr to Err values and onOk to Ok values.

Type Parameters

E1

E1

E2

E2

A

A

B

B

Parameters

onErr

(error) => E2

onOk

(value) => B

Returns

(result) => Result<E2, B>

See

• Result.map to transform only the success value.
• Result.mapError to transform only the error value.

Example

pipe(
  Result.make.ok(5),
  Result.bimap(
    (e) => `Error: ${e}`,
    (n) => n * 2
  )
); // Ok(10)

chain

chain: <E2, A, B>(transform) => <E1>(result) => Result<E2 | E1, B>

Chains Result computations. If the first is Ok, passes the value to transform. If the first is Err, propagates the error.

Type Parameters

E2

E2

A

A

B

B

Parameters

transform

(value) => Result<E2, B>

Returns

<E1>(result) => Result<E2 | E1, B>

See

Result.map to transform the inner value without returning a new Result.

Example

const validatePositive = (n: number): Result<string, number> =>
  n > 0 ? Result.make.ok(n) : Result.make.err("Must be positive");

pipe(Result.make.ok(5), Result.chain(validatePositive)); // Ok(5)
pipe(Result.make.ok(-1), Result.chain(validatePositive)); // Err("Must be positive")

ensure

ensure: {<A, B, E2>(refinement, onFail): <E1>(result) => Result<E2 | E1, B>; <A, E2>(predicate, onFail): <E1>(result) => Result<E2 | E1, A>; }

Narrows an Ok value with a predicate, converting to Err(onFail(value)) if the predicate returns false.

Call Signature

<A, B, E2>(refinement, onFail): <E1>(result) => Result<E2 | E1, B>

Type Parameters

A

A

B

B

E2

E2

Parameters

refinement

(value) => value is B

onFail

(value) => E2

Returns

<E1>(result) => Result<E2 | E1, B>

Call Signature

<A, E2>(predicate, onFail): <E1>(result) => Result<E2 | E1, A>

Type Parameters

A

A

E2

E2

Parameters

predicate

(value) => boolean

onFail

(value) => E2

Returns

<E1>(result) => Result<E2 | E1, A>

See

Result.from.Predicate to lift a value into a Result based on a predicate.

Example

pipe(
  Result.make.ok(15),
  Result.ensure((n) => n >= 18, (n) => `Age ${n} is below 18`)
); // Err("Age 15 is below 18")

from

from: object

from.Maybe

Maybe: <E>(onNone) => <A>(maybe) => Result<E, A>

Creates a Result from a Maybe. Some becomes Ok, None becomes error from onNone.

Type Parameters

E

E

Parameters

onNone

() => E

Returns

<A>(maybe) => Result<E, A>

See

Result.to.Maybe to convert a Result back into a Maybe.

Example

pipe(Maybe.make.none(), Result.from.Maybe(() => "is none")); // Err("is none")
pipe(Maybe.make.some(42), Result.from.Maybe(() => "is none")); // Ok(42)

from.nullable

nullable: <E>(onNull) => <A>(value) => Result<E, NonNullable<A>>

Creates a Result from a nullable value. Returns Ok if the value is not null or undefined, error from onNull otherwise.

Type Parameters

E

E

Parameters

onNull

() => E

Returns

<A>(value) => Result<E, NonNullable<A>>

See

• Result.from.Maybe to convert an optional Maybe into a Result.
• Result.from.Predicate to validate and lift values into a Result based on a predicate.

Example

pipe(null, Result.from.nullable(() => "is null")); // Err("is null")
pipe(42, Result.from.nullable(() => "is null"));   // Ok(42)

from.Predicate

Predicate: {<A, B, E>(refinement, onFalse): (value) => Result<E, B>; <A, E>(predicate, onFalse): (value) => Result<E, A>; }

Creates a Result from a predicate or type guard applied to a value. Returns Ok if the predicate passes, Err from onFalse otherwise.

Call Signature

<A, B, E>(refinement, onFalse): (value) => Result<E, B>

Type Parameters

A

A

B

B

E

E

Parameters

refinement

(value) => value is B

onFalse

(value) => E

Returns

(value) => Result<E, B>

Call Signature

<A, E>(predicate, onFalse): (value) => Result<E, A>

Type Parameters

A

A

E

E

Parameters

predicate

(value) => boolean

onFalse

(value) => E

Returns

(value) => Result<E, A>

See

Result.ensure to validate and filter an existing Result.

Example

pipe(5, Result.from.Predicate(n => n > 0, n => `${n} is not positive`));  // Ok(5)
pipe(-1, Result.from.Predicate(n => n > 0, n => `${n} is not positive`)); // Err("-1 is not positive")
pipe("", Result.from.Predicate(s => s.length > 0, () => "empty string")); // Err("empty string")

from.Validation

Validation: <E1, E2>(combineErrors) => <A>(validation) => Result<E2, A>

Converts a Validation to a Result, combining accumulated errors using combineErrors. Passed(a) becomes Ok(a); Failed(errors) becomes Err(combineErrors(errors)).

Type Parameters

E1

E1

E2

E2

Parameters

combineErrors

(errors) => E2

Returns

<A>(validation) => Result<E2, A>

See

Result.to.Validation to convert a Result into a Validation.

Example

Result.from.Validation((errors) => errors.join(", "))(Validation.make.failed("error1")); // Err("error1")

getOrElse

getOrElse: <B>(fallback) => <A, E>(result) => B | A

Returns the success value or a default value if the Result is an error. The default is a thunk () => B — evaluated only when the Result is Err. The default can be a different type, widening the result to A | B.

Type Parameters

B

B

Parameters

fallback

() => B

Returns

<A, E>(result) => B | A

See

Result.match to handle both the Ok and Err cases.

Example

pipe(Result.make.ok(5), Result.getOrElse(() => 0)); // 5
pipe(Result.make.err("error"), Result.getOrElse(() => 0)); // 0
pipe(Result.make.err("error"), Result.getOrElse(() => null)); // null — typed as number | null

is

is: object

is.err

err: <E, A>(result) => result is Err<E> = isErr

Type guard that checks if a Result is Err.

Type Parameters

E

E

A

A

Parameters

result

Result<E, A>

Returns

result is Err<E>

See

Result.is.ok to check if a Result is an Ok success.

Example

const res = Result.make.err("failed");
if (Result.is.err(res)) {
  console.log(res.error); // "failed"
}

is.ok

ok: <E, A>(result) => result is Ok<A> = isOk

Type guard that checks if a Result is Ok.

Type Parameters

E

E

A

A

Parameters

result

Result<E, A>

Returns

result is Ok<A>

See

Result.is.err to check if a Result is an Err failure.

Example

const res = Result.make.ok(42);
if (Result.is.ok(res)) {
  console.log(res.value); // 42
}

make

make: object

make.err

err: <E>(error) => Err<E> = makeErr

Creates a failed Result with the given error.

Type Parameters

E

E

Parameters

error

E

Returns

Err<E>

Example

Result.make.err("Error message"); // Err("Error message")

make.ok

ok: <A>(value) => Ok<A> = makeOk

Creates a successful Result with the given value.

Type Parameters

A

A

Parameters

value

A

Returns

Ok<A>

Example

Result.make.ok(42); // Ok(42)

map

map: <A, B>(transform) => <E>(result) => Result<E, B>

Transforms the success value inside a Result.

Type Parameters

A

A

B

B

Parameters

transform

(value) => B

Returns

<E>(result) => Result<E, B>

See

• Result.chain to sequence operations that themselves return a Result.
• Result.mapError to transform the error value instead of the success value.

Example

pipe(Result.make.ok(5), Result.map(n => n * 2)); // Ok(10)
pipe(Result.make.err("error"), Result.map(n => n * 2)); // Err("error")

mapError

mapError: <E, F>(transform) => <A>(result) => Result<F, A>

Transforms the error value inside a Result.

Type Parameters

E

E

F

F

Parameters

transform

(error) => F

Returns

<A>(result) => Result<F, A>

See

Result.map to transform the success value instead of the error value.

Example

pipe(Result.make.err("oops"), Result.mapError(e => e.toUpperCase())); // Err("OOPS")

match

match: <E, A, B>(cases) => (result) => B

Pattern matches on a Result, returning the result of the matching case.

Type Parameters

E

E

A

A

B

B

Parameters

cases

err

(error) => B

ok

(value) => B

Returns

(result) => B

See

Result.getOrElse to extract the success value with a default fallback.

Example

pipe(
  result,
  Result.match({
    ok: value => `Got ${value}`,
    err: error => `Failed: ${error}`
  })
);

recover

recover: <E1, B, E2>(fallback) => <A>(result) => Result<E2, B | A>

Recovers from an error by providing a fallback Result. The fallback can produce a different success type or resolve with a different error type.

Type Parameters

E1

E1

B

B

E2

E2 = never

Parameters

fallback

(error) => Result<E2, B>

Returns

<A>(result) => Result<E2, B | A>

See

Result.recoverUnless to conditionally recover based on the error value.

Example

pipe(
  Result.make.err("not found"),
  Result.recover((e) => Result.make.ok(`default for ${e}`))
); // Ok("default for not found")

recoverUnless

recoverUnless: <E1, B, E2>(isBlocked, fallback) => <A>(result) => Result<E1 | E2, B | A>

Recovers from an error unless the predicate isBlocked returns true for that error. The fallback can produce a different success type, widening the result to Result<E1 | E2, A | B>.

Type Parameters

E1

E1

B

B

E2

E2 = never

Parameters

isBlocked

(error) => boolean

fallback

(error) => Result<E2, B>

Returns

<A>(result) => Result<E1 | E2, B | A>

See

Result.recover for unconditional error recovery.

Example

pipe(
  Result.make.err(new Error("not found")),
  Result.recoverUnless(e => e.message === "fatal", () => Result.make.ok(0))
); // Ok(0)

sequence

sequence: object

sequence.Maybe

Maybe: <E, A>(result) => Maybe<Result<E, A>>

Swaps the outer Result and inner Maybe context. Ok(Some(a)) becomes Some(Ok(a)), Ok(None) becomes None, and Err(e) becomes Some(Err(e)).

Type Parameters

E

E

A

A

Parameters

result

Result<E, Maybe<A>>

Returns

Maybe<Result<E, A>>

Example

Result.sequence.Maybe(Result.make.ok(Maybe.make.some(42))); // Some(Ok(42))
Result.sequence.Maybe(Result.make.ok(Maybe.make.none()));   // None
Result.sequence.Maybe(Result.make.err("error"));           // Some(Err("error"))

struct

struct: <T>(fields) => Result<T[keyof T] extends Result<E, unknown> ? E : never, { [K in string | number | symbol]: T[K] extends Result<unknown, A> ? A : never }>

Combines a record of Results into a single Result of a record. Evaluates fields in key order and short-circuits on the first failure.

Type Parameters

T

T extends Record<string, Result<unknown, unknown>>

Parameters

fields

T

Returns

Result<T[keyof T] extends Result<E, unknown> ? E : never, { [K in string | number | symbol]: T[K] extends Result<unknown, A> ? A : never }>

See

Result.assign to combine values sequentially with inter-field dependencies.

Example

Result.struct({
  name: Result.make.ok("Alice"),
  age: Result.make.ok(30)
}); // Ok({ name: "Alice", age: 30 })

tap

tap: <A>(sideEffect) => <E>(result) => Result<E, A>

Executes a side effect on the success value without changing the Result. Useful for logging or debugging.

Type Parameters

A

A

Parameters

sideEffect

(value) => void

Returns

<E>(result) => Result<E, A>

See

Result.tapError to perform a side effect on the error value.

Example

pipe(
  Result.make.ok(5),
  Result.tap(n => console.log("Value:", n)),
  Result.map(n => n * 2)
);

tapError

tapError: <E>(sideEffect) => <A>(result) => Result<E, A>

Executes a side effect on the error value without changing the Result. Useful for logging or reporting errors.

Type Parameters

E

E

Parameters

sideEffect

(error) => void

Returns

<A>(result) => Result<E, A>

See

Result.tap to perform a side effect on the success value.

Example

pipe(
  Result.make.err("not found"),
  Result.tapError(e => console.error("validation failed:", e)),
  Result.chain(save),
)

to

to: object

to.Maybe

Maybe: <E, A>(result) => Maybe<A>

Converts a Result to a Maybe. Ok becomes Some, Err becomes None (the error is discarded).

Type Parameters

E

E

A

A

Parameters

result

Result<E, A>

Returns

Maybe<A>

See

Result.from.Maybe to convert a Maybe into a Result.

Example

Result.to.Maybe(Result.make.ok(42)); // Some(42)
Result.to.Maybe(Result.make.err("oops")); // None

to.Validation

Validation: <E, A>(result) => Validation<E, A>

Converts a Result to a Validation. Ok(a) becomes Passed(a); Err(e) becomes Failed([e]).

Type Parameters

E

E

A

A

Parameters

result

Result<E, A>

Returns

Validation<E, A>

See

Result.from.Validation to convert a Validation into a Result.

Example

Result.to.Validation(Result.make.ok(42));     // Passed(42)
Result.to.Validation(Result.make.err("bad")); // Failed(["bad"])

tryCatch

tryCatch: <E, A>(operation, options) => Result<E, A>

Creates a Result from a synchronous thunk that may throw. Catches any errors and transforms them using the onError function.

Type Parameters

E

E

A

A

Parameters

operation

() => A

options

onError

(error) => E

Returns

Result<E, A>

Example

const result = Result.tryCatch(
  () => JSON.parse(rawString),
  { onError: (error) => `Parse error: ${error}` }
);