Class None

Implements

NoneBase

Index

Constructors

Properties

Accessors

[toStringTag] value

Constructors

constructor

new None(): None
Returns None

Properties

`Readonly`_tag

_tag: "None" = 'None'

Accessors

[toStringTag]

get "[toStringTag]"(): string
Returns string

value

get value(): null
Returns null
Implementation of NoneBase.value

Methods

[iterator]

"[iterator]"(): IterableIterator<never>
Returns IterableIterator<never>
Implementation of NoneBase.[iterator]

and

and<U>(other: Option<U>): None
Returns None if the option is None, otherwise returns other.
Type Parameters
- U
Parameters
- other: Option<U>
Returns None
Implementation of NoneBase.and

andThen

andThen<U>(fn: (value: never) => Option<U>): None
Maps an Option<T> to Option<U> by applying a function to a contained value, if present. This is a no-op if the option is None.
Type Parameters
- U
Parameters
- fn: (value: never) => Option<U>
Returns None
Implementation of NoneBase.andThen

andThenAsync

andThenAsync<U>(fn: (value: never) => Promise<Option<U>>): Promise<None>
Maps an Option<T> to Promise<Option<U>> by applying a function to a contained value, if present. This is a no-op if the option is None.
Type Parameters
- U
Parameters
- fn: (value: never) => Promise<Option<U>>
Returns Promise<None>
Implementation of NoneBase.andThenAsync

equals

equals<T>(other: Option<T>): boolean
Returns true if the current option is equivalent to other.
Type Parameters
- T
Parameters
- other: Option<T>
Returns boolean
Implementation of NoneBase.equals

expect

expect(message: string): never
Returns the option if it is a Some value, otherwise throws an error with the provided message.
Parameters
- message: string
Returns never
Implementation of NoneBase.expect

filter

filter(fn: (value: never) => boolean): None
Returns None if the option is None or the predicate fn returns false, otherwise returns the option.
Parameters
- fn: (value: never) => boolean
Returns None
Implementation of NoneBase.filter

inspect

inspect(fn: (value: never) => void): None
Calls fn if the option is a Some value. Useful for checking the contents of a Some while still being able to use it after in a chain.
Parameters
- fn: (value: never) => void
Returns None
Implementation of NoneBase.inspect

inspectNone

inspectNone(fn: () => void): None
Calls fn if the option is a None value. Useful for checking the contents of a None while still being able to use it after in a chain.
Parameters
- fn: () => void
Returns None
Implementation of NoneBase.inspectNone

isNone

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

Returns this is None
Implementation of NoneBase.isNone

isSome

isSome(): this is Some<never>
Returns true if the option is a Some value.

Returns this is Some<never>
Implementation of NoneBase.isSome

isSomeAnd

isSomeAnd(fn: (value: never) => boolean): this is Some<never>
Returns true if the option is a Some value and fn returns true for the contained value.
Parameters
- fn: (value: never) => boolean
Returns this is Some<never>
Implementation of NoneBase.isSomeAnd

iter

iter(): IterableIterator<never>
Returns an iterator over the possibly contained value.

Returns IterableIterator<never>
Implementation of NoneBase.iter

map

map<U>(fn: (value: never) => undefined | null | U): None
Maps an Option<T> to Option<U> by applying a function to a contained value, if present. This is a no-op if the option is None.
Type Parameters
- U
Parameters
- fn: (value: never) => undefined | null | U
Returns None
Implementation of NoneBase.map

mapAsync

mapAsync<U>(fn: (value: never) => Promise<undefined | null | U>): Promise<None>
Maps an Option<T> to Promise<Option<U>> by applying a function to a contained value, if present. This is a no-op if the option is None.
Type Parameters
- U
Parameters
- fn: (value: never) => Promise<undefined | null | U>
Returns Promise<None>
Implementation of NoneBase.mapAsync

mapOr

mapOr<U>(fn: (value: never) => U, fallback: U): U
Maps an Option<T> to Option<U> by applying a function to a contained value, if present. Otherwise, returns U.
Type Parameters
- U
Parameters
- fn: (value: never) => U
- fallback: U
Returns U
Implementation of NoneBase.mapOr

mapOrAsync

mapOrAsync<U>(fn: (value: never) => Promise<U>, fallback: U): Promise<U>
Maps an Option<T> to Promise<U> by applying a function to a contained value, if present. Otherwise, returns U.
Type Parameters
- U
Parameters
- fn: (value: never) => Promise<U>
- fallback: U
Returns Promise<U>
Implementation of NoneBase.mapOrAsync

mapOrElse

mapOrElse<U>(fn: (value: never) => U, fallback: () => U): U
Maps an Option<T> to U by applying a function to a contained value, if present. Otherwise, calls the provided fallback function and returns the result.
Type Parameters
- U
Parameters
- fn: (value: never) => U
- fallback: () => U
Returns U
Implementation of NoneBase.mapOrElse

mapOrElseAsync

mapOrElseAsync<U>(
fn: (value: never) => Promise<U>,
fallback: () => Promise<U>,
): Promise<U>
Maps an Option<T> to Promise<U> by applying a function to a contained value, if present. Otherwise, calls the provided fallback function and returns the result.
Type Parameters
- U
Parameters
- fn: (value: never) => Promise<U>
- fallback: () => Promise<U>
Returns Promise<U>
Implementation of NoneBase.mapOrElseAsync

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(error).
Type Parameters
- E
Parameters
- error: E
Returns Result<never, E>
Implementation of NoneBase.okOr

okOrElse

okOrElse<E>(fn: () => E): Result<never, E>
Transforms the Option<T> into a Result<T, E>, mapping Some(v) to Ok(v) and None to Err(fn()).
Type Parameters
- E
Parameters
- fn: () => E
Returns Result<never, E>
Implementation of NoneBase.okOrElse

or

or<U>(other: Option<U>): Option<U>
Returns this option if it is Some, otherwise returns other.
Type Parameters
- U
Parameters
- other: Option<U>
Returns Option<U>
Implementation of NoneBase.or

orElse

orElse<U>(fn: () => Option<U>): Option<U>
Returns this option if it is Some, otherwise calls fn and returns the result.
Type Parameters
- U
Parameters
- fn: () => Option<U>
Returns Option<U>
Implementation of NoneBase.orElse

toString

toString(): string
Returns a string representation of the option for debugging purposes.

Returns string
Implementation of NoneBase.toString

unwrap

unwrap(): never
Unwraps the option, yielding the content of a Some.

USE THIS SPARINGLY! It is generally better to use unwrapOr or map to handle situations you may be temped to .unwrap() in.

Returns never
Throws
if the option is None.

Implementation of NoneBase.unwrap

unwrapOr

unwrapOr<V>(fallback: V): V
Unwraps the option, yielding the content of a Some, or returns fallback.
Type Parameters
- V
Parameters
- fallback: V
Returns V
Implementation of NoneBase.unwrapOr

unwrapOrElse

unwrapOrElse<V>(fn: () => V): V
Unwraps the option, yielding the content of a Some, or calls fn and returns the result.
Type Parameters
- V
Parameters
- fn: () => V
Returns V
Implementation of NoneBase.unwrapOrElse

xor

xor<U>(other: Option<U>): Option<U>
Returns Some if one or the other is Some, but not both. Otherwise, returns None.
Type Parameters
- U
Parameters
- other: Option<U>
Returns Option<U>
Implementation of NoneBase.xor

zip

zip<U>(other: Option<U>): Option<[never, U]>
Zips this with another option. If both are Some, returns a Some with a tuple of the two values. Otherwise, returns None.
Type Parameters
- U
Parameters
- other: Option<U>
Returns Option<[never, U]>
Implementation of NoneBase.zip

zipWith

zipWith<U, V>(other: Option<U>, fn: (a: never, b: U) => V): Option<V>
Zips this with another option, using the provided function to compute a new return value.If both are Some, returns a Some with the new value. Otherwise, returns None.
Type Parameters
- U
- V
Parameters
- other: Option<U>
- fn: (a: never, b: U) => V
Returns Option<V>
Implementation of NoneBase.zipWith