Maybe

Maybe: object

Defined in: Core/Maybe.ts:25

Type Declaration

ap

ap: <A>(arg) => <B>(data) => Maybe<B>

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

Type Parameters

A

A

Parameters

arg

Maybe<A>

Returns

<B>(data) => Maybe<B>

Example

const add = (a: number) => (b: number) => a + b;
pipe(
  Maybe.make.some(add),
  Maybe.ap(Maybe.make.some(5)),
  Maybe.ap(Maybe.make.some(3))
); // Some(8)

bind

bind: <K, A, B>(key, f) => (data) => Maybe<A & { [P in string]: B }>

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

Type Parameters

K

K extends string

A

A

B

B

Parameters

key

K

f

(a) => Maybe<B>

Returns

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

Example

pipe(
  Maybe.make.some({ a: 1 }),
  Maybe.bind("b", ({ a }) => Maybe.make.some(a + 1))
); // Some({ a: 1, b: 2 })

bindTo

bindTo: <K>(key) => <A>(data) => Maybe<{ [P in string]: A }>

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

Type Parameters

K

K extends string

Parameters

key

K

Returns

<A>(data) => Maybe<{ [P in string]: A }>

Example

pipe(Maybe.make.some(42), Maybe.bindTo("value")); // Some({ value: 42 })

chain

chain: <A, B>(f) => (data) => Maybe<B>

Chains Maybe computations. If the first is Some, passes the value to f. If the first is None, propagates None.

Type Parameters

A

A

B

B

Parameters

f

(a) => Maybe<B>

Returns

(data) => Maybe<B>

Example

const parseNumber = (s: string): Maybe<number> => {
  const n = parseInt(s, 10);
  return isNaN(n) ? Maybe.make.none() : Maybe.make.some(n);
};

pipe(Maybe.make.some("42"), Maybe.chain(parseNumber)); // Some(42)
pipe(Maybe.make.some("abc"), Maybe.chain(parseNumber)); // None

filter

filter: <A>(predicate) => (data) => Maybe<A>

Filters a Maybe based on a predicate. Returns None if the predicate returns false or if the Maybe is already None.

Type Parameters

A

A

Parameters

predicate

(a) => boolean

Returns

(data) => Maybe<A>

Example

pipe(Maybe.make.some(5), Maybe.filter(n => n > 3)); // Some(5)
pipe(Maybe.make.some(2), Maybe.filter(n => n > 3)); // None

fold

fold: <A, B>(onNone, onSome) => (data) => B

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

Type Parameters

A

A

B

B

Parameters

onNone

() => B

onSome

(a) => B

Returns

(data) => B

Example

pipe(
  Maybe.make.some(5),
  Maybe.fold(
    () => "No value",
    n => `Value: ${n}`
  )
); // "Value: 5"

from

from: object

from.nullable

nullable: <A>(value) => Maybe<A>

Creates a Maybe from a nullable value. Returns None if the value is null or undefined, Some otherwise.

Type Parameters

A

A

Parameters

value

A | null | undefined

Returns

Maybe<A>

Example

Maybe.from.nullable(null); // None
Maybe.from.nullable(42); // Some(42)

from.Predicate

Predicate: <A>(pred) => (a) => Maybe<A>

Creates a Maybe from a predicate applied to a value. Returns Some if the predicate passes, None otherwise.

Type Parameters

A

A

Parameters

pred

(a) => boolean

Returns

(a) => Maybe<A>

Example

Maybe.from.Predicate((n: number) => n >= 18)(21); // Some(21)
Maybe.from.Predicate((n: number) => n >= 18)(15); // None

pipe("hello", Maybe.from.Predicate((s: string) => s.length > 0)); // Some("hello")
pipe("", Maybe.from.Predicate((s: string) => s.length > 0));      // None

from.Result

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

Creates a Maybe from a Result. 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

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

getOrElse

getOrElse: <B>(defaultValue) => <A>(data) => B | A

Returns the value inside a Maybe, or a default value if None. The default is a thunk () => B — evaluated only when the Maybe is None. The default can be a different type, widening the result to A | B.

Type Parameters

B

B

Parameters

defaultValue

() => B

Returns

<A>(data) => B | A

Example

pipe(Maybe.make.some(5), Maybe.getOrElse(() => 0)); // 5
pipe(Maybe.make.none(), Maybe.getOrElse(() => 0)); // 0
pipe(Maybe.make.none<string>(), Maybe.getOrElse(() => null)); // null — typed as string | null

is

is: object

is.none

none: <A>(data) => data is None = isNone

Type guard that checks if a Maybe is None.

Type Parameters

A

A

Parameters

data

Maybe<A>

Returns

data is None

Example

const value = Maybe.make.none();
if (Maybe.is.none(value)) {
  console.log("No value present");
}

is.some

some: <A>(data) => data is Some<A> = isSome

Type guard that checks if a Maybe is Some.

Type Parameters

A

A

Parameters

data

Maybe<A>

Returns

data is Some<A>

Example

const value = Maybe.make.some(42);
if (Maybe.is.some(value)) {
  console.log(value.value); // 42
}

make

make: object

make.none

none: () => None = makeNone

Creates a None (empty Maybe).

Returns

None

Example

Maybe.make.none(); // None

make.some

some: <A>(value) => Some<A> = makeSome

Creates a Some containing the given value.

Type Parameters

A

A

Parameters

value

A

Returns

Some<A>

Example

Maybe.make.some(42); // Some(42)

map

map: <A, B>(f) => (data) => Maybe<B>

Transforms the value inside a Maybe if it exists.

Type Parameters

A

A

B

B

Parameters

f

(a) => B

Returns

(data) => Maybe<B>

Example

pipe(Maybe.make.some(5), Maybe.map(n => n * 2)); // Some(10)
pipe(Maybe.make.none(), Maybe.map(n => n * 2)); // None

match

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

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

Type Parameters

A

A

B

B

Parameters

cases

none

() => B

some

(a) => B

Returns

(data) => B

Example

pipe(
  optionUser,
  Maybe.match({
    some: user => `Hello, ${user.name}`,
    none: () => "Hello, stranger"
  })
);

recover

recover: <B>(fallback) => <A>(data) => Maybe<B | A>

Recovers from a None by providing a fallback Maybe. The fallback can produce a different type, widening the result to Maybe<A | B>.

Type Parameters

B

B

Parameters

fallback

() => Maybe<B>

Returns

<A>(data) => Maybe<B | A>

Example

pipe(Maybe.make.none(), Maybe.recover(() => Maybe.make.some(42))); // Some(42)
pipe(Maybe.make.some(10), Maybe.recover(() => Maybe.make.some(42))); // Some(10)

struct

struct: <R>(fields) => Maybe<R>

Combines a record of Maybes into a single Maybe of a record. Evaluates fields in key order and short-circuits on the first None.

Type Parameters

R

R extends Record<string, any>

Parameters

fields

{ [K in string | number | symbol]: Maybe<R[K]> }

Returns

Maybe<R>

Example

Maybe.struct({
  name: Maybe.make.some("Alice"),
  age: Maybe.make.some(30)
}); // Some({ name: "Alice", age: 30 })

tap

tap: <A>(f) => (data) => Maybe<A>

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

Type Parameters

A

A

Parameters

f

(a) => void

Returns

(data) => Maybe<A>

Example

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

to

to: object

to.nullable

nullable: <A>(data) => A | null

Extracts the value from a Maybe, returning null if None.

Type Parameters

A

A

Parameters

data

Maybe<A>

Returns

A | null

Example

Maybe.to.nullable(Maybe.make.some(42)); // 42
Maybe.to.nullable(Maybe.make.none());   // null

to.Result

Result: <E>(onNone) => <A>(data) => Result<E, A>

Converts a Maybe to a Result. Some becomes Ok, None becomes Err with the provided error.

Type Parameters

E

E

Parameters

onNone

() => E

Returns

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

Example

pipe(
  Maybe.make.some(42),
  Maybe.to.Result(() => "Value was missing")
); // Ok(42)

pipe(
  Maybe.make.none(),
  Maybe.to.Result(() => "Value was missing")
); // Err("Value was missing")

to.undefined

undefined: <A>(data) => A | undefined

Extracts the value from a Maybe, returning undefined if None.

Type Parameters

A

A

Parameters

data

Maybe<A>

Returns

A | undefined

Example

Maybe.to.undefined(Maybe.make.some(42)); // 42
Maybe.to.undefined(Maybe.make.none());   // undefined

transposeResult

transposeResult: <E, A>(data) => Result<E, Maybe<A>>

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

Type Parameters

E

E

A

A

Parameters

data

Maybe<Result<E, A>>

Returns

Result<E, Maybe<A>>

Example

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