Result

Result: object

Defined in: Core/Result.ts:26

Type Declaration

ap

ap: <E, A>(arg) => <B>(data) => Result<E, B>

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

Type Parameters

E

E

A

A

Parameters

arg

Result<E, A>

Returns

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

Example

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

bimap

bimap: <E1, E2, A, B>(onErr, onOk) => (data) => 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

(e) => E2

onOk

(a) => B

Returns

(data) => Result<E2, B>

Example

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

bind

bind: <K, E, A, B>(key, f) => (data) => Result<E, 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

E

E

A

A

B

B

Parameters

key

K

f

(a) => Result<E, B>

Returns

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

Example

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

bindTo

bindTo: <K>(key) => <E, A>(data) => 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>(data) => Result<E, { [P in string]: A }>

Example

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

chain

chain: <E2, A, B>(f) => <E1>(data) => Result<E2 | E1, B>

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

Type Parameters

E2

E2

A

A

B

B

Parameters

f

(a) => Result<E2, B>

Returns

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

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, E2>(predicate, onFail) => <E1>(data) => Result<E2 | E1, A>

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

Type Parameters

A

A

E2

E2

Parameters

predicate

(a) => boolean

onFail

(a) => E2

Returns

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

Example

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

fold

fold: <E, A, B>(onErr, onOk) => (data) => B

Extracts the value from a Result by providing handlers for both cases.

Type Parameters

E

E

A

A

B

B

Parameters

onErr

(e) => B

onOk

(a) => B

Returns

(data) => B

Example

pipe(
  Result.make.ok(5),
  Result.fold(
    e => `Error: ${e}`,
    n => `Value: ${n}`
  )
); // "Value: 5"

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>

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, 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, A>

Example

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

from.Predicate

Predicate: <E, A>(pred, onFalse) => (a) => Result<E, A>

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

Type Parameters

E

E

A

A

Parameters

pred

(a) => boolean

onFalse

(a) => E

Returns

(a) => Result<E, A>

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, A>(combineErrors) => (val) => 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

A

A

Parameters

combineErrors

(errors) => E2

Returns

(val) => Result<E2, A>

Example

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

getOrElse

getOrElse: <B>(defaultValue) => <E, A>(data) => 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

defaultValue

() => B

Returns

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

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>(data) => data is Err<E> = isErr

Type guard that checks if a Result is Err.

Type Parameters

E

E

A

A

Parameters

data

Result<E, A>

Returns

data is Err<E>

Example

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

is.ok

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

Type guard that checks if a Result is Ok.

Type Parameters

E

E

A

A

Parameters

data

Result<E, A>

Returns

data is Ok<A>

Example

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

make

make: object

make.err

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

Creates a failed Result with the given error.

Type Parameters

E

E

Parameters

e

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: <E, A, B>(f) => (data) => Result<E, B>

Transforms the success value inside a Result.

Type Parameters

E

E

A

A

B

B

Parameters

f

(a) => B

Returns

(data) => Result<E, B>

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, A>(f) => (data) => Result<F, A>

Transforms the error value inside a Result.

Type Parameters

E

E

F

F

A

A

Parameters

f

(e) => F

Returns

(data) => Result<F, A>

Example

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

match

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

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

Type Parameters

E

E

A

A

B

B

Parameters

cases

err

(e) => B

ok

(a) => B

Returns

(data) => B

Example

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

recover

recover: <E, B>(fallback) => <A>(data) => Result<E, B | A>

Recovers from an error by providing a fallback Result. The fallback can produce a different success type, widening the result to Result<E, A | B>.

Type Parameters

E

E

B

B

Parameters

fallback

(e) => Result<E, B>

Returns

<A>(data) => Result<E, B | A>

recoverUnless

recoverUnless: <E, B>(isBlocked, fallback) => <A>(data) => Result<E, 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<E, A | B>.

Type Parameters

E

E

B

B

Parameters

isBlocked

(e) => boolean

fallback

() => Result<E, B>

Returns

<A>(data) => Result<E, B | A>

Example

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

struct

struct: <E, R>(fields) => Result<E, R>

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

E

E

R

R extends Record<string, any>

Parameters

fields

{ [K in string | number | symbol]: Result<E, R[K]> }

Returns

Result<E, R>

Example

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

tap

tap: <E, A>(f) => (data) => Result<E, A>

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

Type Parameters

E

E

A

A

Parameters

f

(a) => void

Returns

(data) => Result<E, A>

Example

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

tapError

tapError: <E, A>(f) => (data) => 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

A

A

Parameters

f

(e) => void

Returns

(data) => Result<E, A>

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>(data) => 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

data

Result<E, A>

Returns

Maybe<A>

Example

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

to.Validation

Validation: <E, A>(data) => 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

data

Result<E, A>

Returns

Validation<E, A>

Example

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

transposeMaybe

transposeMaybe: <E, A>(data) => 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

data

Result<E, Maybe<A>>

Returns

Maybe<Result<E, A>>

Example

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

tryCatch

tryCatch: <E, A>(f, 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

f

() => A

options

onError

(e) => E

Returns

Result<E, A>

Example

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