None | ts-opt

Empty Opt.

notexported
see: Opt

Type parameters

Hierarchy

Opt<T>
- None

Index

Constructors

constructor

Properties

Accessors

Methods

Constructors

constructor

new None<T>(): None<T>

Inherited from Opt.constructor

Type parameters
- T
Returns None<T>

Properties

Readonly @@type

@@type: symbol = ...

act

act: ActInClassFn<T> = ...

Similar to chain (in other languages called bind or >>=), but supports more functions passed at once (resembles do notation in Haskell). It is used to model a sequence of operations where each operation can fail (can return None).

// does addition when first argument is number
const f1 =
  (x: string | number) => (y: number) => opt(x).narrow(isNumber).map(z => z + y);
// passes only even numbers
const f2 = (x: number): Opt<number> => x % 2 === 0 ? opt(x) : none;

opt(0).act( // Some(0)
  f1(-2), // Some(-2)
  f2, // Some(-2)
  optNegative, // None
); // None

opt(0).act( // Some(0)
  f1(1), // Some(1)
  f2, // None
  optNegative, // won't get called, still None
); // None

opt(3).act( // Some(3)
  f1(1), // Some(4)
  f2, // Some(4)
  optNegative, // Some(4)
); // Some(4)

param

actToOpt

actToOpt: ActToOptInClassFn<T> = ...

Similar to act, but functions return empty values instead of Opt. It is useful for typical JavaScript functions (e.g. lodash), properly handles undefined/null/NaN at any point of the chain.

const data = [{}, {f: true, a: [{b: 7, c: 1}]}, {a: [{}]}];
opt(data).actToOpt(
  find(x => Boolean(x?.f)), // {f: true, a: [{b: 7, c: 1}]}
  x => x?.a, // [{b: 7, c: 1}]
  find(x => x.b === 8) // undefined
); // None

param

chainFlow

chainFlow: ActInClassFn<T> = ...

Alias of act

param

chainToOptFlow

chainToOptFlow: ActToOptInClassFn<T> = ...

Alias of actToOpt.

param

const

const: ConstInClassFn<T> = ...

Constructs a function which returns a value for Some or an empty value for None (default is null). Optionally takes an empty value as a parameter.

opt(1).const()() // 1
opt(undefined).const()() // null

// custom empty value
opt(NaN).const(undefined)() // undefined

mapFlow

mapFlow: MapFlowInClassFn<T> = ...

Similar to map, but supports more functions which are called in succession, each on a result of a previous one.

const sq = (x: number) => x * x;
const dec = (x: number) => x - 1;
opt(4).mapFlow(sq, dec) // Some(15)
opt(null).mapFlow(sq, dec) // None

param

pipe

pipe: PipeInClassFn<T> = ...

Applies passed function to this instance and returns function result. Also known as a reverse function application, |> (Reason/ReScript, F#, OCaml), & (Haskell), # (PureScript) or a pipe operator.

some(1).pipe(x => x.isEmpty) // false
none.pipe(x => x.isEmpty) // true

Supports multiple functions.

opt(1).pipe( // Some(1)
  x => x.isEmpty, // false
  x => !x, // true
) // true

param: Functions in call chain

Accessors

isEmpty

get isEmpty(): boolean

- Defined in Opt.ts:653
Returns boolean

length

get length(): number

- Defined in Opt.ts:61
1 for Some, 0 for None.

Returns number

nonEmpty

get nonEmpty(): boolean

- Defined in Opt.ts:46
false for Some, true for None.

Returns boolean

Methods

at

at<R>(_index: number): Opt<R>

Overrides Opt.at
- Defined in Opt.ts:734
Type parameters
- R: unknown
Parameters
- _index: number
Returns Opt<R>

bimap

bimap(_someF: (_: T) => U, noneF: () => U): Opt

Overrides Opt.bimap
- Defined in Opt.ts:701
Type parameters
- U
Parameters
- _someF: (_: T) => U
 - - (_: T): U
 - Parameters
 - _: T
 Returns U
- noneF: () => U
 - - (): U
 - Returns U
Returns Opt

caseOf

caseOf<R>(_onSome: (x: T) => R, onNone: () => R): R

Overrides Opt.caseOf
- Defined in Opt.ts:680
Type parameters
- R
Parameters
- _onSome: (x: T) => R
  - - (x: T): R
    - Parameters
      - x: T
      Returns R
- onNone: () => R
  - - (): R
    - Returns R
Returns R

chain

chain(f: (_: T) => Opt): Opt

Inherited from Opt.chain
- Defined in Opt.ts:127
Alias of flatMap

Type parameters
- U
Parameters
- f: (_: T) => Opt
 - - (_: T): Opt
 - Parameters
 - _: T
 Returns Opt
Returns Opt

chainToOpt

chainToOpt(f: (_: T) => undefined | null | U): Opt

Inherited from Opt.chainToOpt
- Defined in Opt.ts:178
Combination of flatMap and opt functions.
```
some(1).chainToOpt(x => x === 1 ? null : x + 1) // None
some(2).chainToOpt(x => x === 1 ? null : x + 1) // Some(3)
```
Type parameters
- U
Parameters
- f: (_: T) => undefined | null | U
 - - (_: T): undefined | null | U
 - Parameters
 - _: T
 Returns undefined | null | U
Returns Opt

contains

contains(_x: T): boolean

Overrides Opt.contains
- Defined in Opt.ts:691
Parameters
- _x: T
Returns boolean

equals

equals(other: Opt<T>, _comparator?: EqualityFunction): boolean

Overrides Opt.equals
- Defined in Opt.ts:724
Parameters
- other: Opt<T>
- _comparator: EqualityFunction = ...
Returns boolean

exists

exists(_p: (x: T) => boolean): boolean

Overrides Opt.exists
- Defined in Opt.ts:693
Parameters
- _p: (x: T) => boolean
  - - (x: T): boolean
    - Parameters
      - x: T
      Returns boolean
Returns boolean

filter

filter(_predicate: (_: T) => boolean): Opt<T>

Overrides Opt.filter
- Defined in Opt.ts:715
Parameters
- _predicate: (_: T) => boolean
 - - (_: T): boolean
 - Parameters
 - _: T
 Returns boolean
Returns Opt<T>

flatBimap

flatBimap(_someF: (_: T) => Opt, noneF: () => Opt): Opt

Overrides Opt.flatBimap
- Defined in Opt.ts:703
Type parameters
- U
Parameters
- _someF: (_: T) => Opt
 - - (_: T): Opt
 - Parameters
 - _: T
 Returns Opt
- noneF: () => Opt
 - - (): Opt
 - Returns Opt
Returns Opt

flatMap

flatMap(_f: (_: T) => Opt): Opt

Overrides Opt.flatMap
- Defined in Opt.ts:657
Type parameters
- U
Parameters
- _f: (_: T) => Opt
 - - (_: T): Opt
 - Parameters
 - _: T
 Returns Opt
Returns Opt

forAll

forAll(_p: (x: T) => boolean): boolean

Overrides Opt.forAll
- Defined in Opt.ts:695
Parameters
- _p: (x: T) => boolean
  - - (x: T): boolean
    - Parameters
      - x: T
      Returns boolean
Returns boolean

head

head<R>(): Opt<R>

Inherited from Opt.head
- Defined in Opt.ts:630
Get a first item of an array.
example
```
opt([1, 2, 3]).head() // Some(1)
opt([]).head() // None
opt(null).head() // None
```
Type parameters
- R: unknown
Returns Opt<R>

isNone

isNone(): this is None<T>

Inherited from Opt.isNone
- Defined in Opt.ts:56
Is this instance of None?

Returns this is None<T>

isSome

isSome(): this is Some<T>

Inherited from Opt.isSome
- Defined in Opt.ts:51
Is this instance of Some?

Returns this is Some<T>

last

last<R>(): Opt<R>

Inherited from Opt.last
- Defined in Opt.ts:642
Get a last item of an array.
example
```
opt([1, 2, 3]).last() // Some(3)
opt([]).last() // None
opt(null).last() // None
```
Type parameters
- R: unknown
Returns Opt<R>

map

map(): Opt

Overrides Opt.map
- Defined in Opt.ts:659
Type parameters
- U
Returns Opt

narrow

narrow(_guard: (value: any) => value is U): Opt

Overrides Opt.narrow
- Defined in Opt.ts:717
Type parameters
- U
Parameters
- _guard: (value: any) => value is U
 - - (value: any): value is U
 - Parameters
 - value: any
 Returns value is U
Returns Opt

noneIf

noneIf(predicate: (_: T) => boolean): Opt<T>

Inherited from Opt.noneIf
- Defined in Opt.ts:501
Returns None if predicate holds, otherwise passes same instance of Opt.
```
opt(1).noneIf(x => x > 0); // None
opt(-1).noneIf(x => x > 0); // Some(-1)
```
see

filter
Parameters
- predicate: (_: T) => boolean
 - - (_: T): boolean
 - Parameters
 - _: T
 Returns boolean
Returns Opt<T>

onNone

onNone(f: () => void): Opt<T>

Overrides Opt.onNone
- Defined in Opt.ts:684
Parameters
- f: () => void
 - - (): void
 - Returns void
Returns Opt<T>

onSome

onSome(_f: (x: T) => void): Opt<T>

Overrides Opt.onSome
- Defined in Opt.ts:689
Parameters
- _f: (x: T) => void
 - - (x: T): void
 - Parameters
 - x: T
 Returns void
Returns Opt<T>

optOrCrash

optOrCrash(msg: string): Opt<T>

Overrides Opt.optOrCrash
- Defined in Opt.ts:666
deprecated

Please use someOrCrash instead

Parameters
- msg: string
Returns Opt<T>

orCrash

orCrash(msg: string): T

Overrides Opt.orCrash
- Defined in Opt.ts:661
Parameters
- msg: string
Returns T

orElse

orElse(def: T): T

Overrides Opt.orElse
- Defined in Opt.ts:697
Parameters
- def: T
Returns T

orElseOpt

orElseOpt(def: Opt<T>): Opt<T>

Overrides Opt.orElseOpt
- Defined in Opt.ts:699
Parameters
- def: Opt<T>
Returns Opt<T>

orFalse

orFalse(): false | T

Overrides Opt.orFalse
- Defined in Opt.ts:674
Returns false | T

orNaN

orNaN(): number | T

Overrides Opt.orNaN
- Defined in Opt.ts:678
Returns number | T

orNull

orNull(): null | T

Overrides Opt.orNull
- Defined in Opt.ts:670
Returns null | T

orTrue

orTrue(): true | T

Overrides Opt.orTrue
- Defined in Opt.ts:676
Returns true | T

orUndef

orUndef(): undefined | T

Overrides Opt.orUndef
- Defined in Opt.ts:672
Returns undefined | T

print

print(tag?: string): Opt<T>

Overrides Opt.print
- Defined in Opt.ts:719
Parameters
- Optional tag: string
Returns Opt<T>

prop

prop<K>(_key: K): Opt<NonNullable<T[K]>>

Overrides Opt.prop
- Defined in Opt.ts:728
Type parameters
- K: string | number | symbol
Parameters
- _key: K
Returns Opt<NonNullable<T[K]>>

someOrCrash

someOrCrash(msg: string): Some<T>

Overrides Opt.someOrCrash
- Defined in Opt.ts:668
Parameters
- msg: string
Returns Some<T>

swap

swap(_newVal: U): Opt

Overrides Opt.swap
- Defined in Opt.ts:730
Type parameters
- U
Parameters
- _newVal: U
Returns Opt

toArray

toArray(): [] | [T]

Overrides Opt.toArray
- Defined in Opt.ts:655
Returns [] | [T]

toString

toString(): string

Overrides Opt.toString
- Defined in Opt.ts:705
Returns string

widen

widen<U, R>(): Opt<R>

Inherited from Opt.widen
- Defined in Opt.ts:553
Widen union (typically union of strings to string). Experimental. May be removed if it is later found out it's unsafe and unfixable.
```
opt(someValueOfUnionType).widen<SuperOfThatUnion>() // :Opt<SuperOfThatUnion>
```
Type parameters
- U
- R = SuperUnionOf<U, T>
Returns Opt<R>

zip

zip(_other: Opt): Opt<[T, U]>

Overrides Opt.zip
- Defined in Opt.ts:707
Type parameters
- U
Parameters
- _other: Opt
Returns Opt<[T, U]>

zip3

zip3<X, Y>(_x: Opt<X>, _y: Opt<Y>): Opt<[T, X, Y]>

Overrides Opt.zip3
- Defined in Opt.ts:709
Type parameters
- X
- Y
Parameters
- _x: Opt<X>
- _y: Opt<Y>
Returns Opt<[T, X, Y]>

zip4

zip4<X, Y, Z>(_x: Opt<X>, _y: Opt<Y>, _z: Opt<Z>): Opt<[T, X, Y, Z]>

Overrides Opt.zip4
- Defined in Opt.ts:711
Type parameters
- X
- Y
- Z
Parameters
- _x: Opt<X>
- _y: Opt<Y>
- _z: Opt<Z>
Returns Opt<[T, X, Y, Z]>

zip5

zip5<X, Y, Z, ZZ>(_x: Opt<X>, _y: Opt<Y>, _z: Opt<Z>, _zz: Opt<ZZ>): Opt<[T, X, Y, Z, ZZ]>

Overrides Opt.zip5
- Defined in Opt.ts:713
Type parameters
- X
- Y
- Z
- ZZ
Parameters
- _x: Opt<X>
- _y: Opt<Y>
- _z: Opt<Z>
- _zz: Opt<ZZ>
Returns Opt<[T, X, Y, Z, ZZ]>

Static fromArray

fromArray<T>(x: [] | [T]): Opt<T>

Inherited from Opt.fromArray
- Defined in Opt.ts:73
Create Opt instance from an array of one or zero items.
```
Opt.fromArray([]) // None
Opt.fromArray([1]) // Some(1)
```
Type parameters
- T
Parameters
- x: [] | [T]
Returns Opt<T>

Type parameters

T

Hierarchy

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Type parameters

T

Returns None<T>

Properties

Readonly @@type

act

actToOpt

chainFlow

chainToOptFlow

const

mapFlow

pipe

Accessors

isEmpty

Returns boolean

length

Returns number

nonEmpty

Returns boolean

Methods

at

Type parameters

R: unknown

Parameters

_index: number

Returns Opt<R>

bimap

Type parameters

U

Parameters

_someF: (_: T) => U

Parameters

_: T

Returns U

noneF: () => U

Returns U

Returns Opt<U>

caseOf

Type parameters

R

Parameters

_onSome: (x: T) => R

Parameters

x: T

Returns R

onNone: () => R

Returns R

Returns R

chain

Type parameters

U

Parameters

f: (_: T) => Opt<U>

Parameters

_: T

Returns Opt<U>

Returns Opt<U>

chainToOpt

Type parameters

U

Parameters

f: (_: T) => undefined | null | U

Parameters

_: T

Returns undefined | null | U

Returns Opt<U>

contains

Parameters

_x: T

Returns boolean