Class Optional<ValueT>

Type Parameters

ValueT

Hierarchy

Monad<ValueT>
- Optional

Index

Constructors

constructor

Properties

Methods

Constructors

constructor

new Optional<ValueT>(_success: boolean, _value: undefined | null | ValueT): Optional<ValueT>

Overrides Monad.constructor
- Defined in Optional.ts:8
Type Parameters
- ValueT
Parameters
- _success: boolean
- _value: undefined | null | ValueT
Returns Optional<ValueT>

Properties

_success

_success: boolean

_value

_value: undefined | null | ValueT

Methods

amap

amap<B>(mapping: Optional<((value: ValueT) => B)>): Optional<B>

Overrides Monad.amap
- Defined in Optional.ts:44
Type Parameters
- B
Parameters
- mapping: Optional<((value: ValueT) => B)>
Returns Optional<B>

and

and<B, App>(b: CallHKT<App, B>): CallHKT<App, [ValueT, B]>

Inherited from Monad.and
- Defined in Applicative.ts:30
Type Parameters
- B
- App extends ApplicativeHKT<App>
Parameters
- b: CallHKT<App, B>
Returns CallHKT<App, [ValueT, B]>

andIgnoreLeft

andIgnoreLeft<B, App>(b: CallHKT<App, B>): CallHKT<App, B>

Inherited from Monad.andIgnoreLeft
- Defined in Applicative.ts:26
Type Parameters
- B
- App extends ApplicativeHKT<App>
Parameters
- b: CallHKT<App, B>
Returns CallHKT<App, B>

andIgnoreRight

andIgnoreRight<B, App>(b: CallHKT<App, B>): CallHKT<App, ValueT>

Inherited from Monad.andIgnoreRight
- Defined in Applicative.ts:22
Type Parameters
- B
- App extends ApplicativeHKT<App>
Parameters
- b: CallHKT<App, B>
Returns CallHKT<App, ValueT>

catch

catch<NewErrorT>(mapping: (() => ValueT)): Optional<ValueT>

- Defined in Optional.ts:93
If None() replace it with a value

Type Parameters
- NewErrorT
Parameters
- mapping: (() => ValueT)
  - - (): ValueT
    - Returns ValueT
Returns Optional<ValueT>

catchThen

catchThen<NewErrorT>(mapping: (() => Optional<ValueT>)): Optional<ValueT>

- Defined in Optional.ts:105
If None() replaces it with the result of the mapping

Type Parameters
- NewErrorT
Parameters
- mapping: (() => Optional<ValueT>)
  - - (): Optional<ValueT>
    - Returns Optional<ValueT>
Returns Optional<ValueT>

map

map<B>(mapping: ((value: ValueT) => B)): Optional<B>

Overrides Monad.map
- Defined in Optional.ts:36
If a value is held, this uses the mapping function to transform it, and returns Optional otherwise, it returns None()

Type Parameters
- B
Parameters
- mapping: ((value: ValueT) => B)
  - - (value: ValueT): B
    - Parameters
      - value: ValueT
      Returns B
Returns Optional<B>

or

or<B>(defaultValue: B): ValueT | B

- Defined in Optional.ts:81
Returns the value is defined, otherwise it returns defaultValue

Type Parameters
- B
Parameters
- defaultValue: B
Returns ValueT | B

pure

pure<B>(value: B): Optional<B>

Overrides Monad.pure
- Defined in Optional.ts:58
Type Parameters
- B
Parameters
- value: B
Returns Optional<B>

replaceA

replaceA<B>(value: B): Functor<B>

Inherited from Monad.replaceA
- Defined in Functor.ts:10
Type Parameters
- B
Parameters
- value: B
Returns Functor<B>

then

then<B>(mapping: ((value: ValueT) => Optional<B>)): Optional<B>

Overrides Monad.then
- Defined in Optional.ts:67
If a value is held the mapping is preformed on it, otherwise None() is returned. If you want to just transform ValueT to a new Value, use .map

Type Parameters
- B
Parameters
- mapping: ((value: ValueT) => Optional<B>)
  - - (value: ValueT): Optional<B>
    - Parameters
      - value: ValueT
      Returns Optional<B>
Returns Optional<B>

unwrap

unwrap(): ValueT

- Defined in Optional.ts:117
Returns the value if Some(), otherwise it throws a reference error. This is the nuclear option, .or(default) should be preferred.

Returns ValueT

Static liftToApplicative

liftToApplicative<A, B, C, App>(fn: ((value: A) => ((value: B) => C))): ((a: CallHKT<App, A>) => ((b: CallHKT<App, B>) => CallHKT<App, C>))

Inherited from Monad.liftToApplicative
- Defined in Applicative.ts:14
Type Parameters
- A
- B
- C
- App extends ApplicativeHKT<App>
Parameters
- fn: ((value: A) => ((value: B) => C))
  - - (value: A): ((value: B) => C)
    - Parameters
      - value: A
      Returns ((value: B) => C)
      - (value: B): C
        Parameters
        value: B
        Returns C
Returns ((a: CallHKT<App, A>) => ((b: CallHKT<App, B>) => CallHKT<App, C>))
- - (a: CallHKT<App, A>): ((b: CallHKT<App, B>) => CallHKT<App, C>)
  - Parameters
    - a: CallHKT<App, A>
    Returns ((b: CallHKT<App, B>) => CallHKT<App, C>)
    - - (b: CallHKT<App, B>): CallHKT<App, C>
      - Parameters
        b: CallHKT<App, B>
        Returns CallHKT<App, C>

Static wrap

wrap<FnT>(fn: FnT): ((...args: Parameters<FnT>) => Optional<NonNullable<ReturnType<FnT>>>)

- Defined in Optional.ts:19
Used to wrap a function that can potentially return null or undefined in a safe wrapper
```
const safeQuerySelector = Optional.wrap(document.querySelector)
```
Type Parameters
- FnT extends ((...args: any[]) => any)
Parameters
- fn: FnT
Returns ((...args: Parameters<FnT>) => Optional<NonNullable<ReturnType<FnT>>>)
- - (...args: Parameters<FnT>): Optional<NonNullable<ReturnType<FnT>>>
  - Parameters
    - Rest ...args: Parameters<FnT>
    Returns Optional<NonNullable<ReturnType<FnT>>>

Generated using TypeDoc