Opt | ts-opt

Type parameters

T

Wrapped value type.

Hierarchy

Opt
- None
- Some

Index

Accessors

Methods

Accessors

isEmpty

get isEmpty(): boolean

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

Returns boolean

length

get length(): number

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

Returns number

nonEmpty

get nonEmpty(): boolean

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

Returns boolean

Methods

Abstract bimap

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

- Defined in Opt.ts:282
Similar to caseOf but doesn't unwrap value.
```
some(1).bimap(x => x + 1, () => 0) // Some(2)
none.bimap(x => x + 1, () => 0) // Some(0)
```
Type parameters
- U
Parameters
- someF: (_: T) => U
 - - (_: T): U
 - Parameters
 - _: T
 Returns U
- noneF: () => U
 - - (): U
 - Returns U
Returns Opt

Abstract caseOf

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

- Defined in Opt.ts:183
Applies appropriate function and returns result from the function.
```
some(1).caseOf(x => x + 1, () => 0) // 2
none.caseOf(x => x + 1, () => 0) // 0
```
Type parameters
- R
Parameters
- onSome: (x: T) => R
  
  Processing function for Some.
  - - (x: T): R
    - Parameters
      - x: T
      Returns R
- onNone: () => R
  
  Processing function for None.
  - - (): R
    - Returns R
Returns R

chain

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

- Defined in Opt.ts:90
Alias of flatMap

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

chainToOpt

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

- Defined in Opt.ts:102
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) => U | undefined | null
 - - (_: T): U | undefined | null
 - Parameters
 - _: T
 Returns U | undefined | null
Returns Opt

Abstract contains

contains(x: T): boolean

- Defined in Opt.ts:221
Compares inner value with given value using ===. Always false for None.
```
some(1).contains(1) // true
some(0).contains(1) // false
none.contains(undefined) // false
```
Parameters
- x: T
Returns boolean

Abstract equals

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

Is a value of this instance and given other instance the same? Default comparator function is === (referential equality).

none.equals(none) // true
some(1).equals(none) // false
some(1).equals(some(1)) // true
some(1).equals(some(2)) // false
some({a: 1}).equals(some({a: 1})) // false (different objects)
some(1).equals(some(2), (x, y) => true) // true (custom comparator function)

const jsonCmp = <T>(a: T, b: T): boolean => JSON.stringify(a) === JSON.stringify(b);
some({a: 1}).equals(some({a: 1}), jsonCmp) // true (comparing values converted to JSON)

Parameters

other: Opt<T>
Optional comparator: EqualityFunction

Returns boolean

Abstract exists

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

- Defined in Opt.ts:234
Applies p to inner value and passes result. Always false for None.
```
some(0).exists(x => x > 0) // false
some(1).exists(x => x > 0) // true
none.exists(x => x > 0) // false
```
Parameters
- p: (x: T) => boolean
  
  Predicate.
  - - (x: T): boolean
    - Parameters
      - x: T
      Returns boolean
Returns boolean

Abstract filter

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

- Defined in Opt.ts:357
Returns Some with same value if predicate holds, None otherwise.
```
opt(1).filter(x => x > 0); // Some(1)
opt(-1).filter(x => x > 0); // None
```
see

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

Abstract flatBimap

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

- Defined in Opt.ts:295
Similar to bimap, but accepts functions returning Opt.
```
some(1).flatBimap(x => some(x+1), () => some(0)) // Some(2)
none.flatBimap(x => some(x+1), () => some(0)) // Some(0)
some(5).flatBimap(x => none, () => some(0)) // None
```
Type parameters
- U
Parameters
- someF: (_: T) => Opt
 - - (_: T): Opt
 - Parameters
 - _: T
 Returns Opt
- noneF: () => Opt
 - - (): Opt
 - Returns Opt
Returns Opt

Abstract flatMap

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

- Defined in Opt.ts:84
Similar to map, but function is expected to return Opt which will be returned. Useful for including steps which may fail or return no value.
```
some(1).flatMap(x => x === 1 ? none : some(x + 1)) // None
none.flatMap(x => some(1)) // None
```
Type parameters
- U
Parameters
- f: (_: T) => Opt
 - - (_: T): Opt
 - Parameters
 - _: T
 Returns Opt
Returns Opt

Abstract forAll

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

- Defined in Opt.ts:246
Applies p to inner value and passes result. Always true for None.
```
some(0).forAll(x => x > 0) // false
some(1).forAll(x => x > 0) // true
none.forAll(x => x > 0) // true
```
Parameters
- p: (x: T) => boolean
  
  Predicate.
  - - (x: T): boolean
    - Parameters
      - x: T
      Returns boolean
Returns boolean

isNone

isNone(): this is None<T>

- Defined in Opt.ts:32
Is this instance of None?

Returns this is None<T>

isSome

isSome(): this is Some<T>

- Defined in Opt.ts:27
Is this instance of Some?

Returns this is Some<T>

Abstract map

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

- Defined in Opt.ts:71
Applies function to the wrapped value and returns a new instance of Some.
```
some(1).map(x => x + 1) // Some(2)
none.map(x => x + 1) // None
```
Type parameters
- U
Parameters
- f: (_: T) => U
 - - (_: T): U
 - Parameters
 - _: T
 Returns U
Returns Opt

Abstract narrow

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

- Defined in Opt.ts:380
Narrows type inside Opt using given type guard.
```
some('1' as string | number).narrow(isString) // Some('1'): Opt<string>
some(1 as string | number).narrow(isString) // None: Opt<string>
```
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>

- Defined in Opt.ts:368
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>

Abstract onNone

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

- Defined in Opt.ts:195
Calls f on None, does nothing for Some.

Parameters
- f: () => void
 - - (): void
 - Returns void
Returns Opt<T>

Abstract onSome

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

- Defined in Opt.ts:189
Calls f on Some with its value, does nothing for None.

Parameters
- f: (x: T) => void
 - - (x: T): void
 - Parameters
 - x: T
 Returns void
Returns Opt<T>

Abstract optOrCrash

optOrCrash(msg: string): Opt<T>

- Defined in Opt.ts:120
Crash when called on None, pass Opt instance on Some.
```
some(1).optOrCrash('fail') // Some(1)
none.optOrCrash('fail') // throws
```
Parameters
- msg: string
Returns Opt<T>

Abstract orCrash

orCrash(msg: string): T

- Defined in Opt.ts:108
Returns value when Some, throws error with msg otherwise.

Parameters
- msg: string
  
  Error message.
Returns T

Abstract orElse

orElse(def: T): T

- Defined in Opt.ts:258
Get inner value if Some, or use passed def value for None.
```
some(1).orElse(2) // 1
none.orElse(2) // 2
```
Parameters
- def: T
  
  Default value.
Returns T

Abstract orElseOpt

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

Return this for Some, def for None.

some(1).orElseOpt(some(2)) // Some(1)
none.orElseOpt(some(2)) // Some(2)
none.orElseOpt(none) // None

Parameters

def: Opt<T>

Returns Opt<T>

Abstract orFalse

orFalse(): T | false

- Defined in Opt.ts:150
Returns inner value for Some, false for None.
```
some(1).orFalse() // 1
none.orFalse() // false
```
Returns T | false

Abstract orNaN

orNaN(): T | number

- Defined in Opt.ts:170
Returns inner value for Some, NaN for None.
```
some(1).orNaN() // 1
none.orNaN() // NaN
```
Returns T | number

Abstract orNull

orNull(): T | null

- Defined in Opt.ts:140
Returns value for Some or null for None.
```
some(1).orNull() // 1
none.orNull() // null
```
Returns T | null

Abstract orTrue

orTrue(): T | true

- Defined in Opt.ts:160
Returns inner value for Some, true for None.
```
some(1).orTrue() // 1
none.orTrue() // true
```
Returns T | true

Abstract orUndef

orUndef(): T | undefined

- Defined in Opt.ts:130
Returns value for Some or undefined for None.
```
some(1).orUndef() // 1
none.orUndef() // undefined
```
Returns T | undefined

pipe

pipe<R>(f: (x: Opt<T>) => R): R

- Defined in Opt.ts:208
Applies passed function to this instance and returns function result. Also known as a function application, |> or pipe operator.
```
some(1).pipe(x => x.isEmpty) // false
none.pipe(x => x.isEmpty) // true
```
Type parameters
- R
Parameters
- f: (x: Opt<T>) => R
 - - (x: Opt<T>): R
 - Parameters
 - x: Opt<T>
 Returns R
Returns R

Abstract print

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

Print value to console.

opt(1).print() // logs 'Some:', '1'; returns Some(1)
opt(1).print('test') // logs '[test]', 'Some:', '1'; returns Some(1)
none.print('x') // logs '[x]', 'None'; returns None

Parameters

Optional tag: undefined | string

Returns Opt<T>

Abstract toArray

toArray(): [] | [T]

- Defined in Opt.ts:59
Converts Opt to an array.
```
some(1).toArray() // [1]
none.toArray() // []
```
Returns [] | [T]

Abstract toString

toString(): string

- Defined in Opt.ts:305
Formats Opt to string. In case of Some inner value is converted using JSON.stringify.
```
some(1).toString() // 'Some(1)'
none.toString() // 'None'
```
Returns string

Abstract zip

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

- Defined in Opt.ts:318
Joins two optional values to a pair. If either of them is None then the result is None.
```
some(1).zip(some(true)) // Some([1, true])
some(1).zip(none) // None
none.zip(some(1)) // None
none.zip(none) // None
```
Type parameters
- U
Parameters
- other: Opt
Returns Opt<[T, U]>

Abstract zip3

zip3<X, Y>(x: Opt<X>, y: Opt<Y>): Opt<[T, X, Y]>

- Defined in Opt.ts:329
Same as zip, but with one more optional.
```
some(1).zip3(some('a'), some(false)) // Some([1, 'a', false])
none.zip3(some(1), some(2)) // None
```
Type parameters
- X
- Y
Parameters
- x: Opt<X>
- y: Opt<Y>
Returns Opt<[T, X, Y]>

Abstract zip4

zip4<X, Y, Z>(x: Opt<X>, y: Opt<Y>, z: Opt<Z>): Opt<[T, X, Y, Z]>

- Defined in Opt.ts:337
Same as zip3, but with one more optional.

Type parameters
- X
- Y
- Z
Parameters
- x: Opt<X>
- y: Opt<Y>
- z: Opt<Z>
Returns Opt<[T, X, Y, Z]>

Abstract zip5

zip5<X, Y, Z, ZZ>(x: Opt<X>, y: Opt<Y>, z: Opt<Z>, zz: Opt<ZZ>): Opt<[T, X, Y, Z, ZZ]>

- Defined in Opt.ts:346
Same as zip4, but with one more optional.

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>

- Defined in Opt.ts:49
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

Accessors

Methods

Accessors

isEmpty

Returns boolean

length

Returns number

nonEmpty

Returns boolean

Methods

Abstract bimap

Type parameters

U

Parameters

someF: (_: T) => U

Parameters

_: T

Returns U

noneF: () => U

Returns U

Returns Opt<U>

Abstract 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) => U | undefined | null

Parameters

_: T

Returns U | undefined | null

Returns Opt<U>

Abstract contains

Parameters

x: T

Returns boolean

Abstract equals

Parameters

other: Opt<T>

Optional comparator: EqualityFunction

Returns boolean

Abstract exists

Parameters

p: (x: T) => boolean

Parameters

x: T

Returns boolean

Returns boolean

Abstract filter

Parameters

predicate: (_: T) => boolean

Parameters

_: T

Returns boolean

Returns Opt<T>

Abstract flatBimap

Type parameters

U