Some | ts-opt

Opt with a value inside.

notexported
see: Opt

Type parameters

Hierarchy

Opt<T>
- Some

Index

Constructors

constructor

Properties

Accessors

Methods

Constructors

constructor

new Some<T>(_value: T): Some<T>

Inherited from Opt.constructor
- Defined in Opt.ts:802
Type parameters
- T
Parameters
- _value: T
Returns Some<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:806
Returns boolean

length

get length(): number

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

Returns number

nonEmpty

get nonEmpty(): boolean

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

Returns boolean

value

get value(): T

- Defined in Opt.ts:808
Returns T

Methods

at

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

Overrides Opt.at
- Defined in Opt.ts:916
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:863
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:839
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:144
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:195
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:846
Parameters
- x: T
Returns boolean

equals

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

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

exists

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

Overrides Opt.exists
- Defined in Opt.ts:848
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:894
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:865
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:812
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:850
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:667
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:71
Is this instance of None?

Returns this is None<T>

isSome

isSome(): this is Some<T>

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

Returns this is Some<T>

last

last<R>(): Opt<R>

Inherited from Opt.last
- Defined in Opt.ts:679
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(f: (_: T) => U): Opt

Overrides Opt.map
- Defined in Opt.ts:816
Type parameters
- U
Parameters
- f: (_: T) => U
 - - (_: T): U
 - Parameters
 - _: T
 Returns U
Returns Opt

narrow

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

Overrides Opt.narrow
- Defined in Opt.ts:896
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:538
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>

onBoth

onBoth(onSome: (x: T) => void, _onNone: () => void): Opt<T>

Overrides Opt.onBoth
- Defined in Opt.ts:841
Parameters
- onSome: (x: T) => void
 - - (x: T): void
 - Parameters
 - x: T
 Returns void
- _onNone: () => void
 - - (): void
 - Returns void
Returns Opt<T>

onNone

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

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

onSome

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

Overrides Opt.onSome
- Defined in Opt.ts:854
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:825
deprecated

Please use someOrCrash instead

Parameters
- _msg: string
Returns Opt<T>

orCrash

orCrash(_msg: string): T

Overrides Opt.orCrash
- Defined in Opt.ts:820
Parameters
- _msg: string
Returns T

orElse

orElse(_def: T): T

Overrides Opt.orElse
- Defined in Opt.ts:859
Parameters
- _def: T
Returns T

orElseOpt

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

Overrides Opt.orElseOpt
- Defined in Opt.ts:861
Parameters
- _def: Opt<T>
Returns Opt<T>

orFalse

orFalse(): false | T

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

orNaN

orNaN(): number | T

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

orNull

orNull(): null | T

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

orTrue

orTrue(): true | T

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

orUndef

orUndef(): undefined | T

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

print

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

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

prop

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

Overrides Opt.prop
- Defined in Opt.ts:910
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:827
Parameters
- _msg: string
Returns Some<T>

swap

swap(newVal: U): Opt

Overrides Opt.swap
- Defined in Opt.ts:912
Type parameters
- U
Parameters
- newVal: U
Returns Opt

testReOrFalse

testReOrFalse<R>(re: RegExp): R

Inherited from Opt.testReOrFalse
- Defined in Opt.ts:692
A convenience function to test this (Opt<string>) against a given regular expression.
example
```
opt('a').testReOrFalse(/a/) // true
opt('b').testReOrFalse(/a/)) // false;
```
Type parameters
- R: boolean | OperationNotAvailable<T, string>
Parameters
- re: RegExp
 
 Regular expression
Returns R

toArray

toArray(): [] | [T]

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

toString

toString(): string

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

widen

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

Inherited from Opt.widen
- Defined in Opt.ts:590
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:869
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:874
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:880
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:887
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:88
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

Parameters

_value: T

Returns Some<T>

Properties

Readonly @@type

act

actToOpt

chainFlow

chainToOptFlow

const

mapFlow

pipe

Accessors

isEmpty

Returns boolean

length

Returns number

nonEmpty

Returns boolean

value

Returns T

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>