Interface Nothing<R>

Absolutely Nothing

Maybe data type specialiation representing an absence of any value

interface Nothing<R> {
    generator: MaybeGeneratorFunction<[], R, Nothing<R>, R>;
    chain<R2>(this, op): Nothing<never>;
    chain<R2>(this, op): Nothing<never>;
    chain<R2>(this, op): Nothing<never>;
    chain<R2>(this, op): Maybe<R2>;
    chain<R2>(this, op): Nothing<never>;
    chain<R2>(this, op): Maybe<R2>;
    isJust(): this is Just<R>;
    isNothing(): this is Nothing<R>;
    map<R2>(this, op): Nothing<never>;
    map<R2>(this, op): Maybe<R2>;
    matchChain<R2, R3>(this, op): Just<R3>;
    matchChain<R2, R3>(this, op): Nothing<never>;
    matchChain<R2, R3>(this, op): Just<R3>;
    matchChain<R2, R3>(this, op): Nothing<never>;
    matchChain<R2, R3>(this, op): Maybe<R3>;
    matchChain<R2, R3>(this, op): Maybe<R3>;
    matchChain<R2, R3>(this, op): Just<R3>;
    matchChain<R2, R3>(this, op): Nothing<never>;
    matchChain<R2, R3>(this, op): Maybe<R3>;
    matchChain<R2, R3>(this, op): Just<R2 | R3>;
    matchChain<R2, R3>(this, op): Maybe<R2>;
    matchChain<R2, R3>(this, op): Maybe<R3>;
    matchChain<R2, R3>(this, op): Nothing<never>;
    matchChain<R2, R3>(this, op): Maybe<R2 | R3>;
    matchChain<R2, R3>(this, op): Maybe<R3>;
    matchChain<R2, R3>(this, op): Maybe<R2 | R3>;
    matchChain<R2, R3>(this, op): Maybe<R2>;
    matchChain<R2, R3>(this, op): Maybe<R2 | R3>;
    matchMap<R2, R3>(this, op): Just<R3>;
    matchMap<R2, R3>(this, op): Just<R2 | R3>;
    matchTap(op): this;
    orChain<R2>(this, op): Just<R2>;
    orChain<R2>(this, op): Nothing<never>;
    orChain<R2>(this, op): Maybe<R2>;
    orChain<R2>(this, op): Just<R | R2>;
    orChain<R2>(this, op): Maybe<R>;
    orChain<R2>(this, op): Maybe<R | R2>;
    orMap<R2>(this, op): Just<R2>;
    orMap<R2>(this, op): Just<R | R2>;
    orTap(op): this;
    tap(op): this;
}

Type Parameters

Index

Properties

generator

Methods

chain isJust isNothing map matchChain matchMap matchTap orChain orMap orTap tap

Properties

generator

generator: MaybeGeneratorFunction<[], R, Nothing<R>, R>

Wrap Maybe to singleton generator

Userful in order to avoid ambiguous yied types

Returns

generator of Maybe wrapping this

Methods

chain

chain<R2>(this, op): Nothing<never>
Maybe composition function

Applied to 'just value' returns 'op(value)' Applied to 'nothing' returns self without invoking composition function
Type Parameters
- R2
  transformer function result's underlying type
Parameters
- this: Nothing<R>
- op: ((value) => Just<R2>)
  transformer to be invoked with underlying value
  - - (value): Just<R2>
    - Parameters
      value: R
      Returns Just<R2>
Returns Nothing<never>
'op(value)' or 'nothing'
- Defined in maybe.ts:297
chain<R2>(this, op): Nothing<never>
Type Parameters
- R2
Parameters
- this: Nothing<R>
- op: ((value) => Nothing<R2>)
  - - (value): Nothing<R2>
    - Parameters
      value: R
      Returns Nothing<R2>
Returns Nothing<never>
- Defined in maybe.ts:298
chain<R2>(this, op): Nothing<never>
Type Parameters
- R2
Parameters
- this: Nothing<R>
- op: ((value) => Maybe<R2>)
  - - (value): Maybe<R2>
    - Parameters
      value: R
      Returns Maybe<R2>
Returns Nothing<never>
- Defined in maybe.ts:299
chain<R2>(this, op): Maybe<R2>
Type Parameters
- R2
Parameters
- this: Maybe<R>
- op: ((value) => Just<R2>)
  - - (value): Just<R2>
    - Parameters
      value: R
      Returns Just<R2>
Returns Maybe<R2>
- Defined in maybe.ts:301
chain<R2>(this, op): Nothing<never>
Type Parameters
- R2
Parameters
- this: Maybe<R>
- op: ((value) => Nothing<R2>)
  - - (value): Nothing<R2>
    - Parameters
      value: R
      Returns Nothing<R2>
Returns Nothing<never>
- Defined in maybe.ts:302
chain<R2>(this, op): Maybe<R2>
Type Parameters
- R2
Parameters
- this: Maybe<R>
- op: ((value) => Maybe<R2>)
  - - (value): Maybe<R2>
    - Parameters
      value: R
      Returns Maybe<R2>
Returns Maybe<R2>
- Defined in maybe.ts:303

isJust

isJust(): this is Just<R>
Maybe type guard for 'just'

Returns this is Just<R>
'true' in case wrapped value exists (and resolves this type to be 'just')
Example
```
if (maybe.isJust()) {
  console.log(maybe.just);
}
```
- Defined in maybe.ts:369

isNothing

isNothing(): this is Nothing<R>
Maybe type guard for 'nothing'

Returns this is Nothing<R>
'true' in case wrapped value is 'nothing' (and resolves this type to be 'nothing')
Example
```
if (maybe.isNohing()) {
  console.log('nothing');
}
```
- Defined in maybe.ts:383

map

map<R2>(this, op): Nothing<never>
Maybe transformer function

Applied to 'just value' returns 'just op(value)' Applied to 'nothing' returns self without invoking transformer
Type Parameters
- R2
  transformer function's return type
Parameters
- this: Nothing<R>
- op: ((value) => R2)
  transformer to be invoked with underlying value
  - - (value): R2
    - Parameters
      value: R
      Returns R2
Returns Nothing<never>
'just op(value)' or 'nothing'
- Defined in maybe.ts:251
map<R2>(this, op): Maybe<R2>
Type Parameters
- R2
Parameters
- this: Maybe<R>
- op: ((value) => R2)
  - - (value): R2
    - Parameters
      value: R
      Returns R2
Returns Maybe<R2>
- Defined in maybe.ts:253

matchChain

matchChain<R2, R3>(this, op): Just<R3>
Maybe patter matching composition function

Applied to 'just value' returns 'op.just(value)' Applied to 'nothing' returns op.nothing()
Type Parameters
- R2
  just transformer function result's underlying type
- R3 = R2
  nothing transformer function result's underlying type
Parameters
- this: Nothing<R>
- op: {
  just: ((value) => Just<R2>);
  nothing: (() => Just<R3>);
  }
  - just: ((value) => Just<R2>)
    transformer to be invoked with underlying value in case of just
    - (value): Just<R2>
      transformer to be invoked with underlying value in case of just
      
      Parameters
      value: R
      Returns Just<R2>
  - nothing: (() => Just<R3>)
    transformer to be invoked in case of nothing
    - (): Just<R3>
      transformer to be invoked in case of nothing
      
      Returns Just<R3>
Returns Just<R3>
'op.just(value)' or 'op.nothing()'
- Defined in maybe.ts:337
matchChain<R2, R3>(this, op): Nothing<never>
Type Parameters
- R2
- R3 = R2
Parameters
- this: Nothing<R>
- op: {
  just: ((value) => Just<R2>);
  nothing: (() => Nothing<R3>);
  }
  - just: ((value) => Just<R2>)
    - (value): Just<R2>
      Parameters
      value: R
      Returns Just<R2>
  - nothing: (() => Nothing<R3>)
    - (): Nothing<R3>
      Returns Nothing<R3>
Returns Nothing<never>
- Defined in maybe.ts:338
matchChain<R2, R3>(this, op): Just<R3>
Type Parameters
- R2
- R3 = R2
Parameters
- this: Nothing<R>
- op: {
  just: ((value) => Nothing<R2>);
  nothing: (() => Just<R3>);
  }
  - just: ((value) => Nothing<R2>)
    - (value): Nothing<R2>
      Parameters
      value: R
      Returns Nothing<R2>
  - nothing: (() => Just<R3>)
    - (): Just<R3>
      Returns Just<R3>
Returns Just<R3>
- Defined in maybe.ts:339
matchChain<R2, R3>(this, op): Nothing<never>
Type Parameters
- R2
- R3 = R2
Parameters
- this: Nothing<R>
- op: {
  just: ((value) => Nothing<R2>);
  nothing: (() => Nothing<R3>);
  }
  - just: ((value) => Nothing<R2>)
    - (value): Nothing<R2>
      Parameters
      value: R
      Returns Nothing<R2>
  - nothing: (() => Nothing<R3>)
    - (): Nothing<R3>
      Returns Nothing<R3>
Returns Nothing<never>
- Defined in maybe.ts:340
matchChain<R2, R3>(this, op): Maybe<R3>
Type Parameters
- R2
- R3 = R2
Parameters
- this: Nothing<R>
- op: {
  just: ((value) => Just<R2>);
  nothing: (() => Maybe<R3>);
  }
  - just: ((value) => Just<R2>)
    - (value): Just<R2>
      Parameters
      value: R
      Returns Just<R2>
  - nothing: (() => Maybe<R3>)
    - (): Maybe<R3>
      Returns Maybe<R3>
Returns Maybe<R3>
- Defined in maybe.ts:341
matchChain<R2, R3>(this, op): Maybe<R3>
Type Parameters
- R2
- R3 = R2
Parameters
- this: Nothing<R>
- op: {
  just: ((value) => Nothing<R2>);
  nothing: (() => Maybe<R3>);
  }
  - just: ((value) => Nothing<R2>)
    - (value): Nothing<R2>
      Parameters
      value: R
      Returns Nothing<R2>
  - nothing: (() => Maybe<R3>)
    - (): Maybe<R3>
      Returns Maybe<R3>
Returns Maybe<R3>
- Defined in maybe.ts:342
matchChain<R2, R3>(this, op): Just<R3>
Type Parameters
- R2
- R3 = R2
Parameters
- this: Nothing<R>
- op: {
  just: ((value) => Maybe<R2>);
  nothing: (() => Just<R3>);
  }
  - just: ((value) => Maybe<R2>)
    - (value): Maybe<R2>
      Parameters
      value: R
      Returns Maybe<R2>
  - nothing: (() => Just<R3>)
    - (): Just<R3>
      Returns Just<R3>
Returns Just<R3>
- Defined in maybe.ts:343
matchChain<R2, R3>(this, op): Nothing<never>
Type Parameters
- R2
- R3 = R2
Parameters
- this: Nothing<R>
- op: {
  just: ((value) => Maybe<R2>);
  nothing: (() => Nothing<R3>);
  }
  - just: ((value) => Maybe<R2>)
    - (value): Maybe<R2>
      Parameters
      value: R
      Returns Maybe<R2>
  - nothing: (() => Nothing<R3>)
    - (): Nothing<R3>
      Returns Nothing<R3>
Returns Nothing<never>
- Defined in maybe.ts:344
matchChain<R2, R3>(this, op): Maybe<R3>
Type Parameters
- R2
- R3 = R2
Parameters
- this: Nothing<R>
- op: {
  just: ((value) => Maybe<R2>);
  nothing: (() => Maybe<R3>);
  }
  - just: ((value) => Maybe<R2>)
    - (value): Maybe<R2>
      Parameters
      value: R
      Returns Maybe<R2>
  - nothing: (() => Maybe<R3>)
    - (): Maybe<R3>
      Returns Maybe<R3>
Returns Maybe<R3>
- Defined in maybe.ts:345
matchChain<R2, R3>(this, op): Just<R2 | R3>
Type Parameters
- R2
- R3 = R2
Parameters
- this: Maybe<R>
- op: {
  just: ((value) => Just<R2>);
  nothing: (() => Just<R3>);
  }
  - just: ((value) => Just<R2>)
    - (value): Just<R2>
      Parameters
      value: R
      Returns Just<R2>
  - nothing: (() => Just<R3>)
    - (): Just<R3>
      Returns Just<R3>
Returns Just<R2 | R3>
- Defined in maybe.ts:347
matchChain<R2, R3>(this, op): Maybe<R2>
Type Parameters
- R2
- R3 = R2
Parameters
- this: Maybe<R>
- op: {
  just: ((value) => Just<R2>);
  nothing: (() => Nothing<R3>);
  }
  - just: ((value) => Just<R2>)
    - (value): Just<R2>
      Parameters
      value: R
      Returns Just<R2>
  - nothing: (() => Nothing<R3>)
    - (): Nothing<R3>
      Returns Nothing<R3>
Returns Maybe<R2>
- Defined in maybe.ts:348
matchChain<R2, R3>(this, op): Maybe<R3>
Type Parameters
- R2
- R3 = R2
Parameters
- this: Maybe<R>
- op: {
  just: ((value) => Nothing<R2>);
  nothing: (() => Just<R3>);
  }
  - just: ((value) => Nothing<R2>)
    - (value): Nothing<R2>
      Parameters
      value: R
      Returns Nothing<R2>
  - nothing: (() => Just<R3>)
    - (): Just<R3>
      Returns Just<R3>
Returns Maybe<R3>
- Defined in maybe.ts:349
matchChain<R2, R3>(this, op): Nothing<never>
Type Parameters
- R2
- R3 = R2
Parameters
- this: Maybe<R>
- op: {
  just: ((value) => Nothing<R2>);
  nothing: (() => Nothing<R3>);
  }
  - just: ((value) => Nothing<R2>)
    - (value): Nothing<R2>
      Parameters
      value: R
      Returns Nothing<R2>
  - nothing: (() => Nothing<R3>)
    - (): Nothing<R3>
      Returns Nothing<R3>
Returns Nothing<never>
- Defined in maybe.ts:350
matchChain<R2, R3>(this, op): Maybe<R2 | R3>
Type Parameters
- R2
- R3 = R2
Parameters
- this: Maybe<R>
- op: {
  just: ((value) => Just<R2>);
  nothing: (() => Maybe<R3>);
  }
  - just: ((value) => Just<R2>)
    - (value): Just<R2>
      Parameters
      value: R
      Returns Just<R2>
  - nothing: (() => Maybe<R3>)
    - (): Maybe<R3>
      Returns Maybe<R3>
Returns Maybe<R2 | R3>
- Defined in maybe.ts:351
matchChain<R2, R3>(this, op): Maybe<R3>
Type Parameters
- R2
- R3 = R2
Parameters
- this: Maybe<R>
- op: {
  just: ((value) => Nothing<R2>);
  nothing: (() => Maybe<R3>);
  }
  - just: ((value) => Nothing<R2>)
    - (value): Nothing<R2>
      Parameters
      value: R
      Returns Nothing<R2>
  - nothing: (() => Maybe<R3>)
    - (): Maybe<R3>
      Returns Maybe<R3>
Returns Maybe<R3>
- Defined in maybe.ts:352
matchChain<R2, R3>(this, op): Maybe<R2 | R3>
Type Parameters
- R2
- R3 = R2
Parameters
- this: Maybe<R>
- op: {
  just: ((value) => Maybe<R2>);
  nothing: (() => Just<R3>);
  }
  - just: ((value) => Maybe<R2>)
    - (value): Maybe<R2>
      Parameters
      value: R
      Returns Maybe<R2>
  - nothing: (() => Just<R3>)
    - (): Just<R3>
      Returns Just<R3>
Returns Maybe<R2 | R3>
- Defined in maybe.ts:353
matchChain<R2, R3>(this, op): Maybe<R2>
Type Parameters
- R2
- R3 = R2
Parameters
- this: Maybe<R>
- op: {
  just: ((value) => Maybe<R2>);
  nothing: (() => Nothing<R3>);
  }
  - just: ((value) => Maybe<R2>)
    - (value): Maybe<R2>
      Parameters
      value: R
      Returns Maybe<R2>
  - nothing: (() => Nothing<R3>)
    - (): Nothing<R3>
      Returns Nothing<R3>
Returns Maybe<R2>
- Defined in maybe.ts:354
matchChain<R2, R3>(this, op): Maybe<R2 | R3>
Type Parameters
- R2
- R3 = R2
Parameters
- this: Maybe<R>
- op: {
  just: ((value) => Maybe<R2>);
  nothing: (() => Maybe<R3>);
  }
  - just: ((value) => Maybe<R2>)
    - (value): Maybe<R2>
      Parameters
      value: R
      Returns Maybe<R2>
  - nothing: (() => Maybe<R3>)
    - (): Maybe<R3>
      Returns Maybe<R3>
Returns Maybe<R2 | R3>
- Defined in maybe.ts:355

matchMap

matchMap<R2, R3>(this, op): Just<R3>
Maybe patter matching transformer function

Applied to 'just value' returns 'just op.just(value)' Applied to 'nothing' returns 'just op.nothing()'
Type Parameters
- R2
  just transformer function's return type
- R3 = R2
  nothing transformer function's return type
Parameters
- this: Nothing<R>
- op: {
  just: ((value) => R2);
  nothing: (() => R3);
  }
  - just: ((value) => R2)
    transformer to be invoked with underlying value in case of just
    - (value): R2
      transformer to be invoked with underlying value in case of just
      
      Parameters
      value: R
      Returns R2
  - nothing: (() => R3)
    transformer to be invoked in case of nothing
    - (): R3
      transformer to be invoked in case of nothing
      
      Returns R3
Returns Just<R3>
'just op.just(value)' or 'just op.nothing()'
- Defined in maybe.ts:282
matchMap<R2, R3>(this, op): Just<R2 | R3>
Type Parameters
- R2
- R3 = R2
Parameters
- this: Maybe<R>
- op: {
  just: ((value) => R2);
  nothing: (() => R3);
  }
  - just: ((value) => R2)
    - (value): R2
      Parameters
      value: R
      Returns R2
  - nothing: (() => R3)
    - (): R3
      Returns R3
Returns Just<R2 | R3>
- Defined in maybe.ts:284

matchTap

matchTap(op): this
Maybe patter matching peeker function

Applied to 'just value' returns self invoking op.just(value) in process Applied to 'nothing' returns self invoking op.nothing() in process
Parameters
- op: {
  just: ((value) => void);
  nothing: (() => void);
  }
  - just: ((value) => void)
    function to be invoked with underlying value in case of just
    - (value): void
      function to be invoked with underlying value in case of just
      
      Parameters
      value: R
      Returns void
  - nothing: (() => void)
    function to be invoked in case of nothing
    - (): void
      function to be invoked in case of nothing
      
      Returns void
Returns this
self
- Defined in maybe.ts:238

orChain

orChain<R2>(this, op): Just<R2>
Maybe fallback composition function

Applied to 'just value' returns self witjout invoking composition function Applied to 'nothing' returns op()
Type Parameters
- R2
  transformer function result's underlying type
Parameters
- this: Nothing<R>
- op: (() => Just<R2>)
  transformer to be invoked
  - - (): Just<R2>
    - Returns Just<R2>
Returns Just<R2>
'just value' or 'op()'
- Defined in maybe.ts:316
orChain<R2>(this, op): Nothing<never>
Type Parameters
- R2
Parameters
- this: Nothing<R>
- op: (() => Nothing<R2>)
  - - (): Nothing<R2>
    - Returns Nothing<R2>
Returns Nothing<never>
- Defined in maybe.ts:317
orChain<R2>(this, op): Maybe<R2>
Type Parameters
- R2
Parameters
- this: Nothing<R>
- op: (() => Maybe<R2>)
  - - (): Maybe<R2>
    - Returns Maybe<R2>
Returns Maybe<R2>
- Defined in maybe.ts:318
orChain<R2>(this, op): Just<R | R2>
Type Parameters
- R2
Parameters
- this: Maybe<R>
- op: (() => Just<R2>)
  - - (): Just<R2>
    - Returns Just<R2>
Returns Just<R | R2>
- Defined in maybe.ts:320
orChain<R2>(this, op): Maybe<R>
Type Parameters
- R2
Parameters
- this: Maybe<R>
- op: (() => Nothing<R2>)
  - - (): Nothing<R2>
    - Returns Nothing<R2>
Returns Maybe<R>
- Defined in maybe.ts:321
orChain<R2>(this, op): Maybe<R | R2>
Type Parameters
- R2
Parameters
- this: Maybe<R>
- op: (() => Maybe<R2>)
  - - (): Maybe<R2>
    - Returns Maybe<R2>
Returns Maybe<R | R2>
- Defined in maybe.ts:322

orMap

orMap<R2>(this, op): Just<R2>
Maybe fallback transformer function

Applied to 'just value' returns self without invoking transformer Applied to 'nothing' returns 'just op()'
Type Parameters
- R2
Parameters
- this: Nothing<R>
- op: (() => R2)
  function to be invoked
  - - (): R2
    - Returns R2
Returns Just<R2>
'just value' or 'just op()'
- Defined in maybe.ts:265
orMap<R2>(this, op): Just<R | R2>
Type Parameters
- R2
Parameters
- this: Maybe<R>
- op: (() => R2)
  - - (): R2
    - Returns R2
Returns Just<R | R2>
- Defined in maybe.ts:267

orTap

orTap(op): this
Maybe fallback peeker function

Applied to 'just value' returns self without invoking callback Applied to 'nothing' returns self invoking op() in process
Parameters
- op: (() => void)
  function to be invoked
  - - (): void
    - Returns void
Returns this
self
- Defined in maybe.ts:226

tap

tap(op): this
Maybe peeker function

Applied to 'just value' returns self invoking op(value) in process Applied to 'nothing' returns self without invoking callback
Parameters
- op: ((value) => void)
  function to be invoked with underlying value
  - - (value): void
    - Parameters
      value: R
      Returns void
Returns this
self
- Defined in maybe.ts:215

Interface Nothing<R>

Type Parameters

R

Index

Properties

Methods

Properties

generator

Returns

Methods

chain

Type Parameters

R2

Parameters

this: Nothing<R>

op: ((value) => Just<R2>)

Parameters

value: R

Returns Just<R2>

Returns Nothing<never>

Type Parameters

R2

Parameters

this: Nothing<R>

op: ((value) => Nothing<R2>)

Parameters

value: R

Returns Nothing<R2>

Returns Nothing<never>

Type Parameters

R2

Parameters

this: Nothing<R>

op: ((value) => Maybe<R2>)

Parameters

value: R

Returns Maybe<R2>

Returns Nothing<never>

Type Parameters

R2

Parameters

this: Maybe<R>

op: ((value) => Just<R2>)

Parameters

value: R

Returns Just<R2>

Returns Maybe<R2>

Type Parameters

R2

Parameters

this: Maybe<R>

op: ((value) => Nothing<R2>)

Parameters

value: R

Returns Nothing<R2>

Returns Nothing<never>

Type Parameters

R2

Parameters

this: Maybe<R>

op: ((value) => Maybe<R2>)

Parameters

value: R

Returns Maybe<R2>

Returns Maybe<R2>

isJust

Returns this is Just<R>

Example

isNothing

Returns this is Nothing<R>

Example

map

Type Parameters

R2

Parameters

this: Nothing<R>

op: ((value) => R2)

Parameters

value: R

Returns R2

op: {
just: ((value) => Just<R2>);
nothing: (() => Just<R3>);
}

op: {
just: ((value) => Just<R2>);
nothing: (() => Nothing<R3>);
}

op: {
just: ((value) => Nothing<R2>);
nothing: (() => Just<R3>);
}

op: {
just: ((value) => Nothing<R2>);
nothing: (() => Nothing<R3>);
}

op: {
just: ((value) => Just<R2>);
nothing: (() => Maybe<R3>);
}