Interface Right<R, L>

Right (correct) value of type R

Either data type specialization representing a correct value

interface Right<R, L> {
    generator: EitherGeneratorFunction<[], R, Right<R, L>, R>;
    right: R;
    chain<R2, L2>(this, op): Right<R2, never>;
    chain<R2, L2>(this, op): Left<never, L2>;
    chain<R2, L2>(this, op): Either<R2, L2>;
    chain<R2, L2>(this, op): Either<R2, L>;
    chain<R2, L2>(this, op): Left<never, L | L2>;
    chain<R2, L2>(this, op): Either<R2, L | L2>;
    isLeft(): this is Left<R, L>;
    isRight(): this is Right<R, L>;
    map<R2>(this, op): Right<R2, never>;
    map<R2>(this, op): Either<R2, L>;
    matchChain<R2, L2, R3, L3>(this, op): Right<R2, never>;
    matchChain<R2, L2, R3, L3>(this, op): Left<never, L2>;
    matchChain<R2, L2, R3, L3>(this, op): Right<R2, never>;
    matchChain<R2, L2, R3, L3>(this, op): Left<never, L2>;
    matchChain<R2, L2, R3, L3>(this, op): Either<R2, L2>;
    matchChain<R2, L2, R3, L3>(this, op): Either<R2, L2>;
    matchChain<R2, L2, R3, L3>(this, op): Right<R2, never>;
    matchChain<R2, L2, R3, L3>(this, op): Left<never, L2>;
    matchChain<R2, L2, R3, L3>(this, op): Either<R2, L2>;
    matchChain<R2, L2, R3, L3>(this, op): Right<R2 | R3, never>;
    matchChain<R2, L2, R3, L3>(this, op): Either<R3, L2>;
    matchChain<R2, L2, R3, L3>(this, op): Either<R2, L3>;
    matchChain<R2, L2, R3, L3>(this, op): Left<never, L2 | L3>;
    matchChain<R2, L2, R3, L3>(this, op): Either<R2 | R3, L2>;
    matchChain<R2, L2, R3, L3>(this, op): Either<R2, L2 | L3>;
    matchChain<R2, L2, R3, L3>(this, op): Either<R2 | R3, L3>;
    matchChain<R2, L2, R3, L3>(this, op): Either<R3, L2 | L3>;
    matchChain<R2, L2, R3, L3>(this, op): Either<R2 | R3, L2 | L3>;
    matchMap<R2, R3>(this, op): Right<R2, never>;
    matchMap<R2, R3>(this, op): Right<R2 | R3, never>;
    matchTap(op): this;
    orChain<R2, L2>(this, op): Right<R, never>;
    orChain<R2, L2>(this, op): Right<R, never>;
    orChain<R2, L2>(this, op): Right<R, never>;
    orChain<R2, L2>(this, op): Right<R | R2, never>;
    orChain<R2, L2>(this, op): Either<R, L2>;
    orChain<R2, L2>(this, op): Either<R | R2, L2>;
    orMap<R2>(this, op): Right<R, never>;
    orMap<R2>(this, op): Right<R | R2, never>;
    orTap(op): this;
    tap(op): this;
}

Type Parameters

R
underlying value type
L
underlying error type (needed for type merging, in fact alwas considered to be never)

Index

Properties

generator right

Methods

chain isLeft isRight map matchChain matchMap matchTap orChain orMap orTap tap

Properties

generator

generator: EitherGeneratorFunction<[], R, Right<R, L>, R>

Wrap Maybe to singleton generator

Userful in order to avoid ambiguous yied types

Returns

generator of Maybe wrapping this

`Readonly` right

right: R

Methods

chain

chain<R2, L2>(this, op): Right<R2, never>
Either composition function

Applied to 'right value' returns 'op(value)' Applied to 'left error' returns self without invoking composition function
Type Parameters
- R2
  transformer function result's underlying value type
- L2
  transformer function result's underlying error type
Parameters
- this: Right<R, L>
- op: ((value) => Right<R2, L2>)
  transformer to be invoked with underlying value
  - - (value): Right<R2, L2>
    - Parameters
      value: R
      Returns Right<R2, L2>
Returns Right<R2, never>
'op(value)' or 'left error'
- Defined in either.ts:104
chain<R2, L2>(this, op): Left<never, L2>
Type Parameters
- R2
- L2
Parameters
- this: Right<R, L>
- op: ((value) => Left<R2, L2>)
  - - (value): Left<R2, L2>
    - Parameters
      value: R
      Returns Left<R2, L2>
Returns Left<never, L2>
- Defined in either.ts:105
chain<R2, L2>(this, op): Either<R2, L2>
Type Parameters
- R2
- L2
Parameters
- this: Right<R, L>
- op: ((value) => Either<R2, L2>)
  - - (value): Either<R2, L2>
    - Parameters
      value: R
      Returns Either<R2, L2>
Returns Either<R2, L2>
- Defined in either.ts:106
chain<R2, L2>(this, op): Either<R2, L>
Type Parameters
- R2
- L2
Parameters
- this: Either<R, L>
- op: ((value) => Right<R2, L2>)
  - - (value): Right<R2, L2>
    - Parameters
      value: R
      Returns Right<R2, L2>
Returns Either<R2, L>
- Defined in either.ts:108
chain<R2, L2>(this, op): Left<never, L | L2>
Type Parameters
- R2
- L2
Parameters
- this: Either<R, L>
- op: ((value) => Left<R2, L2>)
  - - (value): Left<R2, L2>
    - Parameters
      value: R
      Returns Left<R2, L2>
Returns Left<never, L | L2>
- Defined in either.ts:109
chain<R2, L2>(this, op): Either<R2, L | L2>
Type Parameters
- R2
- L2
Parameters
- this: Either<R, L>
- op: ((value) => Either<R2, L2>)
  - - (value): Either<R2, L2>
    - Parameters
      value: R
      Returns Either<R2, L2>
Returns Either<R2, L | L2>
- Defined in either.ts:110

isLeft

isLeft(): this is Left<R, L>
Either type guard for 'left'

Returns this is Left<R, L>
'true' in case this is 'left error' (and resolves type to be 'left')
Example
```
if (either.isLeft()) {
  console.error(either.left)
}
```
- Defined in either.ts:193

isRight

isRight(): this is Right<R, L>
Either type guard for 'right'

Returns this is Right<R, L>
'true' in case this is 'right value' (and resolves type to be 'right')
Example
```
if (either.isRight()) {
  console.log(either.right)
}
```
- Defined in either.ts:179

map

map<R2>(this, op): Right<R2, never>
Either transformer function

Applied to 'right value' returns 'right op(value)' Applied to 'left error' returns self without invoking transformer
Type Parameters
- R2
  transformer function's return type
Parameters
- this: Right<R, L>
- op: ((value) => R2)
  transformer to be invoked with underlying value
  - - (value): R2
    - Parameters
      value: R
      Returns R2
Returns Right<R2, never>
'right op(value)' or 'left error'
- Defined in either.ts:57
map<R2>(this, op): Either<R2, L>
Type Parameters
- R2
Parameters
- this: Either<R, L>
- op: ((value) => R2)
  - - (value): R2
    - Parameters
      value: R
      Returns R2
Returns Either<R2, L>
- Defined in either.ts:59

matchChain

matchChain<R2, L2, R3, L3>(this, op): Right<R2, never>
Either pattern matching composition function

Applied to 'right value' returns 'op.right(value)' Applied to 'left error' returns 'op.left(error)'
Type Parameters
- R2
  right transformer function result's underlying value type
- L2
  right transformer function result's underlying error type
- R3 = R2
  left transformer function result's underlying value type
- L3 = L2
  left transformer function result's underlying error type
Parameters
- this: Right<R, L>
- op: {
  left: ((error) => Right<R3, L3>);
  right: ((value) => Right<R2, L2>);
  }
  - left: ((error) => Right<R3, L3>)
    transformer to be invoked with underlying error in case of 'left'
    - (error): Right<R3, L3>
      transformer to be invoked with underlying error in case of 'left'
      
      Parameters
      error: L
      Returns Right<R3, L3>
  - right: ((value) => Right<R2, L2>)
    transformer to be invoked with underlying value in case of 'right'
    - (value): Right<R2, L2>
      transformer to be invoked with underlying value in case of 'right'
      
      Parameters
      value: R
      Returns Right<R2, L2>
Returns Right<R2, never>
'op(value)' or 'op(error)'
- Defined in either.ts:147
matchChain<R2, L2, R3, L3>(this, op): Left<never, L2>
Type Parameters
- R2
- L2
- R3 = R2
- L3 = L2
Parameters
- this: Right<R, L>
- op: {
  left: ((error) => Right<R3, L3>);
  right: ((value) => Left<R2, L2>);
  }
  - left: ((error) => Right<R3, L3>)
    - (error): Right<R3, L3>
      Parameters
      error: L
      Returns Right<R3, L3>
  - right: ((value) => Left<R2, L2>)
    - (value): Left<R2, L2>
      Parameters
      value: R
      Returns Left<R2, L2>
Returns Left<never, L2>
- Defined in either.ts:148
matchChain<R2, L2, R3, L3>(this, op): Right<R2, never>
Type Parameters
- R2
- L2
- R3 = R2
- L3 = L2
Parameters
- this: Right<R, L>
- op: {
  left: ((error) => Left<R3, L3>);
  right: ((value) => Right<R2, L2>);
  }
  - left: ((error) => Left<R3, L3>)
    - (error): Left<R3, L3>
      Parameters
      error: L
      Returns Left<R3, L3>
  - right: ((value) => Right<R2, L2>)
    - (value): Right<R2, L2>
      Parameters
      value: R
      Returns Right<R2, L2>
Returns Right<R2, never>
- Defined in either.ts:149
matchChain<R2, L2, R3, L3>(this, op): Left<never, L2>
Type Parameters
- R2
- L2
- R3 = R2
- L3 = L2
Parameters
- this: Right<R, L>
- op: {
  left: ((error) => Left<R3, L3>);
  right: ((value) => Left<R2, L2>);
  }
  - left: ((error) => Left<R3, L3>)
    - (error): Left<R3, L3>
      Parameters
      error: L
      Returns Left<R3, L3>
  - right: ((value) => Left<R2, L2>)
    - (value): Left<R2, L2>
      Parameters
      value: R
      Returns Left<R2, L2>
Returns Left<never, L2>
- Defined in either.ts:150
matchChain<R2, L2, R3, L3>(this, op): Either<R2, L2>
Type Parameters
- R2
- L2
- R3 = R2
- L3 = L2
Parameters
- this: Right<R, L>
- op: {
  left: ((error) => Right<R3, L3>);
  right: ((value) => Either<R2, L2>);
  }
  - left: ((error) => Right<R3, L3>)
    - (error): Right<R3, L3>
      Parameters
      error: L
      Returns Right<R3, L3>
  - right: ((value) => Either<R2, L2>)
    - (value): Either<R2, L2>
      Parameters
      value: R
      Returns Either<R2, L2>
Returns Either<R2, L2>
- Defined in either.ts:151
matchChain<R2, L2, R3, L3>(this, op): Either<R2, L2>
Type Parameters
- R2
- L2
- R3 = R2
- L3 = L2
Parameters
- this: Right<R, L>
- op: {
  left: ((error) => Left<R3, L3>);
  right: ((value) => Either<R2, L2>);
  }
  - left: ((error) => Left<R3, L3>)
    - (error): Left<R3, L3>
      Parameters
      error: L
      Returns Left<R3, L3>
  - right: ((value) => Either<R2, L2>)
    - (value): Either<R2, L2>
      Parameters
      value: R
      Returns Either<R2, L2>
Returns Either<R2, L2>
- Defined in either.ts:152
matchChain<R2, L2, R3, L3>(this, op): Right<R2, never>
Type Parameters
- R2
- L2
- R3 = R2
- L3 = L2
Parameters
- this: Right<R, L>
- op: {
  left: ((error) => Either<R3, L3>);
  right: ((value) => Right<R2, L2>);
  }
  - left: ((error) => Either<R3, L3>)
    - (error): Either<R3, L3>
      Parameters
      error: L
      Returns Either<R3, L3>
  - right: ((value) => Right<R2, L2>)
    - (value): Right<R2, L2>
      Parameters
      value: R
      Returns Right<R2, L2>
Returns Right<R2, never>
- Defined in either.ts:153
matchChain<R2, L2, R3, L3>(this, op): Left<never, L2>
Type Parameters
- R2
- L2
- R3 = R2
- L3 = L2
Parameters
- this: Right<R, L>
- op: {
  left: ((error) => Either<R3, L3>);
  right: ((value) => Left<R2, L2>);
  }
  - left: ((error) => Either<R3, L3>)
    - (error): Either<R3, L3>
      Parameters
      error: L
      Returns Either<R3, L3>
  - right: ((value) => Left<R2, L2>)
    - (value): Left<R2, L2>
      Parameters
      value: R
      Returns Left<R2, L2>
Returns Left<never, L2>
- Defined in either.ts:154
matchChain<R2, L2, R3, L3>(this, op): Either<R2, L2>
Type Parameters
- R2
- L2
- R3 = R2
- L3 = L2
Parameters
- this: Right<R, L>
- op: {
  left: ((error) => Either<R3, L3>);
  right: ((value) => Either<R2, L2>);
  }
  - left: ((error) => Either<R3, L3>)
    - (error): Either<R3, L3>
      Parameters
      error: L
      Returns Either<R3, L3>
  - right: ((value) => Either<R2, L2>)
    - (value): Either<R2, L2>
      Parameters
      value: R
      Returns Either<R2, L2>
Returns Either<R2, L2>
- Defined in either.ts:155
matchChain<R2, L2, R3, L3>(this, op): Right<R2 | R3, never>
Type Parameters
- R2
- L2
- R3 = R2
- L3 = L2
Parameters
- this: Either<R, L>
- op: {
  left: ((error) => Right<R3, L3>);
  right: ((value) => Right<R2, L2>);
  }
  - left: ((error) => Right<R3, L3>)
    - (error): Right<R3, L3>
      Parameters
      error: L
      Returns Right<R3, L3>
  - right: ((value) => Right<R2, L2>)
    - (value): Right<R2, L2>
      Parameters
      value: R
      Returns Right<R2, L2>
Returns Right<R2 | R3, never>
- Defined in either.ts:157
matchChain<R2, L2, R3, L3>(this, op): Either<R3, L2>
Type Parameters
- R2
- L2
- R3 = R2
- L3 = L2
Parameters
- this: Either<R, L>
- op: {
  left: ((error) => Right<R3, L3>);
  right: ((value) => Left<R2, L2>);
  }
  - left: ((error) => Right<R3, L3>)
    - (error): Right<R3, L3>
      Parameters
      error: L
      Returns Right<R3, L3>
  - right: ((value) => Left<R2, L2>)
    - (value): Left<R2, L2>
      Parameters
      value: R
      Returns Left<R2, L2>
Returns Either<R3, L2>
- Defined in either.ts:158
matchChain<R2, L2, R3, L3>(this, op): Either<R2, L3>
Type Parameters
- R2
- L2
- R3 = R2
- L3 = L2
Parameters
- this: Either<R, L>
- op: {
  left: ((error) => Left<R3, L3>);
  right: ((value) => Right<R2, L2>);
  }
  - left: ((error) => Left<R3, L3>)
    - (error): Left<R3, L3>
      Parameters
      error: L
      Returns Left<R3, L3>
  - right: ((value) => Right<R2, L2>)
    - (value): Right<R2, L2>
      Parameters
      value: R
      Returns Right<R2, L2>
Returns Either<R2, L3>
- Defined in either.ts:159
matchChain<R2, L2, R3, L3>(this, op): Left<never, L2 | L3>
Type Parameters
- R2
- L2
- R3 = R2
- L3 = L2
Parameters
- this: Either<R, L>
- op: {
  left: ((error) => Left<R3, L3>);
  right: ((value) => Left<R2, L2>);
  }
  - left: ((error) => Left<R3, L3>)
    - (error): Left<R3, L3>
      Parameters
      error: L
      Returns Left<R3, L3>
  - right: ((value) => Left<R2, L2>)
    - (value): Left<R2, L2>
      Parameters
      value: R
      Returns Left<R2, L2>
Returns Left<never, L2 | L3>
- Defined in either.ts:160
matchChain<R2, L2, R3, L3>(this, op): Either<R2 | R3, L2>
Type Parameters
- R2
- L2
- R3 = R2
- L3 = L2
Parameters
- this: Either<R, L>
- op: {
  left: ((error) => Right<R3, L3>);
  right: ((value) => Either<R2, L2>);
  }
  - left: ((error) => Right<R3, L3>)
    - (error): Right<R3, L3>
      Parameters
      error: L
      Returns Right<R3, L3>
  - right: ((value) => Either<R2, L2>)
    - (value): Either<R2, L2>
      Parameters
      value: R
      Returns Either<R2, L2>
Returns Either<R2 | R3, L2>
- Defined in either.ts:161
matchChain<R2, L2, R3, L3>(this, op): Either<R2, L2 | L3>
Type Parameters
- R2
- L2
- R3 = R2
- L3 = L2
Parameters
- this: Either<R, L>
- op: {
  left: ((error) => Left<R3, L3>);
  right: ((value) => Either<R2, L2>);
  }
  - left: ((error) => Left<R3, L3>)
    - (error): Left<R3, L3>
      Parameters
      error: L
      Returns Left<R3, L3>
  - right: ((value) => Either<R2, L2>)
    - (value): Either<R2, L2>
      Parameters
      value: R
      Returns Either<R2, L2>
Returns Either<R2, L2 | L3>
- Defined in either.ts:162
matchChain<R2, L2, R3, L3>(this, op): Either<R2 | R3, L3>
Type Parameters
- R2
- L2
- R3 = R2
- L3 = L2
Parameters
- this: Either<R, L>
- op: {
  left: ((error) => Either<R3, L3>);
  right: ((value) => Right<R2, L2>);
  }
  - left: ((error) => Either<R3, L3>)
    - (error): Either<R3, L3>
      Parameters
      error: L
      Returns Either<R3, L3>
  - right: ((value) => Right<R2, L2>)
    - (value): Right<R2, L2>
      Parameters
      value: R
      Returns Right<R2, L2>
Returns Either<R2 | R3, L3>
- Defined in either.ts:163
matchChain<R2, L2, R3, L3>(this, op): Either<R3, L2 | L3>
Type Parameters
- R2
- L2
- R3 = R2
- L3 = L2
Parameters
- this: Either<R, L>
- op: {
  left: ((error) => Either<R3, L3>);
  right: ((value) => Left<R2, L2>);
  }
  - left: ((error) => Either<R3, L3>)
    - (error): Either<R3, L3>
      Parameters
      error: L
      Returns Either<R3, L3>
  - right: ((value) => Left<R2, L2>)
    - (value): Left<R2, L2>
      Parameters
      value: R
      Returns Left<R2, L2>
Returns Either<R3, L2 | L3>
- Defined in either.ts:164
matchChain<R2, L2, R3, L3>(this, op): Either<R2 | R3, L2 | L3>
Type Parameters
- R2
- L2
- R3 = R2
- L3 = L2
Parameters
- this: Either<R, L>
- op: {
  left: ((error) => Either<R3, L3>);
  right: ((value) => Either<R2, L2>);
  }
  - left: ((error) => Either<R3, L3>)
    - (error): Either<R3, L3>
      Parameters
      error: L
      Returns Either<R3, L3>
  - right: ((value) => Either<R2, L2>)
    - (value): Either<R2, L2>
      Parameters
      value: R
      Returns Either<R2, L2>
Returns Either<R2 | R3, L2 | L3>
- Defined in either.ts:165

matchMap

matchMap<R2, R3>(this, op): Right<R2, never>
Either pattern matching transformer function

Applied to 'right value' returns 'right op.right(value)' Applied to 'left error' returns 'right op.left(error)'
Type Parameters
- R2
  right transformer function's return type
- R3 = R2
  left transformer function's return type
Parameters
- this: Right<R, L>
- op: {
  left: ((error) => R3);
  right: ((value) => R2);
  }
  - left: ((error) => R3)
    transformer to be invoked with underlying error in case of 'left'
    - (error): R3
      transformer to be invoked with underlying error in case of 'left'
      
      Parameters
      error: L
      Returns R3
  - right: ((value) => R2)
    transformer to be invoked with underlying value in case of 'right'
    - (value): R2
      transformer to be invoked with underlying value in case of 'right'
      
      Parameters
      value: R
      Returns R2
Returns Right<R2, never>
'right op.right(value)' or 'right op.left(error)'
- Defined in either.ts:88
matchMap<R2, R3>(this, op): Right<R2 | R3, never>
Type Parameters
- R2
- R3 = R2
Parameters
- this: Either<R, L>
- op: {
  left: ((error) => R3);
  right: ((value) => R2);
  }
  - left: ((error) => R3)
    - (error): R3
      Parameters
      error: L
      Returns R3
  - right: ((value) => R2)
    - (value): R2
      Parameters
      value: R
      Returns R2
Returns Right<R2 | R3, never>
- Defined in either.ts:90

matchTap

matchTap(op): this
Either pattern matching peeker function

Applied to 'right value' returns self invoking op.right(value) in process Applied to 'left error' returns self invoking op.left(error) in process
Parameters
- op: {
  left: ((error) => void);
  right: ((value) => void);
  }
  - left: ((error) => void)
    function to be invoked with underlying error in case of 'left'
    - (error): void
      function to be invoked with underlying error in case of 'left'
      
      Parameters
      error: L
      Returns void
  - right: ((value) => void)
    function to be invoked with underlying value in case of 'right'
    - (value): void
      function to be invoked with underlying value in case of 'right'
      
      Parameters
      value: R
      Returns void
Returns this
self
- Defined in either.ts:44

orChain

orChain<R2, L2>(this, op): Right<R, never>
Either composition function

Applied to 'right value' returns self without invoking composition function Applied to 'left error' returns 'op(error)'
Type Parameters
- R2
  transformer function result's underlying value type
- L2
  transformer function result's underlying error type
Parameters
- this: Right<R, L>
- op: ((error) => Right<R2, L2>)
  transformer to be invoked with underlying value
  - - (error): Right<R2, L2>
    - Parameters
      error: L
      Returns Right<R2, L2>
Returns Right<R, never>
'right value' or 'op(error)'
- Defined in either.ts:124
orChain<R2, L2>(this, op): Right<R, never>
Type Parameters
- R2
- L2
Parameters
- this: Right<R, L>
- op: ((error) => Left<R2, L2>)
  - - (error): Left<R2, L2>
    - Parameters
      error: L
      Returns Left<R2, L2>
Returns Right<R, never>
- Defined in either.ts:125
orChain<R2, L2>(this, op): Right<R, never>
Type Parameters
- R2
- L2
Parameters
- this: Right<R, L>
- op: ((error) => Either<R2, L2>)
  - - (error): Either<R2, L2>
    - Parameters
      error: L
      Returns Either<R2, L2>
Returns Right<R, never>
- Defined in either.ts:126
orChain<R2, L2>(this, op): Right<R | R2, never>
Type Parameters
- R2
- L2
Parameters
- this: Either<R, L>
- op: ((error) => Right<R2, L2>)
  - - (error): Right<R2, L2>
    - Parameters
      error: L
      Returns Right<R2, L2>
Returns Right<R | R2, never>
- Defined in either.ts:128
orChain<R2, L2>(this, op): Either<R, L2>
Type Parameters
- R2
- L2
Parameters
- this: Either<R, L>
- op: ((error) => Left<R2, L2>)
  - - (error): Left<R2, L2>
    - Parameters
      error: L
      Returns Left<R2, L2>
Returns Either<R, L2>
- Defined in either.ts:129
orChain<R2, L2>(this, op): Either<R | R2, L2>
Type Parameters
- R2
- L2
Parameters
- this: Either<R, L>
- op: ((error) => Either<R2, L2>)
  - - (error): Either<R2, L2>
    - Parameters
      error: L
      Returns Either<R2, L2>
Returns Either<R | R2, L2>
- Defined in either.ts:130

orMap

orMap<R2>(this, op): Right<R, never>
Either fallback transformer function

Applied to 'right value' returns self without invoking transformer Applied to 'left error' returns 'right op(error)'
Type Parameters
- R2
Parameters
- this: Right<R, L>
- op: ((error) => R2)
  transformer to be invoked with underlying error
  - - (error): R2
    - Parameters
      error: L
      Returns R2
Returns Right<R, never>
'right value' or 'right op(error)'
- Defined in either.ts:71
orMap<R2>(this, op): Right<R | R2, never>
Type Parameters
- R2
Parameters
- this: Either<R, L>
- op: ((error) => R2)
  - - (error): R2
    - Parameters
      error: L
      Returns R2
Returns Right<R | R2, never>
- Defined in either.ts:73

orTap

orTap(op): this
Either fallback peeker function

Applied to 'right value' returns self without invoking callback Applied to 'left error' returns self invoking op(error) in process
Parameters
- op: ((error) => void)
  function to be invoked with underlying error
  - - (error): void
    - Parameters
      error: L
      Returns void
Returns this
self
- Defined in either.ts:32

tap

tap(op): this
Either peeker function

Applied to 'right value' returns self invoking op(value) in process Applied to 'left error' 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 either.ts:21

Interface Right<R, L>

Type Parameters

R

L

Index

Properties

Methods

Properties

generator

Returns

Readonly right

Methods

chain

Type Parameters

R2

L2

Parameters

this: Right<R, L>

op: ((value) => Right<R2, L2>)

Parameters

value: R

Returns Right<R2, L2>

Returns Right<R2, never>

Type Parameters

R2

L2

Parameters

this: Right<R, L>

op: ((value) => Left<R2, L2>)

Parameters

value: R

Returns Left<R2, L2>

Returns Left<never, L2>

Type Parameters

R2

L2

Parameters

this: Right<R, L>

op: ((value) => Either<R2, L2>)

Parameters

value: R

Returns Either<R2, L2>

Returns Either<R2, L2>

Type Parameters

R2

L2

Parameters

this: Either<R, L>

op: ((value) => Right<R2, L2>)

Parameters

value: R

Returns Right<R2, L2>

Returns Either<R2, L>

Type Parameters

R2

L2

Parameters

this: Either<R, L>

op: ((value) => Left<R2, L2>)

Parameters

value: R

Returns Left<R2, L2>

Returns Left<never, L | L2>

Type Parameters

R2

L2

Parameters

this: Either<R, L>

op: ((value) => Either<R2, L2>)

Parameters

value: R

Returns Either<R2, L2>

Returns Either<R2, L | L2>

isLeft

Returns this is Left<R, L>

Example

isRight

Returns this is Right<R, L>

Example

map

`Readonly` right

op: {
left: ((error) => Right<R3, L3>);
right: ((value) => Right<R2, L2>);
}

op: {
left: ((error) => Right<R3, L3>);
right: ((value) => Left<R2, L2>);
}

op: {
left: ((error) => Left<R3, L3>);
right: ((value) => Right<R2, L2>);
}