t-tasks 1.0.4 → 1.1.1

package/dist/either.d.ts

@@ -1,626 +1,626 @@
-/**
- * Right (correct) value of type R
- *
- * Either data type specialization representing a correct value
- *
- * @template R underlying value type
- * @template L underlying error type (needed for type merging, in fact alwas considered to be never)
- */
-export interface Right<R, L> {
-    readonly right: R;
-    /**
-     * Either peeker function
-     *
-     * Applied to 'right value' returns self invoking op(value) in process
-     * Applied to 'left error' returns self without invoking callback
-     *
-     * @param op function to be invoked with underlying value
-     * @returns self
-     */
-    tap(op: (value: R) => void): 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
-     *
-     * @param op function to be invoked with underlying error
-     * @returns self
-     */
-    orTap(op: (error: L) => void): 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
-     *
-     * @param op.right function to be invoked with underlying value in case of 'right'
-     * @param op.left function to be invoked with underlying error in case of 'left'
-     * @returns self
-     */
-    matchTap(op: {
-        right: (value: R) => void;
-        left: (error: L) => void;
-    }): this;
-    /**
-     * Either transformer function
-     *
-     * Applied to 'right value' returns 'right op(value)'
-     * Applied to 'left error' returns self without invoking transformer
-     *
-     * @template R2 transformer function's return type
-     * @param op transformer to be invoked with underlying value
-     * @returns 'right op(value)' or 'left error'
-     */
-    map<R2>(this: Right<R, L>, op: (value: R) => R2): Right<R2, never>;
-    map<R2>(this: Either<R, L>, op: (value: R) => R2): Either<R2, L>;
-    /**
-     * Either fallback transformer function
-     *
-     * Applied to 'right value' returns self without invoking transformer
-     * Applied to 'left error' returns 'right op(error)'
-     *
-     * @param op transformer to be invoked with underlying error
-     * @returns 'right value' or 'right op(error)'
-     */
-    orMap<R2>(this: Right<R, L>, op: (error: L) => R2): Right<R, never>;
-    orMap<R2>(this: Either<R, L>, op: (error: L) => R2): Right<R | 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)'
-     *
-     * @template R2 right transformer function's return type
-     * @template R3 left transformer function's return type
-     * @param op.right transformer to be invoked with underlying value in case of 'right'
-     * @param op.left transformer to be invoked with underlying error in case of 'left'
-     * @returns 'right op.right(value)' or 'right op.left(error)'
-     */
-    matchMap<R2, R3 = R2>(this: Right<R, L>, op: {
-        right: (value: R) => R2;
-        left: (error: L) => R3;
-    }): Right<R2, never>;
-    matchMap<R2, R3 = R2>(this: Either<R, L>, op: {
-        right: (value: R) => R2;
-        left: (error: L) => R3;
-    }): Right<R2 | R3, never>;
-    /**
-     * Either composition function
-     *
-     * Applied to 'right value' returns 'op(value)'
-     * Applied to 'left error' returns self without invoking composition function
-     *
-     * @template R2 transformer function result's underlying value type
-     * @template L2 transformer function result's underlying error type
-     * @param op transformer to be invoked with underlying value
-     * @returns 'op(value)' or 'left error'
-     */
-    chain<R2, L2>(this: Right<R, L>, op: (value: R) => Right<R2, L2>): Right<R2, never>;
-    chain<R2, L2>(this: Right<R, L>, op: (value: R) => Left<R2, L2>): Left<never, L2>;
-    chain<R2, L2>(this: Right<R, L>, op: (value: R) => Either<R2, L2>): Either<R2, L2>;
-    chain<R2, L2>(this: Either<R, L>, op: (value: R) => Right<R2, L2>): Either<R2, L>;
-    chain<R2, L2>(this: Either<R, L>, op: (value: R) => Left<R2, L2>): Left<never, L | L2>;
-    chain<R2, L2>(this: Either<R, L>, op: (value: R) => Either<R2, L2>): Either<R2, L | L2>;
-    /**
-     * Either composition function
-     *
-     * Applied to 'right value' returns self without invoking composition function
-     * Applied to 'left error' returns 'op(error)'
-     *
-     * @template R2 transformer function result's underlying value type
-     * @template L2 transformer function result's underlying error type
-     * @param op transformer to be invoked with underlying value
-     * @returns 'right value' or 'op(error)'
-     */
-    orChain<R2, L2>(this: Right<R, L>, op: (error: L) => Right<R2, L2>): Right<R, never>;
-    orChain<R2, L2>(this: Right<R, L>, op: (error: L) => Left<R2, L2>): Right<R, never>;
-    orChain<R2, L2>(this: Right<R, L>, op: (error: L) => Either<R2, L2>): Right<R, never>;
-    orChain<R2, L2>(this: Either<R, L>, op: (error: L) => Right<R2, L2>): Right<R | R2, never>;
-    orChain<R2, L2>(this: Either<R, L>, op: (error: L) => Left<R2, L2>): Either<R, L2>;
-    orChain<R2, L2>(this: Either<R, L>, op: (error: L) => Either<R2, L2>): Either<R | R2, L2>;
-    /**
-     * Either pattern matching composition function
-     *
-     * Applied to 'right value' returns 'op.right(value)'
-     * Applied to 'left error' returns 'op.left(error)'
-     *
-     * @template R2 right transformer function result's underlying value type
-     * @template L2 right transformer function result's underlying error type
-     * @template R3 left transformer function result's underlying value type
-     * @template L3 left transformer function result's underlying error type
-     * @param op.right transformer to be invoked with underlying value in case of 'right'
-     * @param op.left transformer to be invoked with underlying error in case of 'left'
-     * @returns 'op(value)' or 'op(error)'
-     */
-    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: {
-        right: (value: R) => Right<R2, L2>;
-        left: (error: L) => Right<R3, L3>;
-    }): Right<R2, never>;
-    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: {
-        right: (value: R) => Left<R2, L2>;
-        left: (error: L) => Right<R3, L3>;
-    }): Left<never, L2>;
-    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: {
-        right: (value: R) => Right<R2, L2>;
-        left: (error: L) => Left<R3, L3>;
-    }): Right<R2, never>;
-    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: {
-        right: (value: R) => Left<R2, L2>;
-        left: (error: L) => Left<R3, L3>;
-    }): Left<never, L2>;
-    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: {
-        right: (value: R) => Either<R2, L2>;
-        left: (error: L) => Right<R3, L3>;
-    }): Either<R2, L2>;
-    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: {
-        right: (value: R) => Either<R2, L2>;
-        left: (error: L) => Left<R3, L3>;
-    }): Either<R2, L2>;
-    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: {
-        right: (value: R) => Right<R2, L2>;
-        left: (error: L) => Either<R3, L3>;
-    }): Right<R2, never>;
-    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: {
-        right: (value: R) => Left<R2, L2>;
-        left: (error: L) => Either<R3, L3>;
-    }): Left<never, L2>;
-    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: {
-        right: (value: R) => Either<R2, L2>;
-        left: (error: L) => Either<R3, L3>;
-    }): Either<R2, L2>;
-    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: {
-        right: (value: R) => Right<R2, L2>;
-        left: (error: L) => Right<R3, L3>;
-    }): Right<R2 | R3, never>;
-    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: {
-        right: (value: R) => Left<R2, L2>;
-        left: (error: L) => Right<R3, L3>;
-    }): Either<R3, L2>;
-    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: {
-        right: (value: R) => Right<R2, L2>;
-        left: (error: L) => Left<R3, L3>;
-    }): Either<R2, L3>;
-    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: {
-        right: (value: R) => Left<R2, L2>;
-        left: (error: L) => Left<R3, L3>;
-    }): Left<never, L2 | L3>;
-    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: {
-        right: (value: R) => Either<R2, L2>;
-        left: (error: L) => Right<R3, L3>;
-    }): Either<R2 | R3, L2>;
-    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: {
-        right: (value: R) => Either<R2, L2>;
-        left: (error: L) => Left<R3, L3>;
-    }): Either<R2, L2 | L3>;
-    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: {
-        right: (value: R) => Right<R2, L2>;
-        left: (error: L) => Either<R3, L3>;
-    }): Either<R2 | R3, L3>;
-    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: {
-        right: (value: R) => Left<R2, L2>;
-        left: (error: L) => Either<R3, L3>;
-    }): Either<R3, L2 | L3>;
-    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: {
-        right: (value: R) => Either<R2, L2>;
-        left: (error: L) => Either<R3, L3>;
-    }): Either<R2 | R3, L2 | L3>;
-    /**
-     * Either type guard for 'right'
-     *
-     * @returns 'true' in case this is 'right value' (and resolves type to be 'right')
-     *
-     * @example
-     * ```typescript
-     * if (either.isRight()) {
-     *   console.log(either.right)
-     * }
-     * ```
-     */
-    isRight(): this is Right<R, L>;
-    /**
-     * Either type guard for 'left'
-     *
-     * @returns 'true' in case this is 'left error' (and resolves type to be 'left')
-     *
-     * @example
-     * ```typescript
-     * if (either.isLeft()) {
-     *   console.error(either.left)
-     * }
-     * ```
-     */
-    isLeft(): this is Left<R, L>;
-    /**
-     * Wrap Maybe to singleton generator
-     *
-     * Userful in order to avoid ambiguous yied types
-     *
-     * @returns generator of Maybe wrapping this
-     */
-    generator: EitherGeneratorFunction<[], R, Right<R, L>, R>;
-}
-/**
- * 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)
- * @template L underlying error type
- */
-export interface Left<R, L> {
-    readonly left: L;
-    /**
-     * Either peeker function
-     *
-     * Applied to 'right value' returns self invoking op(value) in process
-     * Applied to 'left error' returns self without invoking callback
-     *
-     * @param op function to be invoked with underlying value
-     * @returns self
-     */
-    tap(op: (value: R) => void): 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
-     *
-     * @param op function to be invoked with underlying value
-     * @returns self
-     */
-    orTap(op: (error: L) => void): 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
-     *
-     * @param op.right function to be invoked with underlying value in case of 'right'
-     * @param op.left function to be invoked with underlying error in case of 'left'
-     * @returns self
-     */
-    matchTap(op: {
-        right: (value: R) => void;
-        left: (error: L) => void;
-    }): this;
-    /**
-     * Either transformer function
-     *
-     * Applied to 'right value' returns 'right op(value)'
-     * Applied to 'left error' returns self without invoking transformer
-     *
-     * @template R2 transformer function's return type
-     * @param op transformer to be invoked with underlying value
-     * @returns 'right op(value)' or 'left error'
-     */
-    map<R2>(this: Left<R, L>, op: (value: R) => R2): Left<never, L>;
-    map<R2>(this: Either<R, L>, op: (value: R) => R2): Either<R2, L>;
-    /**
-     * Either fallback transformer function
-     *
-     * Applied to 'right value' returns self without invoking transformer
-     * Applied to 'left error' returns 'right op(error)'
-     *
-     * @param op transformer to be invoked with underlying error
-     * @returns 'right value' or 'right op(error)'
-     */
-    orMap<R2>(this: Left<R, L>, op: (error: L) => R2): Right<R2, never>;
-    orMap<R2>(this: Either<R, L>, op: (error: L) => R2): Right<R | 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)'
-     *
-     * @template R2 right transformer function's return type
-     * @template R3 left transformer function's return type
-     * @param op.right transformer to be invoked with underlying value in case of 'right'
-     * @param op.left transformer to be invoked with underlying error in case of 'left'
-     * @returns 'right op.right(value)' or 'right op.left(error)'
-     */
-    matchMap<R2, R3 = R2>(this: Left<R, L>, op: {
-        right: (value: R) => R2;
-        left: (error: L) => R3;
-    }): Right<R3, never>;
-    matchMap<R2, R3 = R2>(this: Either<R, L>, op: {
-        right: (value: R) => R2;
-        left: (error: L) => R3;
-    }): Right<R2 | R3, never>;
-    /**
-     * Either composition function
-     *
-     * Applied to 'right value' returns 'op(value)'
-     * Applied to 'left error' returns self without invoking composition function
-     *
-     * @template R2 transformer function result's underlying value type
-     * @template L2 transformer function result's underlying error type
-     * @param op transformer to be invoked with underlying value
-     * @returns 'op(value)' or 'left error'
-     */
-    chain<R2, L2>(this: Left<R, L>, op: (value: R) => Right<R2, L2>): Left<never, L>;
-    chain<R2, L2>(this: Left<R, L>, op: (value: R) => Left<R2, L2>): Left<never, L>;
-    chain<R2, L2>(this: Left<R, L>, op: (value: R) => Either<R2, L2>): Left<never, L>;
-    chain<R2, L2>(this: Either<R, L>, op: (value: R) => Right<R2, L2>): Either<R2, L>;
-    chain<R2, L2>(this: Either<R, L>, op: (value: R) => Left<R2, L2>): Left<never, L | L2>;
-    chain<R2, L2>(this: Either<R, L>, op: (value: R) => Either<R2, L2>): Either<R2, L | L2>;
-    /**
-     * Either fallback composition function
-     *
-     * Applied to 'right value' returns self without invoking composition function
-     * Applied to 'left error' returns 'op(error)'
-     *
-     * @template R2 transformer function result's underlying value type
-     * @template L2 transformer function result's underlying error type
-     * @param op transformer to be invoked with underlying value
-     * @returns 'right value' or 'op(error)'
-     */
-    orChain<R2, L2>(this: Left<R, L>, op: (error: L) => Right<R2, L2>): Right<R2, never>;
-    orChain<R2, L2>(this: Left<R, L>, op: (error: L) => Left<R2, L2>): Left<never, L2>;
-    orChain<R2, L2>(this: Left<R, L>, op: (error: L) => Either<R2, L2>): Either<R2, L2>;
-    orChain<R2, L2>(this: Either<R, L>, op: (error: L) => Right<R2, L2>): Right<R | R2, never>;
-    orChain<R2, L2>(this: Either<R, L>, op: (error: L) => Left<R2, L2>): Either<R, L2>;
-    orChain<R2, L2>(this: Either<R, L>, op: (error: L) => Either<R2, L2>): Either<R | R2, L2>;
-    /**
-     * Either pattern matching composition function
-     *
-     * Applied to 'right value' returns 'op.right(value)'
-     * Applied to 'left error' returns 'op.left(error)'
-     *
-     * @template R2 right transformer function result's underlying value type
-     * @template L2 right transformer function result's underlying error type
-     * @template R3 left transformer function result's underlying value type
-     * @template L3 left transformer function result's underlying error type
-     * @param op.right transformer to be invoked with underlying value in case of 'right'
-     * @param op.left transformer to be invoked with underlying error in case of 'left'
-     * @returns 'op(value)' or 'op(error)'
-     */
-    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: {
-        right: (value: R) => Right<R2, L2>;
-        left: (error: L) => Right<R3, L3>;
-    }): Right<R3, never>;
-    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: {
-        right: (value: R) => Left<R2, L2>;
-        left: (error: L) => Right<R3, L3>;
-    }): Right<R3, never>;
-    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: {
-        right: (value: R) => Right<R2, L2>;
-        left: (error: L) => Left<R3, L3>;
-    }): Left<never, L3>;
-    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: {
-        right: (value: R) => Left<R2, L2>;
-        left: (error: L) => Left<R3, L3>;
-    }): Left<never, L3>;
-    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: {
-        right: (value: R) => Either<R2, L2>;
-        left: (error: L) => Right<R3, L3>;
-    }): Right<R3, never>;
-    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: {
-        right: (value: R) => Either<R2, L2>;
-        left: (error: L) => Left<R3, L3>;
-    }): Left<never, L3>;
-    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: {
-        right: (value: R) => Right<R2, L2>;
-        left: (error: L) => Either<R3, L3>;
-    }): Either<R3, L3>;
-    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: {
-        right: (value: R) => Left<R2, L2>;
-        left: (error: L) => Either<R3, L3>;
-    }): Either<R3, L3>;
-    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: {
-        right: (value: R) => Either<R2, L2>;
-        left: (error: L) => Either<R3, L3>;
-    }): Either<R3, L3>;
-    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: {
-        right: (value: R) => Right<R2, L2>;
-        left: (error: L) => Right<R3, L3>;
-    }): Right<R2 | R3, never>;
-    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: {
-        right: (value: R) => Left<R2, L2>;
-        left: (error: L) => Right<R3, L3>;
-    }): Either<R3, L2>;
-    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: {
-        right: (value: R) => Right<R2, L2>;
-        left: (error: L) => Left<R3, L3>;
-    }): Either<R2, L3>;
-    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: {
-        right: (value: R) => Left<R2, L2>;
-        left: (error: L) => Left<R3, L3>;
-    }): Left<never, L2 | L3>;
-    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: {
-        right: (value: R) => Either<R2, L2>;
-        left: (error: L) => Right<R3, L3>;
-    }): Either<R2 | R3, L2>;
-    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: {
-        right: (value: R) => Either<R2, L2>;
-        left: (error: L) => Left<R3, L3>;
-    }): Either<R2, L2 | L3>;
-    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: {
-        right: (value: R) => Right<R2, L2>;
-        left: (error: L) => Either<R3, L3>;
-    }): Either<R2 | R3, L3>;
-    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: {
-        right: (value: R) => Left<R2, L2>;
-        left: (error: L) => Either<R3, L3>;
-    }): Either<R3, L2 | L3>;
-    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: {
-        right: (value: R) => Either<R2, L2>;
-        left: (error: L) => Either<R3, L3>;
-    }): Either<R2 | R3, L2 | L3>;
-    /**
-     * Either type guard for 'right'
-     *
-     * @returns 'true' in case this is 'right value' (and resolves type to be 'right')
-     *
-     * @example
-     * ```typescript
-     * if (either.isRight()) {
-     *   console.log(either.right)
-     * }
-     * ```
-     */
-    isRight(): this is Right<R, L>;
-    /**
-     * Either type guard for 'left'
-     *
-     * @returns 'true' in case this is 'left error' (and resolves type to be 'left')
-     *
-     * @example
-     * ```typescript
-     * if (either.isLeft()) {
-     *   console.error(either.left)
-     * }
-     * ```
-     */
-    isLeft(): this is Left<R, L>;
-    /**
-     * Wrap Maybe to singleton generator
-     *
-     * Userful in order to avoid ambiguous yied types
-     *
-     * @returns generator of Maybe wrapping this
-     */
-    generator: EitherGeneratorFunction<[], R, Left<R, L>, R>;
-}
-/**
- * Either data type: either Right value of type R or Left value of type L
- *
- * As per classic Either monad implementation can eithr contain a right (correct) value or a left (erroneous) value
- * Used throughout the library to represent the result of failable operations, namely failed tasks
- *
- * @template R underlying value type
- * @template L underlying error type
- */
-export declare type Either<R, L> = Right<R, L> | Left<R, L>;
-export declare namespace Right {
-    /**
-     * Standalone Right value extractor
-     *
-     * Userful for passing as a function to collection transformers
-     *
-     * @template R underlying value type
-     * @template L underlying error type
-     * @param right Right instance
-     * @returns underlying value
-     */
-    function right<R, L>(right: Right<R, L>): R;
-}
-export declare namespace Left {
-    /**
-     * Standalone Left error extractor
-     *
-     * Userful for passing as a function to collection transformers
-     *
-     * @template R underlying value type
-     * @template L underlying error type
-     * @param left Left instance
-     * @returns underlying error
-     */
-    function left<R, L>(left: Left<R, L>): L;
-}
-export declare type EitherGenerator<T, TT extends Either<T, any>, R> = Generator<TT, R, T>;
-export declare type EitherGeneratorFunction<A extends unknown[], T, TT extends Either<T, any>, R> = (...args: A) => EitherGenerator<T, TT, R>;
-export declare namespace Either {
-    /**
-     * Right monad constructor
-     *
-     * @template R underlying value type
-     * @param value underlying value
-     * @returns 'right value'
-     */
-    function right<R>(value: R): Right<R, never>;
-    /**
-     * Left monad constructor
-     *
-     * @template L underlying error type
-     * @param error underlying error
-     * @returns 'left error'
-     */
-    function left<L>(error: L): Left<never, L>;
-    /**
-     * Either constructor from optional value
-     *
-     * Resolves to 'left error' in case of undefined value and 'right value' otherwise
-     *
-     * @param value possibly undefined value
-     * @param error error to use in case of undefined value
-     * @returns either 'right value' or 'left error'
-     */
-    function fromOptional<L>(value: undefined, error: L): Left<never, L>;
-    function fromOptional<R>(value: Exclude<R, undefined>, error: unknown): Right<R, never>;
-    function fromOptional<R, L>(value: R | undefined, error: L): Either<R, L>;
-    /**
-     * Either constructor from optional or nullable value
-     *
-     * Resolves to 'left error' in case of undefined or null value and 'right value' otherwise
-     *
-     * @param value possibly undefined or nullable value
-     * @param error error to use in case of undefined or nullable value
-     * @returns either 'right value' or 'left error'
-     */
-    function fromNullable<L>(value: undefined, error: L): Left<never, L>;
-    function fromNullable<L>(value: null, error: L): Left<never, L>;
-    function fromNullable<R>(value: Exclude<R, null | undefined>, error: unknown): Right<R, never>;
-    function fromNullable<R, L>(value: R | null | undefined, error: L): Either<R, L>;
-    /**
-     * Standalone type guard for 'right'
-     *
-     * Userful for passing as a predicate to collection transformers
-     *
-     * @template R underlying value type
-     * @param either Either instance
-     * @returns 'true' in case argument is 'right value' (and resolves type to be 'right')
-     */
-    function isRight<R, L>(either: Either<R, L>): either is Right<R, never>;
-    /**
-     * Standalone type guard for 'left'
-     *
-     * Userful for passing as a predicate to collection transformers
-     *
-     * @template R underlying value type
-     * @param either Either instance
-     * @returns 'true' in case argument is 'left error' (and resolves type to be 'left')
-     */
-    function isLeft<R, L>(either: Either<R, L>): either is Left<never, L>;
-    /**
-     * Standalone list predicate
-     *
-     * @param eithers a list of Either
-     * @returns true in case every list element is Right
-     */
-    function everyRight<R, L>(eithers: Either<R, L>[]): eithers is Right<R, never>[];
-    /**
-     * Standalone list predicate
-     *
-     * @param eithers a list of Either
-     * @returns true in case at least one list element is Right
-     */
-    function someRight<R, L>(eithers: Either<R, L>[]): boolean;
-    /**
-     * Standalone list predicate
-     *
-     * @param eithers a list of Either
-     * @returns true in case every list element is Left
-     */
-    function everyLeft<R, L>(eithers: Either<R, L>[]): eithers is Left<never, L>[];
-    /**
-     * Standalone list predicate
-     *
-     * @param eithers a list of Either
-     * @returns true in case at least one list element is Left
-     */
-    function someLeft<R, L>(eithers: Either<R, L>[]): boolean;
-    /**
-     * Create compound Either from generator function
-     *
-     * Applying yield to a Maybe within the generator function unwraps the Maybe and returns underlying value in case of success
-     * However the convinient option for typescript is to use ```yield* maybe.generator()``` as othervise one may have to deal with union types
-     *
-     * @template TT yielded Maybe type
-     * @template R returned underlying type
-     * @param maybeGeneratorFunction Maybe generator function
-     * @returns Just wrapping the result of generator function or Nothing
-     * ```
-     */
-    function generate<T, TT extends Either<T, any>, R>(eitherGeneratorFunction: EitherGeneratorFunction<[], T, TT, R>): Either<R, any>;
-}
+/**
+ * Right (correct) value of type R
+ *
+ * Either data type specialization representing a correct value
+ *
+ * @template R underlying value type
+ * @template L underlying error type (needed for type merging, in fact alwas considered to be never)
+ */
+export interface Right<R, L> {
+    readonly right: R;
+    /**
+     * Either peeker function
+     *
+     * Applied to 'right value' returns self invoking op(value) in process
+     * Applied to 'left error' returns self without invoking callback
+     *
+     * @param op function to be invoked with underlying value
+     * @returns self
+     */
+    tap(op: (value: R) => void): 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
+     *
+     * @param op function to be invoked with underlying error
+     * @returns self
+     */
+    orTap(op: (error: L) => void): 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
+     *
+     * @param op.right function to be invoked with underlying value in case of 'right'
+     * @param op.left function to be invoked with underlying error in case of 'left'
+     * @returns self
+     */
+    matchTap(op: {
+        right: (value: R) => void;
+        left: (error: L) => void;
+    }): this;
+    /**
+     * Either transformer function
+     *
+     * Applied to 'right value' returns 'right op(value)'
+     * Applied to 'left error' returns self without invoking transformer
+     *
+     * @template R2 transformer function's return type
+     * @param op transformer to be invoked with underlying value
+     * @returns 'right op(value)' or 'left error'
+     */
+    map<R2>(this: Right<R, L>, op: (value: R) => R2): Right<R2, never>;
+    map<R2>(this: Either<R, L>, op: (value: R) => R2): Either<R2, L>;
+    /**
+     * Either fallback transformer function
+     *
+     * Applied to 'right value' returns self without invoking transformer
+     * Applied to 'left error' returns 'right op(error)'
+     *
+     * @param op transformer to be invoked with underlying error
+     * @returns 'right value' or 'right op(error)'
+     */
+    orMap<R2>(this: Right<R, L>, op: (error: L) => R2): Right<R, never>;
+    orMap<R2>(this: Either<R, L>, op: (error: L) => R2): Right<R | 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)'
+     *
+     * @template R2 right transformer function's return type
+     * @template R3 left transformer function's return type
+     * @param op.right transformer to be invoked with underlying value in case of 'right'
+     * @param op.left transformer to be invoked with underlying error in case of 'left'
+     * @returns 'right op.right(value)' or 'right op.left(error)'
+     */
+    matchMap<R2, R3 = R2>(this: Right<R, L>, op: {
+        right: (value: R) => R2;
+        left: (error: L) => R3;
+    }): Right<R2, never>;
+    matchMap<R2, R3 = R2>(this: Either<R, L>, op: {
+        right: (value: R) => R2;
+        left: (error: L) => R3;
+    }): Right<R2 | R3, never>;
+    /**
+     * Either composition function
+     *
+     * Applied to 'right value' returns 'op(value)'
+     * Applied to 'left error' returns self without invoking composition function
+     *
+     * @template R2 transformer function result's underlying value type
+     * @template L2 transformer function result's underlying error type
+     * @param op transformer to be invoked with underlying value
+     * @returns 'op(value)' or 'left error'
+     */
+    chain<R2, L2>(this: Right<R, L>, op: (value: R) => Right<R2, L2>): Right<R2, never>;
+    chain<R2, L2>(this: Right<R, L>, op: (value: R) => Left<R2, L2>): Left<never, L2>;
+    chain<R2, L2>(this: Right<R, L>, op: (value: R) => Either<R2, L2>): Either<R2, L2>;
+    chain<R2, L2>(this: Either<R, L>, op: (value: R) => Right<R2, L2>): Either<R2, L>;
+    chain<R2, L2>(this: Either<R, L>, op: (value: R) => Left<R2, L2>): Left<never, L | L2>;
+    chain<R2, L2>(this: Either<R, L>, op: (value: R) => Either<R2, L2>): Either<R2, L | L2>;
+    /**
+     * Either composition function
+     *
+     * Applied to 'right value' returns self without invoking composition function
+     * Applied to 'left error' returns 'op(error)'
+     *
+     * @template R2 transformer function result's underlying value type
+     * @template L2 transformer function result's underlying error type
+     * @param op transformer to be invoked with underlying value
+     * @returns 'right value' or 'op(error)'
+     */
+    orChain<R2, L2>(this: Right<R, L>, op: (error: L) => Right<R2, L2>): Right<R, never>;
+    orChain<R2, L2>(this: Right<R, L>, op: (error: L) => Left<R2, L2>): Right<R, never>;
+    orChain<R2, L2>(this: Right<R, L>, op: (error: L) => Either<R2, L2>): Right<R, never>;
+    orChain<R2, L2>(this: Either<R, L>, op: (error: L) => Right<R2, L2>): Right<R | R2, never>;
+    orChain<R2, L2>(this: Either<R, L>, op: (error: L) => Left<R2, L2>): Either<R, L2>;
+    orChain<R2, L2>(this: Either<R, L>, op: (error: L) => Either<R2, L2>): Either<R | R2, L2>;
+    /**
+     * Either pattern matching composition function
+     *
+     * Applied to 'right value' returns 'op.right(value)'
+     * Applied to 'left error' returns 'op.left(error)'
+     *
+     * @template R2 right transformer function result's underlying value type
+     * @template L2 right transformer function result's underlying error type
+     * @template R3 left transformer function result's underlying value type
+     * @template L3 left transformer function result's underlying error type
+     * @param op.right transformer to be invoked with underlying value in case of 'right'
+     * @param op.left transformer to be invoked with underlying error in case of 'left'
+     * @returns 'op(value)' or 'op(error)'
+     */
+    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: {
+        right: (value: R) => Right<R2, L2>;
+        left: (error: L) => Right<R3, L3>;
+    }): Right<R2, never>;
+    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: {
+        right: (value: R) => Left<R2, L2>;
+        left: (error: L) => Right<R3, L3>;
+    }): Left<never, L2>;
+    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: {
+        right: (value: R) => Right<R2, L2>;
+        left: (error: L) => Left<R3, L3>;
+    }): Right<R2, never>;
+    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: {
+        right: (value: R) => Left<R2, L2>;
+        left: (error: L) => Left<R3, L3>;
+    }): Left<never, L2>;
+    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: {
+        right: (value: R) => Either<R2, L2>;
+        left: (error: L) => Right<R3, L3>;
+    }): Either<R2, L2>;
+    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: {
+        right: (value: R) => Either<R2, L2>;
+        left: (error: L) => Left<R3, L3>;
+    }): Either<R2, L2>;
+    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: {
+        right: (value: R) => Right<R2, L2>;
+        left: (error: L) => Either<R3, L3>;
+    }): Right<R2, never>;
+    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: {
+        right: (value: R) => Left<R2, L2>;
+        left: (error: L) => Either<R3, L3>;
+    }): Left<never, L2>;
+    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: {
+        right: (value: R) => Either<R2, L2>;
+        left: (error: L) => Either<R3, L3>;
+    }): Either<R2, L2>;
+    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: {
+        right: (value: R) => Right<R2, L2>;
+        left: (error: L) => Right<R3, L3>;
+    }): Right<R2 | R3, never>;
+    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: {
+        right: (value: R) => Left<R2, L2>;
+        left: (error: L) => Right<R3, L3>;
+    }): Either<R3, L2>;
+    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: {
+        right: (value: R) => Right<R2, L2>;
+        left: (error: L) => Left<R3, L3>;
+    }): Either<R2, L3>;
+    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: {
+        right: (value: R) => Left<R2, L2>;
+        left: (error: L) => Left<R3, L3>;
+    }): Left<never, L2 | L3>;
+    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: {
+        right: (value: R) => Either<R2, L2>;
+        left: (error: L) => Right<R3, L3>;
+    }): Either<R2 | R3, L2>;
+    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: {
+        right: (value: R) => Either<R2, L2>;
+        left: (error: L) => Left<R3, L3>;
+    }): Either<R2, L2 | L3>;
+    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: {
+        right: (value: R) => Right<R2, L2>;
+        left: (error: L) => Either<R3, L3>;
+    }): Either<R2 | R3, L3>;
+    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: {
+        right: (value: R) => Left<R2, L2>;
+        left: (error: L) => Either<R3, L3>;
+    }): Either<R3, L2 | L3>;
+    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: {
+        right: (value: R) => Either<R2, L2>;
+        left: (error: L) => Either<R3, L3>;
+    }): Either<R2 | R3, L2 | L3>;
+    /**
+     * Either type guard for 'right'
+     *
+     * @returns 'true' in case this is 'right value' (and resolves type to be 'right')
+     *
+     * @example
+     * ```typescript
+     * if (either.isRight()) {
+     *   console.log(either.right)
+     * }
+     * ```
+     */
+    isRight(): this is Right<R, L>;
+    /**
+     * Either type guard for 'left'
+     *
+     * @returns 'true' in case this is 'left error' (and resolves type to be 'left')
+     *
+     * @example
+     * ```typescript
+     * if (either.isLeft()) {
+     *   console.error(either.left)
+     * }
+     * ```
+     */
+    isLeft(): this is Left<R, L>;
+    /**
+     * Wrap Maybe to singleton generator
+     *
+     * Userful in order to avoid ambiguous yied types
+     *
+     * @returns generator of Maybe wrapping this
+     */
+    generator: EitherGeneratorFunction<[], R, Right<R, L>, R>;
+}
+/**
+ * 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)
+ * @template L underlying error type
+ */
+export interface Left<R, L> {
+    readonly left: L;
+    /**
+     * Either peeker function
+     *
+     * Applied to 'right value' returns self invoking op(value) in process
+     * Applied to 'left error' returns self without invoking callback
+     *
+     * @param op function to be invoked with underlying value
+     * @returns self
+     */
+    tap(op: (value: R) => void): 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
+     *
+     * @param op function to be invoked with underlying value
+     * @returns self
+     */
+    orTap(op: (error: L) => void): 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
+     *
+     * @param op.right function to be invoked with underlying value in case of 'right'
+     * @param op.left function to be invoked with underlying error in case of 'left'
+     * @returns self
+     */
+    matchTap(op: {
+        right: (value: R) => void;
+        left: (error: L) => void;
+    }): this;
+    /**
+     * Either transformer function
+     *
+     * Applied to 'right value' returns 'right op(value)'
+     * Applied to 'left error' returns self without invoking transformer
+     *
+     * @template R2 transformer function's return type
+     * @param op transformer to be invoked with underlying value
+     * @returns 'right op(value)' or 'left error'
+     */
+    map<R2>(this: Left<R, L>, op: (value: R) => R2): Left<never, L>;
+    map<R2>(this: Either<R, L>, op: (value: R) => R2): Either<R2, L>;
+    /**
+     * Either fallback transformer function
+     *
+     * Applied to 'right value' returns self without invoking transformer
+     * Applied to 'left error' returns 'right op(error)'
+     *
+     * @param op transformer to be invoked with underlying error
+     * @returns 'right value' or 'right op(error)'
+     */
+    orMap<R2>(this: Left<R, L>, op: (error: L) => R2): Right<R2, never>;
+    orMap<R2>(this: Either<R, L>, op: (error: L) => R2): Right<R | 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)'
+     *
+     * @template R2 right transformer function's return type
+     * @template R3 left transformer function's return type
+     * @param op.right transformer to be invoked with underlying value in case of 'right'
+     * @param op.left transformer to be invoked with underlying error in case of 'left'
+     * @returns 'right op.right(value)' or 'right op.left(error)'
+     */
+    matchMap<R2, R3 = R2>(this: Left<R, L>, op: {
+        right: (value: R) => R2;
+        left: (error: L) => R3;
+    }): Right<R3, never>;
+    matchMap<R2, R3 = R2>(this: Either<R, L>, op: {
+        right: (value: R) => R2;
+        left: (error: L) => R3;
+    }): Right<R2 | R3, never>;
+    /**
+     * Either composition function
+     *
+     * Applied to 'right value' returns 'op(value)'
+     * Applied to 'left error' returns self without invoking composition function
+     *
+     * @template R2 transformer function result's underlying value type
+     * @template L2 transformer function result's underlying error type
+     * @param op transformer to be invoked with underlying value
+     * @returns 'op(value)' or 'left error'
+     */
+    chain<R2, L2>(this: Left<R, L>, op: (value: R) => Right<R2, L2>): Left<never, L>;
+    chain<R2, L2>(this: Left<R, L>, op: (value: R) => Left<R2, L2>): Left<never, L>;
+    chain<R2, L2>(this: Left<R, L>, op: (value: R) => Either<R2, L2>): Left<never, L>;
+    chain<R2, L2>(this: Either<R, L>, op: (value: R) => Right<R2, L2>): Either<R2, L>;
+    chain<R2, L2>(this: Either<R, L>, op: (value: R) => Left<R2, L2>): Left<never, L | L2>;
+    chain<R2, L2>(this: Either<R, L>, op: (value: R) => Either<R2, L2>): Either<R2, L | L2>;
+    /**
+     * Either fallback composition function
+     *
+     * Applied to 'right value' returns self without invoking composition function
+     * Applied to 'left error' returns 'op(error)'
+     *
+     * @template R2 transformer function result's underlying value type
+     * @template L2 transformer function result's underlying error type
+     * @param op transformer to be invoked with underlying value
+     * @returns 'right value' or 'op(error)'
+     */
+    orChain<R2, L2>(this: Left<R, L>, op: (error: L) => Right<R2, L2>): Right<R2, never>;
+    orChain<R2, L2>(this: Left<R, L>, op: (error: L) => Left<R2, L2>): Left<never, L2>;
+    orChain<R2, L2>(this: Left<R, L>, op: (error: L) => Either<R2, L2>): Either<R2, L2>;
+    orChain<R2, L2>(this: Either<R, L>, op: (error: L) => Right<R2, L2>): Right<R | R2, never>;
+    orChain<R2, L2>(this: Either<R, L>, op: (error: L) => Left<R2, L2>): Either<R, L2>;
+    orChain<R2, L2>(this: Either<R, L>, op: (error: L) => Either<R2, L2>): Either<R | R2, L2>;
+    /**
+     * Either pattern matching composition function
+     *
+     * Applied to 'right value' returns 'op.right(value)'
+     * Applied to 'left error' returns 'op.left(error)'
+     *
+     * @template R2 right transformer function result's underlying value type
+     * @template L2 right transformer function result's underlying error type
+     * @template R3 left transformer function result's underlying value type
+     * @template L3 left transformer function result's underlying error type
+     * @param op.right transformer to be invoked with underlying value in case of 'right'
+     * @param op.left transformer to be invoked with underlying error in case of 'left'
+     * @returns 'op(value)' or 'op(error)'
+     */
+    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: {
+        right: (value: R) => Right<R2, L2>;
+        left: (error: L) => Right<R3, L3>;
+    }): Right<R3, never>;
+    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: {
+        right: (value: R) => Left<R2, L2>;
+        left: (error: L) => Right<R3, L3>;
+    }): Right<R3, never>;
+    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: {
+        right: (value: R) => Right<R2, L2>;
+        left: (error: L) => Left<R3, L3>;
+    }): Left<never, L3>;
+    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: {
+        right: (value: R) => Left<R2, L2>;
+        left: (error: L) => Left<R3, L3>;
+    }): Left<never, L3>;
+    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: {
+        right: (value: R) => Either<R2, L2>;
+        left: (error: L) => Right<R3, L3>;
+    }): Right<R3, never>;
+    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: {
+        right: (value: R) => Either<R2, L2>;
+        left: (error: L) => Left<R3, L3>;
+    }): Left<never, L3>;
+    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: {
+        right: (value: R) => Right<R2, L2>;
+        left: (error: L) => Either<R3, L3>;
+    }): Either<R3, L3>;
+    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: {
+        right: (value: R) => Left<R2, L2>;
+        left: (error: L) => Either<R3, L3>;
+    }): Either<R3, L3>;
+    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: {
+        right: (value: R) => Either<R2, L2>;
+        left: (error: L) => Either<R3, L3>;
+    }): Either<R3, L3>;
+    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: {
+        right: (value: R) => Right<R2, L2>;
+        left: (error: L) => Right<R3, L3>;
+    }): Right<R2 | R3, never>;
+    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: {
+        right: (value: R) => Left<R2, L2>;
+        left: (error: L) => Right<R3, L3>;
+    }): Either<R3, L2>;
+    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: {
+        right: (value: R) => Right<R2, L2>;
+        left: (error: L) => Left<R3, L3>;
+    }): Either<R2, L3>;
+    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: {
+        right: (value: R) => Left<R2, L2>;
+        left: (error: L) => Left<R3, L3>;
+    }): Left<never, L2 | L3>;
+    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: {
+        right: (value: R) => Either<R2, L2>;
+        left: (error: L) => Right<R3, L3>;
+    }): Either<R2 | R3, L2>;
+    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: {
+        right: (value: R) => Either<R2, L2>;
+        left: (error: L) => Left<R3, L3>;
+    }): Either<R2, L2 | L3>;
+    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: {
+        right: (value: R) => Right<R2, L2>;
+        left: (error: L) => Either<R3, L3>;
+    }): Either<R2 | R3, L3>;
+    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: {
+        right: (value: R) => Left<R2, L2>;
+        left: (error: L) => Either<R3, L3>;
+    }): Either<R3, L2 | L3>;
+    matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: {
+        right: (value: R) => Either<R2, L2>;
+        left: (error: L) => Either<R3, L3>;
+    }): Either<R2 | R3, L2 | L3>;
+    /**
+     * Either type guard for 'right'
+     *
+     * @returns 'true' in case this is 'right value' (and resolves type to be 'right')
+     *
+     * @example
+     * ```typescript
+     * if (either.isRight()) {
+     *   console.log(either.right)
+     * }
+     * ```
+     */
+    isRight(): this is Right<R, L>;
+    /**
+     * Either type guard for 'left'
+     *
+     * @returns 'true' in case this is 'left error' (and resolves type to be 'left')
+     *
+     * @example
+     * ```typescript
+     * if (either.isLeft()) {
+     *   console.error(either.left)
+     * }
+     * ```
+     */
+    isLeft(): this is Left<R, L>;
+    /**
+     * Wrap Maybe to singleton generator
+     *
+     * Userful in order to avoid ambiguous yied types
+     *
+     * @returns generator of Maybe wrapping this
+     */
+    generator: EitherGeneratorFunction<[], R, Left<R, L>, R>;
+}
+/**
+ * Either data type: either Right value of type R or Left value of type L
+ *
+ * As per classic Either monad implementation can eithr contain a right (correct) value or a left (erroneous) value
+ * Used throughout the library to represent the result of failable operations, namely failed tasks
+ *
+ * @template R underlying value type
+ * @template L underlying error type
+ */
+export type Either<R, L> = Right<R, L> | Left<R, L>;
+export declare namespace Right {
+    /**
+     * Standalone Right value extractor
+     *
+     * Userful for passing as a function to collection transformers
+     *
+     * @template R underlying value type
+     * @template L underlying error type
+     * @param right Right instance
+     * @returns underlying value
+     */
+    function right<R, L>(right: Right<R, L>): R;
+}
+export declare namespace Left {
+    /**
+     * Standalone Left error extractor
+     *
+     * Userful for passing as a function to collection transformers
+     *
+     * @template R underlying value type
+     * @template L underlying error type
+     * @param left Left instance
+     * @returns underlying error
+     */
+    function left<R, L>(left: Left<R, L>): L;
+}
+export type EitherGenerator<T, TT extends Either<T, any>, R> = Generator<TT, R, T>;
+export type EitherGeneratorFunction<A extends unknown[], T, TT extends Either<T, any>, R> = (...args: A) => EitherGenerator<T, TT, R>;
+export declare namespace Either {
+    /**
+     * Right monad constructor
+     *
+     * @template R underlying value type
+     * @param value underlying value
+     * @returns 'right value'
+     */
+    function right<R>(value: R): Right<R, never>;
+    /**
+     * Left monad constructor
+     *
+     * @template L underlying error type
+     * @param error underlying error
+     * @returns 'left error'
+     */
+    function left<L>(error: L): Left<never, L>;
+    /**
+     * Either constructor from optional value
+     *
+     * Resolves to 'left error' in case of undefined value and 'right value' otherwise
+     *
+     * @param value possibly undefined value
+     * @param error error to use in case of undefined value
+     * @returns either 'right value' or 'left error'
+     */
+    function fromOptional<L>(value: undefined, error: L): Left<never, L>;
+    function fromOptional<R>(value: Exclude<R, undefined>, error: unknown): Right<R, never>;
+    function fromOptional<R, L>(value: R | undefined, error: L): Either<R, L>;
+    /**
+     * Either constructor from optional or nullable value
+     *
+     * Resolves to 'left error' in case of undefined or null value and 'right value' otherwise
+     *
+     * @param value possibly undefined or nullable value
+     * @param error error to use in case of undefined or nullable value
+     * @returns either 'right value' or 'left error'
+     */
+    function fromNullable<L>(value: undefined, error: L): Left<never, L>;
+    function fromNullable<L>(value: null, error: L): Left<never, L>;
+    function fromNullable<R>(value: Exclude<R, null | undefined>, error: unknown): Right<R, never>;
+    function fromNullable<R, L>(value: R | null | undefined, error: L): Either<R, L>;
+    /**
+     * Standalone type guard for 'right'
+     *
+     * Userful for passing as a predicate to collection transformers
+     *
+     * @template R underlying value type
+     * @param either Either instance
+     * @returns 'true' in case argument is 'right value' (and resolves type to be 'right')
+     */
+    function isRight<R, L>(either: Either<R, L>): either is Right<R, never>;
+    /**
+     * Standalone type guard for 'left'
+     *
+     * Userful for passing as a predicate to collection transformers
+     *
+     * @template R underlying value type
+     * @param either Either instance
+     * @returns 'true' in case argument is 'left error' (and resolves type to be 'left')
+     */
+    function isLeft<R, L>(either: Either<R, L>): either is Left<never, L>;
+    /**
+     * Standalone list predicate
+     *
+     * @param eithers a list of Either
+     * @returns true in case every list element is Right
+     */
+    function everyRight<R, L>(eithers: Either<R, L>[]): eithers is Right<R, never>[];
+    /**
+     * Standalone list predicate
+     *
+     * @param eithers a list of Either
+     * @returns true in case at least one list element is Right
+     */
+    function someRight<R, L>(eithers: Either<R, L>[]): boolean;
+    /**
+     * Standalone list predicate
+     *
+     * @param eithers a list of Either
+     * @returns true in case every list element is Left
+     */
+    function everyLeft<R, L>(eithers: Either<R, L>[]): eithers is Left<never, L>[];
+    /**
+     * Standalone list predicate
+     *
+     * @param eithers a list of Either
+     * @returns true in case at least one list element is Left
+     */
+    function someLeft<R, L>(eithers: Either<R, L>[]): boolean;
+    /**
+     * Create compound Either from generator function
+     *
+     * Applying yield to a Maybe within the generator function unwraps the Maybe and returns underlying value in case of success
+     * However the convinient option for typescript is to use ```yield* maybe.generator()``` as othervise one may have to deal with union types
+     *
+     * @template TT yielded Maybe type
+     * @template R returned underlying type
+     * @param maybeGeneratorFunction Maybe generator function
+     * @returns Just wrapping the result of generator function or Nothing
+     * ```
+     */
+    function generate<T, TT extends Either<T, any>, R>(eitherGeneratorFunction: EitherGeneratorFunction<[], T, TT, R>): Either<R, any>;
+}