Interface Just<R>

Just a value

Maybe data type specialization representing an existing value

interface Just<R> {
    generator: MaybeGeneratorFunction<[], R, Just<R>, R>;
    just: R;
    chain<R2>(this, op): Just<R2>;
    chain<R2>(this, op): Nothing<never>;
    chain<R2>(this, op): Maybe<R2>;
    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): Just<R2>;
    map<R2>(this, op): Maybe<R2>;
    matchChain<R2, R3>(this, op): Just<R2>;
    matchChain<R2, R3>(this, op): Just<R2>;
    matchChain<R2, R3>(this, op): Nothing<never>;
    matchChain<R2, R3>(this, op): Nothing<never>;
    matchChain<R2, R3>(this, op): Just<R2>;
    matchChain<R2, R3>(this, op): Nothing<never>;
    matchChain<R2, R3>(this, op): Maybe<R2>;
    matchChain<R2, R3>(this, op): Maybe<R2>;
    matchChain<R2, R3>(this, op): Maybe<R2>;
    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<R2>;
    matchMap<R2, R3>(this, op): Just<R2 | R3>;
    matchTap(op): this;
    orChain<R2>(this, op): Just<R>;
    orChain<R2>(this, op): Just<R>;
    orChain<R2>(this, op): Just<R>;
    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<R>;
    orMap<R2>(this, op): Just<R | R2>;
    orTap(op): this;
    tap(op): this;
}

Type Parameters

R
underlying value

Index

Properties

generator just

Methods

chain isJust isNothing map matchChain matchMap matchTap orChain orMap orTap tap

Properties

generator

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

Wrap Maybe to singleton generator

Userful in order to avoid ambiguous yied types

Returns

generator of Maybe wrapping this

`Readonly` just

just: R

Methods

chain

chain<R2>(this, op): Just<R2>
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: Just<R>
- op: ((value) => Just<R2>)
  transformer to be invoked with underlying value
  - - (value): Just<R2>
    - Parameters
      value: R
      Returns Just<R2>
Returns Just<R2>
'op(value)' or 'nothing'
- Defined in maybe.ts:102
chain<R2>(this, op): Nothing<never>
Type Parameters
- R2
Parameters
- this: Just<R>
- op: ((value) => Nothing<R2>)
  - - (value): Nothing<R2>
    - Parameters
      value: R
      Returns Nothing<R2>
Returns Nothing<never>
- Defined in maybe.ts:103
chain<R2>(this, op): Maybe<R2>
Type Parameters
- R2
Parameters
- this: Just<R>
- op: ((value) => Maybe<R2>)
  - - (value): Maybe<R2>
    - Parameters
      value: R
      Returns Maybe<R2>
Returns Maybe<R2>
- Defined in maybe.ts:104
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:106
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:107
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:108

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:174

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:188

map

map<R2>(this, op): Just<R2>
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: Just<R>
- op: ((value) => R2)
  transformer to be invoked with underlying value
  - - (value): R2
    - Parameters
      value: R
      Returns R2
Returns Just<R2>
'just op(value)' or 'nothing'
- Defined in maybe.ts:56
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:58

matchChain

matchChain<R2, R3>(this, op): Just<R2>
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: Just<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<R2>
'op.just(value)' or 'op.nothing()'
- Defined in maybe.ts:142
matchChain<R2, R3>(this, op): Just<R2>
Type Parameters
- R2
- R3 = R2
Parameters
- this: Just<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 Just<R2>
- Defined in maybe.ts:143
matchChain<R2, R3>(this, op): Nothing<never>
Type Parameters
- R2
- R3 = R2
Parameters
- this: Just<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 Nothing<never>
- Defined in maybe.ts:144
matchChain<R2, R3>(this, op): Nothing<never>
Type Parameters
- R2
- R3 = R2
Parameters
- this: Just<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:145
matchChain<R2, R3>(this, op): Just<R2>
Type Parameters
- R2
- R3 = R2
Parameters
- this: Just<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 Just<R2>
- Defined in maybe.ts:146
matchChain<R2, R3>(this, op): Nothing<never>
Type Parameters
- R2
- R3 = R2
Parameters
- this: Just<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 Nothing<never>
- Defined in maybe.ts:147
matchChain<R2, R3>(this, op): Maybe<R2>
Type Parameters
- R2
- R3 = R2
Parameters
- this: Just<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>
- Defined in maybe.ts:148
matchChain<R2, R3>(this, op): Maybe<R2>
Type Parameters
- R2
- R3 = R2
Parameters
- this: Just<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:149
matchChain<R2, R3>(this, op): Maybe<R2>
Type Parameters
- R2
- R3 = R2
Parameters
- this: Just<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>
- Defined in maybe.ts:150
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:152
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:153
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:154
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:155
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:156
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:157
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:158
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:159
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:160

matchMap

matchMap<R2, R3>(this, op): Just<R2>
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: Just<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<R2>
'just op.just(value)' or 'just op.nothing()'
- Defined in maybe.ts:87
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:89

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:43

orChain

orChain<R2>(this, op): Just<R>
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: Just<R>
- op: (() => Just<R2>)
  transformer to be invoked
  - - (): Just<R2>
    - Returns Just<R2>
Returns Just<R>
'just value' or 'op()'
- Defined in maybe.ts:121
orChain<R2>(this, op): Just<R>
Type Parameters
- R2
Parameters
- this: Just<R>
- op: (() => Nothing<R2>)
  - - (): Nothing<R2>
    - Returns Nothing<R2>
Returns Just<R>
- Defined in maybe.ts:122
orChain<R2>(this, op): Just<R>
Type Parameters
- R2
Parameters
- this: Just<R>
- op: (() => Maybe<R2>)
  - - (): Maybe<R2>
    - Returns Maybe<R2>
Returns Just<R>
- Defined in maybe.ts:123
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:125
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:126
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:127

orMap

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

Applied to 'just value' returns self without invoking transformer Applied to 'nothing' returns 'just op()'
Type Parameters
- R2
Parameters
- this: Just<R>
- op: (() => R2)
  function to be invoked
  - - (): R2
    - Returns R2
Returns Just<R>
'just value' or 'just op()'
- Defined in maybe.ts:70
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:72

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:31

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:20

Interface Just<R>

Type Parameters

R

Index

Properties

Methods

Properties

generator

Returns

Readonly just

Methods

chain

Type Parameters

R2

Parameters

this: Just<R>

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

Parameters

value: R

Returns Just<R2>

Returns Just<R2>

Type Parameters

R2

Parameters

this: Just<R>

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

Parameters

value: R

Returns Nothing<R2>

Returns Nothing<never>

Type Parameters

R2

Parameters

this: Just<R>

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

Parameters

value: R

Returns Maybe<R2>

Returns Maybe<R2>

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: Just<R>

op: ((value) => R2)

Parameters

value: R

`Readonly` just

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>);
}