Interface Left<R, L>

Left (erroneous) value of type L

Either data type specialization representing an erroneous value

Remplate

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

interface Left<R, L> {
    generator: EitherGeneratorFunction<[], R, Left<R, L>, R>;
    left: L;
    chain<R2, L2>(this, op): Left<never, L>;
    chain<R2, L2>(this, op): Left<never, L>;
    chain<R2, L2>(this, op): Left<never, L>;
    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): Left<never, L>;
    map<R2>(this, op): Either<R2, L>;
    matchChain<R2, L2, R3, L3>(this, op): Right<R3, never>;
    matchChain<R2, L2, R3, L3>(this, op): Right<R3, never>;
    matchChain<R2, L2, R3, L3>(this, op): Left<never, L3>;
    matchChain<R2, L2, R3, L3>(this, op): Left<never, L3>;
    matchChain<R2, L2, R3, L3>(this, op): Right<R3, never>;
    matchChain<R2, L2, R3, L3>(this, op): Left<never, L3>;
    matchChain<R2, L2, R3, L3>(this, op): Either<R3, L3>;
    matchChain<R2, L2, R3, L3>(this, op): Either<R3, L3>;
    matchChain<R2, L2, R3, L3>(this, op): Either<R3, L3>;
    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<R3, never>;
    matchMap<R2, R3>(this, op): Right<R2 | R3, never>;
    matchTap(op): this;
    orChain<R2, L2>(this, op): Right<R2, never>;
    orChain<R2, L2>(this, op): Left<never, L2>;
    orChain<R2, L2>(this, op): Either<R2, L2>;
    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<R2, never>;
    orMap<R2>(this, op): Right<R | R2, never>;
    orTap(op): this;
    tap(op): this;
}

Type Parameters

R
L
underlying error type

Index

Properties

generator left

Methods

chain isLeft isRight map matchChain matchMap matchTap orChain orMap orTap tap

Properties

generator

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

Wrap Maybe to singleton generator

Userful in order to avoid ambiguous yied types

Returns

generator of Maybe wrapping this

`Readonly` left

left: L

Methods

chain

chain<R2, L2>(this, op): Left<never, L>
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: Left<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 Left<never, L>
'op(value)' or 'left error'
- Defined in either.ts:308
chain<R2, L2>(this, op): Left<never, L>
Type Parameters
- R2
- L2
Parameters
- this: Left<R, L>
- op: ((value) => Left<R2, L2>)
  - - (value): Left<R2, L2>
    - Parameters
      value: R
      Returns Left<R2, L2>
Returns Left<never, L>
- Defined in either.ts:309
chain<R2, L2>(this, op): Left<never, L>
Type Parameters
- R2
- L2
Parameters
- this: Left<R, L>
- op: ((value) => Either<R2, L2>)
  - - (value): Either<R2, L2>
    - Parameters
      value: R
      Returns Either<R2, L2>
Returns Left<never, L>
- Defined in either.ts:310
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:312
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:313
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:314

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

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

map

map<R2>(this, op): Left<never, L>
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: Left<R, L>
- op: ((value) => R2)
  transformer to be invoked with underlying value
  - - (value): R2
    - Parameters
      value: R
      Returns R2
Returns Left<never, L>
'right op(value)' or 'left error'
- Defined in either.ts:261
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:263

matchChain

matchChain<R2, L2, R3, L3>(this, op): Right<R3, 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: Left<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<R3, never>
'op(value)' or 'op(error)'
- Defined in either.ts:351
matchChain<R2, L2, R3, L3>(this, op): Right<R3, never>
Type Parameters
- R2
- L2
- R3 = R2
- L3 = L2
Parameters
- this: Left<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 Right<R3, never>
- Defined in either.ts:352
matchChain<R2, L2, R3, L3>(this, op): Left<never, L3>
Type Parameters
- R2
- L2
- R3 = R2
- L3 = L2
Parameters
- this: Left<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 Left<never, L3>
- Defined in either.ts:353
matchChain<R2, L2, R3, L3>(this, op): Left<never, L3>
Type Parameters
- R2
- L2
- R3 = R2
- L3 = L2
Parameters
- this: Left<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, L3>
- Defined in either.ts:354
matchChain<R2, L2, R3, L3>(this, op): Right<R3, never>
Type Parameters
- R2
- L2
- R3 = R2
- L3 = L2
Parameters
- this: Left<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 Right<R3, never>
- Defined in either.ts:355
matchChain<R2, L2, R3, L3>(this, op): Left<never, L3>
Type Parameters
- R2
- L2
- R3 = R2
- L3 = L2
Parameters
- this: Left<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 Left<never, L3>
- Defined in either.ts:356
matchChain<R2, L2, R3, L3>(this, op): Either<R3, L3>
Type Parameters
- R2
- L2
- R3 = R2
- L3 = L2
Parameters
- this: Left<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<R3, L3>
- Defined in either.ts:357
matchChain<R2, L2, R3, L3>(this, op): Either<R3, L3>
Type Parameters
- R2
- L2
- R3 = R2
- L3 = L2
Parameters
- this: Left<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, L3>
- Defined in either.ts:358
matchChain<R2, L2, R3, L3>(this, op): Either<R3, L3>
Type Parameters
- R2
- L2
- R3 = R2
- L3 = L2
Parameters
- this: Left<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<R3, L3>
- Defined in either.ts:359
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:361
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:362
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:363
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:364
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:365
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:366
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:367
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:368
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:369

matchMap

matchMap<R2, R3>(this, op): Right<R3, 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: Left<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<R3, never>
'right op.right(value)' or 'right op.left(error)'
- Defined in either.ts:292
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:294

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

orChain

orChain<R2, L2>(this, op): Right<R2, never>
Either fallback 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: Left<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<R2, never>
'right value' or 'op(error)'
- Defined in either.ts:328
orChain<R2, L2>(this, op): Left<never, L2>
Type Parameters
- R2
- L2
Parameters
- this: Left<R, L>
- op: ((error) => Left<R2, L2>)
  - - (error): Left<R2, L2>
    - Parameters
      error: L
      Returns Left<R2, L2>
Returns Left<never, L2>
- Defined in either.ts:329
orChain<R2, L2>(this, op): Either<R2, L2>
Type Parameters
- R2
- L2
Parameters
- this: Left<R, L>
- op: ((error) => Either<R2, L2>)
  - - (error): Either<R2, L2>
    - Parameters
      error: L
      Returns Either<R2, L2>
Returns Either<R2, L2>
- Defined in either.ts:330
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:332
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:333
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:334

orMap

orMap<R2>(this, op): Right<R2, 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: Left<R, L>
- op: ((error) => R2)
  transformer to be invoked with underlying error
  - - (error): R2
    - Parameters
      error: L
      Returns R2
Returns Right<R2, never>
'right value' or 'right op(error)'
- Defined in either.ts:275
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:277

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 value
  - - (error): void
    - Parameters
      error: L
      Returns void
Returns this
self
- Defined in either.ts:236

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

Interface Left<R, L>

Remplate

Type Parameters

R

L

Index

Properties

Methods

Properties

generator

Returns

Readonly left

Methods

chain

Type Parameters

R2

L2

Parameters

this: Left<R, L>

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

Parameters

value: R

Returns Right<R2, L2>

Returns Left<never, L>

Type Parameters

R2

L2

Parameters

this: Left<R, L>

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

Parameters

value: R

Returns Left<R2, L2>

Returns Left<never, L>

Type Parameters

R2

L2

Parameters

this: Left<R, L>

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

Parameters

value: R

Returns Either<R2, L2>

Returns Left<never, L>

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

`Readonly` left

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