Interface Option<T>

The Option type represents a value that may or may not exist. It's used to handle potentially null or undefined values in a type-safe way.

interface Option<out T extends Type> {
 _tag: "Some" | "None";
 "[toStringTag]": string;
 isEmpty: boolean;
 size: number;
 value: T | undefined;
 ap(ff: Option<(value: T) => U>): Option;
 contains(value: T): boolean;
 count(p: (x: T) => boolean): number;
 doUnwrap(): DoResult<T>;
 exists(p: (a: T) => boolean): boolean;
 filter(predicate: (value: T) => boolean): Option<T>;
 find(p: (a: T) => boolean): Option<T>;
 flatMap(f: (value: T) => Option): Option;
 flatMapAsync(
 f: (value: T) => Promise<Option>,
 ): Promise<Option>;
 fold(onNone: () => U, onSome: (value: T) => U): U;
 foldAsync(
 onNone: () => U | Promise,
 onSome: (value: T) => U | Promise,
 ): Promise;
 foldLeft(z: B): (op: (b: B, a: T) => B) => B;
 foldRight(z: B): (op: (a: T, b: B) => B) => B;
 forEach(f: (a: T) => void): void;
 isNone(): this is Option<T> & { isEmpty: true; value: undefined };
 isSome(): this is Option<T> & { isEmpty: false; value: T };
 map(f: (value: T) => U): Option;
 match<R>(patterns: { None: () => R; Some: (value: T) => R }): R;
 or<T2 extends unknown>(alternative: Option<T2>): Option<T | T2>;
 orElse<T2 extends unknown>(defaultValue: T2): T | T2;
 orNull(): T | null;
 orThrow(error?: Error): T;
 orUndefined(): T | undefined;
 pipe(f: (value: T) => U): U;
 reduce(
 op: (b: Widen<T, B>, a: Widen<T, B>) => Widen<T, B>,
 ): Widen<T, B>;
 reduceRight(
 op: (b: Widen<T, B>, a: Widen<T, B>) => Widen<T, B>,
 ): Widen<T, B>;
 serialize(): SerializationMethods<T>;
 toEither<E>(left: E): Either<E, T>;
 toList(): List<T>;
 toOption(): Option<T>;
 toPromise(): Promise<T>;
 toString(): string;
 toTry(): Try<T>;
 toValue(): { _tag: "Some" | "None"; value: T };
}

Type Parameters

out T extends Type
The type of the value contained in the Option

Hierarchy (View Summary)

Functype<T, "Some" | "None">
Promisable<T>
Doable<T>
Reshapeable<T>
- Option

Properties

`Readonly`_tag

_tag: "Some" | "None"

`Readonly`[toStringTag]

"[toStringTag]": string

isEmpty

isEmpty: boolean

Whether this Option contains no value

size

size: number

The number of elements in this Option (0 or 1)

`Readonly`value

value: T | undefined

The contained value (undefined for None)

Methods

ap

ap(ff: Option<(value: T) => U>): Option
Applies a wrapped function to a wrapped value (Applicative pattern)
Type Parameters
- U extends unknown
Parameters
- ff: Option<(value: T) => U>
 An Option containing a function from T to U
Returns Option
A new Option containing the result of applying the function

Overrides Functype.ap

contains

contains(value: T): boolean
Checks if this Option contains the specified value
Parameters
- value: T
  The value to check for
Returns boolean
true if this Option contains the value, false otherwise

Overrides Functype.contains

count

count(p: (x: T) => boolean): number
Counts elements that satisfy the predicate. For single-value containers: returns 0 or 1 For collections: returns the count of matching elements
Parameters
- p: (x: T) => boolean
Returns number
Inherited from Functype.count

doUnwrap

doUnwrap(): DoResult<T>
Returns DoResult<T>
Inherited from Doable.doUnwrap

exists

exists(p: (a: T) => boolean): boolean
Tests whether any element satisfies the predicate. For single-value containers: tests the single value For collections: returns true if any element matches
Parameters
- p: (a: T) => boolean
Returns boolean
Inherited from Functype.exists

filter

filter(predicate: (value: T) => boolean): Option<T>
Returns this Option if it contains a value that satisfies the predicate, otherwise returns None
Parameters
- predicate: (value: T) => boolean
 The predicate function to test the value
Returns Option<T>
This Option or None

find

find(p: (a: T) => boolean): Option<T>
Finds the first element that satisfies the predicate. For single-value containers: returns Some(value) if predicate matches, None otherwise For collections: returns the first matching element wrapped in Option
Parameters
- p: (a: T) => boolean
Returns Option<T>
Inherited from Functype.find

flatMap

flatMap(f: (value: T) => Option): Option
Maps the value using a function that returns an Option
Type Parameters
- U extends unknown
Parameters
- f: (value: T) => Option
 The mapping function returning an Option
Returns Option
The result of applying f to the contained value, or None if this Option is None

Overrides Functype.flatMap

flatMapAsync

flatMapAsync(
f: (value: T) => Promise<Option>,
): Promise<Option>
Maps the value using an async function that returns an Option
Type Parameters
- U extends unknown
Parameters
- f: (value: T) => Promise<Option>
 The async mapping function returning an Option
Returns Promise<Option>
Promise of the result of applying f to the contained value, or None if this Option is None

Overrides Functype.flatMapAsync

fold

fold(onNone: () => U, onSome: (value: T) => U): U
Pattern matches over the Option, applying onNone if None and onSome if Some
Type Parameters
- U
Parameters
- onNone: () => U
 Function to apply if the Option is None
- onSome: (value: T) => U
 Function to apply if the Option has a value
Returns U
The result of applying the appropriate function

foldAsync

foldAsync(
onNone: () => U | Promise,
onSome: (value: T) => U | Promise,
): Promise
Async variant of fold. Accepts sync or async handlers on either branch and always returns a Promise.
Type Parameters
- U
Parameters
- onNone: () => U | Promise
- onSome: (value: T) => U | Promise
Returns Promise

foldLeft

foldLeft(z: B): (op: (b: B, a: T) => B) => B
Left-associative fold using the provided zero value and operation
Type Parameters
- B
Parameters
- z: B
 Zero/identity value
Returns (op: (b: B, a: T) => B) => B
A function that takes an operation to apply

Overrides Functype.foldLeft

foldRight

foldRight(z: B): (op: (a: T, b: B) => B) => B
Right-associative fold using the provided zero value and operation
Type Parameters
- B
Parameters
- z: B
 Zero/identity value
Returns (op: (a: T, b: B) => B) => B
A function that takes an operation to apply

Overrides Functype.foldRight

forEach

forEach(f: (a: T) => void): void
Applies an effect function to each element. For single-value containers: applies to the value if present For collections: applies to each element
Parameters
- f: (a: T) => void
Returns void
Inherited from Functype.forEach

isNone

isNone(): this is Option<T> & { isEmpty: true; value: undefined }
Returns true if this Option is a None (contains no value)

Returns this is Option<T> & { isEmpty: true; value: undefined }
true if this Option is empty, false otherwise

isSome

isSome(): this is Option<T> & { isEmpty: false; value: T }
Returns true if this Option is a Some (contains a value)

Returns this is Option<T> & { isEmpty: false; value: T }
true if this Option contains a value, false otherwise

map

map(f: (value: T) => U): Option
Maps the value inside the Option using the provided function
Type Parameters
- U extends unknown
Parameters
- f: (value: T) => U
 The mapping function
Returns Option
A new Option containing the mapped value, or None if this Option is None

Overrides Functype.map

match

match<R>(patterns: { None: () => R; Some: (value: T) => R }): R
Pattern matches over the Option, applying a handler function based on the variant
Type Parameters
- R
Parameters
- patterns: { None: () => R; Some: (value: T) => R }
 Object with handler functions for Some and None variants
Returns R
The result of applying the matching handler function

Overrides Functype.match

or

or<T2 extends unknown>(alternative: Option<T2>): Option<T | T2>
Returns this Option if it contains a value, otherwise returns the alternative container. The alternative may hold a different type; the result widens to Option<T | T2>.
Type Parameters
- T2 extends unknown
Parameters
- alternative: Option<T2>
 The alternative Option to return if this is None
Returns Option<T | T2>
This Option or the alternative, typed as Option<T | T2>

Overrides Functype.or

orElse

orElse<T2 extends unknown>(defaultValue: T2): T | T2
Returns the contained value or a default value if None. The default may be of a different type; the result widens to T | T2 so Option stays covariant in T.
Type Parameters
- T2 extends unknown
Parameters
- defaultValue: T2
 The value to return if this Option is None
Returns T | T2
The contained value or defaultValue, typed as T | T2

Overrides Functype.orElse

orNull

orNull(): T | null
Returns the contained value or null if None

Returns T | null
The contained value or null

Overrides Functype.orNull

orThrow

orThrow(error?: Error): T
Returns the contained value or throws an error if None
Parameters
- Optionalerror: Error
  Optional custom error to throw. If not provided, throws a default error
Returns T
The contained value

Throws
The specified error or a default error if the Option is None

Overrides Functype.orThrow

orUndefined

orUndefined(): T | undefined
Returns the contained value or undefined if None

Returns T | undefined
The contained value or undefined

Overrides Functype.orUndefined

pipe

pipe(f: (value: T) => U): U
Pipes the value through the provided function
Type Parameters
- U extends unknown
 The return type of the function
Parameters
- f: (value: T) => U
 The function to apply to the value
Returns U
The result of applying the function to the value

Inherited from Functype.pipe

reduce

reduce(op: (b: Widen<T, B>, a: Widen<T, B>) => Widen<T, B>): Widen<T, B>
Type Parameters
- B = T
Parameters
- op: (b: Widen<T, B>, a: Widen<T, B>) => Widen<T, B>
Returns Widen<T, B>
Inherited from Functype.reduce

reduceRight

reduceRight(
op: (b: Widen<T, B>, a: Widen<T, B>) => Widen<T, B>,
): Widen<T, B>
Type Parameters
- B = T
Parameters
- op: (b: Widen<T, B>, a: Widen<T, B>) => Widen<T, B>
Returns Widen<T, B>
Inherited from Functype.reduceRight

serialize

serialize(): SerializationMethods<T>
Returns SerializationMethods<T>
Inherited from Functype.serialize

toEither

toEither<E>(left: E): Either<E, T>
Converts this Option to an Either
Type Parameters
- E
Parameters
- left: E
 The value to use for Left if this Option is None
Returns Either<E, T>
Either.Right with the contained value if Some, or Either.Left with left if None

Overrides Reshapeable.toEither

toList

toList(): List<T>
Converts this Option to a List.

Returns List<T>
A List containing the value if Some, or empty List if None

Overrides Reshapeable.toList

toOption

toOption(): Option<T>
Converts this monad to an Option.

Conversion rules:
- Option: returns self
- Either: Right → Some, Left → None
- List: non-empty → Some(head), empty → None
- Try: Success → Some, Failure → None
Returns Option<T>
An Option containing the value if present, None otherwise

Inherited from Reshapeable.toOption

toPromise

toPromise(): Promise<T>
Converts this container to a Promise

The behavior depends on the implementing container:
- Success/Right/Some containers resolve with their value
- Failure/Left/None containers reject with their error/default error
Returns Promise<T>
A Promise that resolves or rejects based on the container's state

Inherited from Promisable.toPromise

toString

toString(): string
Returns a string representation of this Option

Returns string
A string representation

toTry

toTry(): Try<T>
Converts this monad to a Try.

Conversion rules:
- Option: Some → Success, None → Failure(Error("None"))
- Either: Right → Success, Left → Failure(Error(leftValue))
- List: non-empty → Success(head), empty → Failure(Error("Empty list"))
- Try: returns self
Returns Try<T>
A Try containing Success with the value or Failure with an appropriate error

Inherited from Reshapeable.toTry

toValue

toValue(): { _tag: "Some" | "None"; value: T }
Returns a simple object representation of this Option

Returns { _tag: "Some" | "None"; value: T }
An object with _tag and value properties

Overrides Functype.toValue

Interface Option<T>

Type Parameters

Hierarchy (View Summary)

Index

Properties

Methods

Properties

Readonly_tag

Readonly[toStringTag]

isEmpty

size

Readonlyvalue

Methods

ap

Type Parameters

Parameters

Returns Option<U>

contains

Parameters

Returns boolean

count

Parameters

Returns number

doUnwrap

Returns DoResult<T>

exists

Parameters

Returns boolean

filter

Parameters

Returns Option<T>

find

Parameters

Returns Option<T>

flatMap

Type Parameters

Parameters

Returns Option<U>

flatMapAsync

Type Parameters

Parameters

Returns Promise<Option<U>>

fold

Type Parameters

Parameters

Returns U

foldAsync

Type Parameters

Parameters

Returns Promise<U>

foldLeft

Type Parameters

Parameters

Returns (op: (b: B, a: T) => B) => B

foldRight

Type Parameters

Parameters

Returns (op: (a: T, b: B) => B) => B

forEach

Parameters

Returns void

isNone

Returns this is Option<T> & { isEmpty: true; value: undefined }

isSome

Returns this is Option<T> & { isEmpty: false; value: T }

map

Type Parameters

Parameters

Returns Option<U>

match

Type Parameters

Parameters

Returns R

or

Type Parameters

Parameters

Returns Option<T | T2>

orElse

Type Parameters

Parameters

`Readonly`_tag

`Readonly`[toStringTag]

`Readonly`value