Interface None

Represents the absence of a value, as a specialized Option type. The type parameter is set to never because None does not hold a value.

interface None {
 "[OptionKindSymbol]": "None";
 "[toStringTag]": "Option";
 "[iterator]"(): Iterator<never>;
 and(other: Option): this;
 andThen(fn: (value: never) => Option): this;
 andThenAsync(
 fn: (value: never) => AsyncLikeOption | Option,
 ): Promise<None>;
 eq<T>(other: Option<T>): boolean;
 expect(msg: string): never;
 filter(predicate: (value: never) => boolean): this;
 flatten(): this;
 inspect(fn: (value: never) => void): this;
 isNone(): true;
 isNoneOr(predicate: (value: never) => boolean): true;
 isNoneOrAsync(
 predicate: (value: never) => boolean | PromiseLike<boolean>,
 ): Promise<true>;
 isSome(): false;
 isSomeAnd(predicate: (value: never) => boolean): false;
 isSomeAndAsync(
 predicate: (value: never) => boolean | PromiseLike<boolean>,
 ): Promise<false>;
 map(fn: (value: never) => U): this;
 mapOr(defaultValue: U, fn: (value: never) => U): U;
 mapOrElse(defaultFn: () => U, fn: (value: never) => U): U;
 okOr<E>(error: E): Result<never, E>;
 okOrElse<E>(err: () => E): Result<never, E>;
 or<T>(other: Option<T>): Option<T>;
 orElse<T>(fn: () => Option<T>): Option<T>;
 orElseAsync<T>(fn: () => AsyncLikeOption<T> | Option<T>): AsyncOption<T>;
 reduce<U, R = U>(
 other: Option,
 fn: (value: never, otherValue: U) => R,
 ): Option;
 toString(): string;
 transpose(): Result<None, never>;
 unwrap(): never;
 unwrapOr<T>(defaultValue: T): T;
 unwrapOrElse<T>(fn: () => T): T;
 unwrapOrElseAsync<T>(fn: () => T | PromiseLike<T>): Promise<Awaited<T>>;
 unzip(): [None, None];
 xor<T>(other: Option<T>): Option<T>;
 zip(other: Option): this;
 zipWith<U, R>(
 other: Option,
 fn: (value: never, otherValue: U) => R,
 ): this;
}

Hierarchy (View Summary)

Option<never>
- None

Properties

`Readonly`[OptionKindSymbol]

"[OptionKindSymbol]": "None"

When using None alone, the following overrides can make type inference more accurate.

`Readonly`[toStringTag]

"[toStringTag]": "Option"

The well-known symbol Symbol.toStringTag used by Object.prototype.toString(). Returns 'Option' so that Object.prototype.toString.call(option) produces '[object Option]'.

This enables reliable type identification even across different execution contexts (e.g., iframes, different module instances).

Example

const x = Some(5);
console.log(Object.prototype.toString.call(x)); // '[object Option]'

Methods

[iterator]

"[iterator]"(): Iterator<never>
Implements the Iterator protocol, allowing Option to be used with for...of loops and spread syntax.
- For Some(value), yields the contained value once.
- For None, yields nothing (empty iterator).
This is similar to Rust's Option::iter() method.
Returns Iterator<never>
An iterator that yields zero or one value.
Example
```
// Using with for...of
for (const value of Some(5)) {
 console.log(value); // 5
}

for (const value of None) {
 console.log(value); // never executed
}

// Using with spread operator
const arr1 = [...Some(5)]; // [5]
const arr2 = [...None]; // []

// Using with Array.from
Array.from(Some('hello')); // ['hello']
Array.from(None); // []
```
Inherited from Option.[iterator]
- Defined in core/option/option.ts:85

and

and(other: Option): this
Returns None if the Option is None, otherwise returns other. This is sometimes called "and then" because it is similar to a logical AND operation.
Type Parameters
- U
 The type of the value in the other Option.
Parameters
- other: Option
 The Option to return if this is Some.
Returns this
None if this is None, otherwise returns other.
See
- or
- xor
Example
```
const x = Some(2);
const y = Some('hello');
console.log(x.and(y).unwrap()); // 'hello'

const z = None;
console.log(z.and(y).isNone()); // true
```
Overrides Option.and
- Defined in core/prelude.ts:61

andThen

andThen(fn: (value: never) => Option): this
Returns None if the Option is None, otherwise calls fn with the wrapped value and returns the result. This function can be used for control flow based on Option values.
Type Parameters
- U
 The type of the value returned by the function.
Parameters
- fn: (value: never) => Option
 A function that takes the contained value and returns an Option.
Returns this
The result of fn if this is Some, otherwise None.
See
- map
- orElse
Example
```
const x = Some(2);
const result = x.andThen(v => v > 0 ? Some(v * 2) : None);
console.log(result.unwrap()); // 4

const y = None;
console.log(y.andThen(v => Some(v * 2)).isNone()); // true
```
Overrides Option.andThen
- Defined in core/prelude.ts:62

andThenAsync

andThenAsync(
fn: (value: never) => AsyncLikeOption | Option,
): Promise<None>
Asynchronous version of andThen.
Type Parameters
- U
 The type of the value returned by the function.
Parameters
- fn: (value: never) => AsyncLikeOption | Option
 A function that takes the contained value and returns PromiseLike<Option> or Option.
Returns Promise<None>
A promise that resolves to None if this is None, otherwise the result of fn.
See
- andThen
- orElseAsync
Example
```
const x = Some(2);
const result = await x.andThenAsync(async v => Some(v * 2));
console.log(result.unwrap()); // 4
```
Overrides Option.andThenAsync
- Defined in core/prelude.ts:63

eq

eq<T>(other: Option<T>): boolean
Tests whether this and other are both Some containing equal values, or both are None. This method can be used for comparing Option instances in a value-sensitive manner.
Type Parameters
- T
Parameters
- other: Option<T>
 The other Option to compare with.
Returns boolean
true if this and other are both Some with equal values, or both are None, otherwise false.
Example
```
const a = Some(5);
const b = Some(5);
const c = Some(10);
console.log(a.eq(b)); // true
console.log(a.eq(c)); // false
console.log(None.eq(None)); // true
console.log(a.eq(None)); // false
```
Overrides Option.eq
- Defined in core/prelude.ts:71

expect

expect(msg: string): never
Returns the contained Some value, with a provided error message if the value is a None.
Parameters
- msg: string
  The error message to provide if the value is a None.
Returns never
Throws
Throws an error with the provided message if the Option is a None.

See
unwrap
Example
```
const x = Some(5);
console.log(x.expect('value should exist')); // 5

const y = None;
y.expect('value should exist'); // throws TypeError: value should exist
```
Overrides Option.expect
- Defined in core/prelude.ts:41

filter

filter(predicate: (value: never) => boolean): this
Returns None if the Option is None, otherwise calls predicate with the wrapped value and returns:
- Some(t) if predicate returns true (where t is the wrapped value), and
- None if predicate returns false.
Parameters
- predicate: (value: never) => boolean
  A function that takes the contained value and returns a boolean.
Returns this
Example
```
const x = Some(4);
console.log(x.filter(v => v > 2).isSome()); // true
console.log(x.filter(v => v > 5).isNone()); // true
```
Overrides Option.filter
- Defined in core/prelude.ts:51

flatten

flatten(): this
Converts from Option<Option> to Option.

Returns this
None if the Option is None, otherwise returns the contained Option.
Example
```
const x = Some(Some(5));
console.log(x.flatten().unwrap()); // 5

const y = Some(None);
console.log(y.flatten().isNone()); // true
```
Overrides Option.flatten
- Defined in core/prelude.ts:52

inspect

inspect(fn: (value: never) => void): this
Calls the provided function with the contained value if this is Some. This is primarily for side effects and does not transform the Option.
Parameters
- fn: (value: never) => void
  A function to call with the contained value.
Returns this
this, unmodified, for chaining additional methods.
Example
```
const x = Some(5);
// Prints "value: 5" and returns Some(10)
const doubled = x.inspect(v => console.log('value:', v)).map(v => v * 2);

const y = None;
// Does nothing and returns None
y.inspect(v => console.log('value:', v));
```
Overrides Option.inspect
- Defined in core/prelude.ts:69

isNone

isNone(): true
Returns true if the Option is a None value.

Returns true
Example
```
const x = Some(2);
console.log(x.isNone()); // false

const y = None;
console.log(y.isNone()); // true
```
Overrides Option.isNone
- Defined in core/prelude.ts:35

isNoneOr

isNoneOr(predicate: (value: never) => boolean): true
Returns true if the Option is None, or the predicate returns true for the contained value.
Parameters
- predicate: (value: never) => boolean
  A function that takes the contained value and returns a boolean.
Returns true
See
isSomeAnd
Example
```
const x = Some(2);
console.log(x.isNoneOr(v => v > 1)); // true
console.log(x.isNoneOr(v => v > 5)); // false

const y = None;
console.log(y.isNoneOr(v => v > 5)); // true (always true for None)
```
Overrides Option.isNoneOr
- Defined in core/prelude.ts:38

isNoneOrAsync

isNoneOrAsync(
predicate: (value: never) => boolean | PromiseLike<boolean>,
): Promise<true>
Asynchronous version of isNoneOr.
Parameters
- predicate: (value: never) => boolean | PromiseLike<boolean>
 A function that takes the contained value and returns a PromiseLike<boolean> or boolean.
Returns Promise<true>
A promise that resolves to true if the Option is None or the predicate resolves to true.
See
isNoneOr
Example
```
const x = Some(2);
await x.isNoneOrAsync(async v => v > 1); // true

const y = None;
await y.isNoneOrAsync(async v => v > 5); // true
```
Overrides Option.isNoneOrAsync
- Defined in core/prelude.ts:39

isSome

isSome(): false
Returns true if the Option is a Some value.

Returns false
Example
```
const x = Some(2);
console.log(x.isSome()); // true

const y = None;
console.log(y.isSome()); // false
```
Overrides Option.isSome
- Defined in core/prelude.ts:34

isSomeAnd

isSomeAnd(predicate: (value: never) => boolean): false
Returns true if the Option is a Some value and the predicate returns true for the contained value.
Parameters
- predicate: (value: never) => boolean
  A function that takes the contained value and returns a boolean.
Returns false
Example
```
const x = Some(2);
console.log(x.isSomeAnd(v => v > 1)); // true
console.log(x.isSomeAnd(v => v > 5)); // false
```
Overrides Option.isSomeAnd
- Defined in core/prelude.ts:36

isSomeAndAsync

isSomeAndAsync(
predicate: (value: never) => boolean | PromiseLike<boolean>,
): Promise<false>
Asynchronous version of isSomeAnd.
Parameters
- predicate: (value: never) => boolean | PromiseLike<boolean>
 A function that takes the contained value and returns a PromiseLike<boolean> or boolean.
Returns Promise<false>
A promise that resolves to true if the Option is Some and the predicate resolves to true.
See
isSomeAnd
Example
```
const x = Some(2);
await x.isSomeAndAsync(async v => v > 1); // true
```
Overrides Option.isSomeAndAsync
- Defined in core/prelude.ts:37

map

map(fn: (value: never) => U): this
Maps an Option<T> to Option by applying a function to a contained value.
Type Parameters
- U
 The type of the value returned by the map function.
Parameters
- fn: (value: never) => U
 A function that takes the contained value and returns a new value.
Returns this
See
andThen
Example
```
const x = Some(5);
console.log(x.map(v => v * 2).unwrap()); // 10

const y = None;
console.log(y.map(v => v * 2).isNone()); // true
```
Overrides Option.map
- Defined in core/prelude.ts:53

mapOr

mapOr(defaultValue: U, fn: (value: never) => U): U
Maps an Option<T> to U by applying a function to the contained value (if any), or returns the provided default (if not).
Type Parameters
- U
 The type of the value returned by the map function or the default value.
Parameters
- defaultValue: U
 The value to return if the Option is None.
- fn: (value: never) => U
 A function that takes the contained value and returns a new value.
Returns U
See
mapOrElse
Example
```
const x = Some(5);
console.log(x.mapOr(0, v => v * 2)); // 10

const y = None;
console.log(y.mapOr(0, v => v * 2)); // 0
```
Overrides Option.mapOr
- Defined in core/prelude.ts:54

mapOrElse

mapOrElse(defaultFn: () => U, fn: (value: never) => U): U
Maps an Option<T> to U by applying a function to a contained value (if any), or computes a default (if not).
Type Parameters
- U
 The type of the value returned by the map function or the default function.
Parameters
- defaultFn: () => U
 A function that returns the default value.
- fn: (value: never) => U
 A function that takes the contained value and returns a new value.
Returns U
See
mapOr
Example
```
const x = Some(5);
console.log(x.mapOrElse(() => 0, v => v * 2)); // 10

const y = None;
console.log(y.mapOrElse(() => 0, v => v * 2)); // 0
```
Overrides Option.mapOrElse
- Defined in core/prelude.ts:55

okOr

okOr<E>(error: E): Result<never, E>
Transforms the Option<T> into a Result<T, E>, mapping Some(v) to Ok(v) and None to Err(err).
Type Parameters
- E
 The type of the error value in the Err variant of the resulting Result.
Parameters
- error: E
 The error value to use if the Option is a None.
Returns Result<never, E>
See
okOrElse
Example
```
const x = Some(5);
console.log(x.okOr('error').isOk()); // true

const y = None;
console.log(y.okOr('error').unwrapErr()); // 'error'
```
Overrides Option.okOr
- Defined in core/prelude.ts:47

okOrElse

okOrElse<E>(err: () => E): Result<never, E>
Transforms the Option<T> into a Result<T, E>, mapping Some(v) to Ok(v) and None to Err(err()).
Type Parameters
- E
 The type of the error value in the Err variant of the resulting Result.
Parameters
- err: () => E
 A function that returns the error value.
Returns Result<never, E>
See
okOr
Example
```
const x = None;
console.log(x.okOrElse(() => 'error').unwrapErr()); // 'error'
```
Overrides Option.okOrElse
- Defined in core/prelude.ts:48

or

or<T>(other: Option<T>): Option<T>
Returns the Option if it contains a value, otherwise returns other. This can be used for providing a fallback Option.
Type Parameters
- T
Parameters
- other: Option<T>
 The fallback Option to use if this is None.
Returns Option<T>
this if it is Some, otherwise other.
See
- and
- xor
- reduce
Example
```
const x = None;
const y = Some(5);
console.log(x.or(y).unwrap()); // 5

const z = Some(2);
console.log(z.or(y).unwrap()); // 2
```
Overrides Option.or
- Defined in core/prelude.ts:64

orElse

orElse<T>(fn: () => Option<T>): Option<T>
Returns the Option if it contains a value, otherwise calls fn and returns the result. This method can be used for lazy fallbacks, as fn is only evaluated if this is None.
Type Parameters
- T
Parameters
- fn: () => Option<T>
 A function that produces an Option.
Returns Option<T>
this if it is Some, otherwise the result of fn.
See
andThen
Example
```
const x = None;
const result = x.orElse(() => Some(10));
console.log(result.unwrap()); // 10

const y = Some(5);
console.log(y.orElse(() => Some(10)).unwrap()); // 5
```
Overrides Option.orElse
- Defined in core/prelude.ts:65

orElseAsync

orElseAsync<T>(fn: () => AsyncLikeOption<T> | Option<T>): AsyncOption<T>
Asynchronous version of orElse.
Type Parameters
- T
Parameters
- fn: () => AsyncLikeOption<T> | Option<T>
 A function that produces PromiseLike<Option<T>> or Option<T>.
Returns AsyncOption<T>
A promise that resolves to this if it is Some, otherwise the result of fn.
See
- orElse
- andThenAsync
Example
```
const x = None;
const result = await x.orElseAsync(async () => Some(10));
console.log(result.unwrap()); // 10
```
Overrides Option.orElseAsync
- Defined in core/prelude.ts:66

reduce

reduce<U, R = U>(
other: Option,
fn: (value: never, otherValue: U) => R,
): Option
Reduces two Option values into one using the provided function.
- If both this and other are Some, applies fn to both values and returns Some(result).
- If only this is Some, returns Some(this_value).
- If only other is Some, returns Some(other_value).
- If both are None, returns None.
This is similar to Rust's Option::reduce with Into<R> constraints. In TypeScript, when only one Option is Some, that value is returned as-is (relying on TypeScript's structural typing for compatibility with R).
Type Parameters
- U
 The type of the value in the other Option.
- R = U
 The result type (defaults to T | U).
Parameters
- other: Option
 The other Option to reduce with.
- fn: (value: never, otherValue: U) => R
 A function that combines both values when both are Some.
Returns Option
The reduced Option.
See
- zip
- zipWith
- or
Example
```
const a = Some(10);
const b = Some(20);
console.log(a.reduce(b, (x, y) => x + y).unwrap()); // 30

const c = None as Option<number>;
console.log(a.reduce(c, (x, y) => x + y).unwrap()); // 10
console.log(c.reduce(b, (x, y) => x + y).unwrap()); // 20
console.log(c.reduce(c, (x, y) => x + y).isNone()); // true

// With different types that share a common supertype
const str = Some('hello');
const num = Some(42);
const result: Option<string> = str.reduce(num, (s, n) => `${s}-${n}`);
```
Inherited from Option.reduce
- Defined in core/option/option.ts:510

toString

toString(): string
Custom toString implementation that uses the Option's contained value.

Returns string
Example
```
console.log(Some(5).toString()); // 'Some(5)'
console.log(None.toString()); // 'None'
```
Inherited from Option.toString
- Defined in core/option/option.ts:95

transpose

transpose(): Result<None, never>
Transposes an Option of a Result into a Result of an Option.

Returns Result<None, never>
Ok containing Some if the Option is a Some containing Ok, Err containing the error if the Option is a Some containing Err, Ok containing None if the Option is None.
Example
```
const x = Some(Ok(5));
console.log(x.transpose().unwrap().unwrap()); // 5

const y = Some(Err('error'));
console.log(y.transpose().unwrapErr()); // 'error'

const z: Option<Result<number, string>> = None;
console.log(z.transpose().unwrap().isNone()); // true
```
Overrides Option.transpose
- Defined in core/prelude.ts:49

unwrap

unwrap(): never
Returns the contained Some value.

Returns never
Throws
Throws an error if the value is a None.
See
- expect
- unwrapOr
Example
```
const x = Some(5);
console.log(x.unwrap()); // 5

const y = None;
y.unwrap(); // throws TypeError
```
Overrides Option.unwrap
- Defined in core/prelude.ts:42

unwrapOr

unwrapOr<T>(defaultValue: T): T
Returns the contained Some value or a provided default.
Type Parameters
- T
Parameters
- defaultValue: T
 The value to return if the Option is a None.
Returns T
See
unwrapOrElse
Example
```
const x = Some(5);
console.log(x.unwrapOr(10)); // 5

const y = None;
console.log(y.unwrapOr(10)); // 10
```
Overrides Option.unwrapOr
- Defined in core/prelude.ts:43

unwrapOrElse

unwrapOrElse<T>(fn: () => T): T
Returns the contained Some value or computes it from a closure.
Type Parameters
- T
Parameters
- fn: () => T
 A function that returns the default value.
Returns T
See
unwrapOr
Example
```
const x = None;
console.log(x.unwrapOrElse(() => 10)); // 10
```
Overrides Option.unwrapOrElse
- Defined in core/prelude.ts:44

unwrapOrElseAsync

unwrapOrElseAsync<T>(fn: () => T | PromiseLike<T>): Promise<Awaited<T>>
Asynchronous version of unwrapOrElse.
Type Parameters
- T
Parameters
- fn: () => T | PromiseLike<T>
 A function that returns PromiseLike<T> or T as the default value.
Returns Promise<Awaited<T>>
A promise that resolves to the contained value or the result of the function.
See
unwrapOrElse
Example
```
const x = None;
await x.unwrapOrElseAsync(async () => 10); // 10
```
Overrides Option.unwrapOrElseAsync
- Defined in core/prelude.ts:45

unzip

unzip(): [None, None]
Converts from Option<[U, R]> to [Option, Option<R>]. If this is Some([a, b]), returns [Some(a), Some(b)]. If this is None, returns [None, None].

Returns [None, None]
A tuple of Options, one for each element in the original Option of a tuple.
See
zip
Example
```
const x = Some([1, 'hello'] as [number, string]);
const [a, b] = x.unzip();
console.log(a.unwrap()); // 1
console.log(b.unwrap()); // 'hello'
```
Overrides Option.unzip
- Defined in core/prelude.ts:59

xor

xor<T>(other: Option<T>): Option<T>
Returns Some if exactly one of this, other is Some, otherwise returns None. This can be thought of as an exclusive or operation on Option values.
Type Parameters
- T
Parameters
- other: Option<T>
 The other Option to compare with.
Returns Option<T>
Some if exactly one of this and other is Some, otherwise None.
See
- and
- or
Example
```
const x = Some(2);
const y = None;
console.log(x.xor(y).unwrap()); // 2

const a = Some(2);
const b = Some(3);
console.log(a.xor(b).isNone()); // true
```
Overrides Option.xor
- Defined in core/prelude.ts:67

zip

zip(other: Option): this
Combines this with another Option by zipping their contained values. If this is Some(s) and other is Some(o), returns Some([s, o]). If either this or other is None, returns None.
Type Parameters
- U
 The type of the value in the other Option.
Parameters
- other: Option
 The other Option to zip with.
Returns this
An Option containing a tuple of the values if both are Some, otherwise None.
See
- zipWith
- unzip
- reduce
Example
```
const x = Some(1);
const y = Some('hello');
console.log(x.zip(y).unwrap()); // [1, 'hello']

const z = None;
console.log(x.zip(z).isNone()); // true
```
Overrides Option.zip
- Defined in core/prelude.ts:57

zipWith

zipWith<U, R>(other: Option, fn: (value: never, otherValue: U) => R): this
Zips this with another Option using a provided function to combine their contained values. If this is Some(s) and other is Some(o), returns Some(fn(s, o)). If either this or other is None, returns None.
Type Parameters
- U
 The type of the value in the other Option.
- R
 The return type of the combining function.
Parameters
- other: Option
 The other Option to zip with.
- fn: (value: never, otherValue: U) => R
 The function to combine the values from both Options.
Returns this
An Option containing the result of fn if both Options are Some, otherwise None.
See
- zip
- reduce
Example
```
const x = Some(2);
const y = Some(3);
console.log(x.zipWith(y, (a, b) => a * b).unwrap()); // 6
```
Overrides Option.zipWith
- Defined in core/prelude.ts:58

Interface None

Hierarchy (View Summary)

Index

Properties

Methods

Properties

Readonly[OptionKindSymbol]

Readonly[toStringTag]

Example

Methods

[iterator]

Returns Iterator<never>

Example

and

Type Parameters

Parameters

Returns this

See

Example

andThen

Type Parameters

Parameters

Returns this

See

Example

andThenAsync

Type Parameters

Parameters

Returns Promise<None>

See

Example

eq

Type Parameters

Parameters

Returns boolean

Example

expect

Parameters

Returns never

Throws

See

Example

filter

Parameters

Returns this

Example

flatten

Returns this

Example

inspect

Parameters

Returns this

Example

isNone

Returns true

Example

isNoneOr

Parameters

Returns true

See

Example

isNoneOrAsync

Parameters

Returns Promise<true>

See

Example

isSome

Returns false

Example

isSomeAnd

Parameters

Returns false

Example

isSomeAndAsync

Parameters

Returns Promise<false>

See

Example

map

Type Parameters

`Readonly`[OptionKindSymbol]

`Readonly`[toStringTag]