t-tasks 1.2.1 → 2.0.0

package/dist/t-tasks.d.ts

@@ -0,0 +1,1790 @@
+//#region src/maybe.d.ts
+/**
+ * Just a value
+ *
+ * Maybe data type specialization representing an existing value
+ *
+ * @template R underlying value
+ */
+export interface Just<R> {
+  readonly just: R;
+  /**
+   * Maybe peeker function
+   *
+   * Applied to 'just value' returns self invoking op(value) in process
+   * Applied to 'nothing' returns self without invoking callback
+   *
+   * @param op function to be invoked with underlying value
+   * @returns self
+   */
+  tap(op: (value: R) => void): this;
+  /**
+   * Maybe fallback peeker function
+   *
+   * Applied to 'just value' returns self without invoking callback
+   * Applied to 'nothing' returns self invoking op() in process
+   *
+   * @param op function to be invoked
+   * @returns self
+   */
+  orTap(op: () => void): this;
+  /**
+   * Maybe pattern matching peeker function
+   *
+   * Applied to 'just value' returns self invoking op.just(value) in process
+   * Applied to 'nothing' returns self invoking op.nothing() in process
+   *
+   * @param op.just function to be invoked with underlying value in case of just
+   * @param op.nothing function to be invoked in case of nothing
+   * @returns self
+   */
+  matchTap(op: {
+    just: (value: R) => void;
+    nothing: () => void;
+  }): this;
+  /**
+   * Maybe transformer function
+   *
+   * Applied to 'just value' returns 'just op(value)'
+   * Applied to 'nothing' returns self without invoking transformer
+   *
+   * @template R2 transformer function's return type
+   * @param op transformer to be invoked with underlying value
+   * @returns 'just op(value)' or 'nothing'
+   */
+  map<R2>(this: Just<R>, op: (value: R) => R2): Just<R2>;
+  map<R2>(this: Maybe<R>, op: (value: R) => R2): Maybe<R2>;
+  /**
+   * Maybe fallback transformer function
+   *
+   * Applied to 'just value' returns self without invoking transformer
+   * Applied to 'nothing' returns 'just op()'
+   *
+   * @param op function to be invoked
+   * @returns 'just value' or 'just op()'
+   */
+  orMap<R2>(this: Just<R>, op: () => R2): Just<R>;
+  orMap<R2>(this: Maybe<R>, op: () => R2): Just<R | R2>;
+  /**
+   * Maybe pattern matching extractor function
+   *
+   * Applied to 'just value' returns op.just(value)
+   * Applied to 'nothing' returns op.nothing()
+   *
+   * @template R2 just extractor function's return type
+   * @template R3 nothing extractor function's return type
+   * @param op.just extractor to be invoked with underlying value in case of just
+   * @param op.nothing extractor to be invoked in case of nothing
+   * @returns op.just(value) or op.nothing()
+   */
+  match<R2, R3 = R2>(this: Just<R>, op: {
+    just: (value: R) => R2;
+    nothing: () => R3;
+  }): R2;
+  match<R2, R3 = R2>(this: Maybe<R>, op: {
+    just: (value: R) => R2;
+    nothing: () => R3;
+  }): R2 | R3;
+  matchMap<R2, R3 = R2>(this: Just<R>, op: {
+    just: (value: R) => R2;
+    nothing: () => R3;
+  }): Just<R2>;
+  matchMap<R2, R3 = R2>(this: Maybe<R>, op: {
+    just: (value: R) => R2;
+    nothing: () => R3;
+  }): Just<R2 | R3>;
+  /**
+   * Maybe composition function
+   *
+   * Applied to 'just value' returns 'op(value)'
+   * Applied to 'nothing' returns self without invoking composition function
+   *
+   * @template R2 transformer function result's underlying type
+   * @param op transformer to be invoked with underlying value
+   * @returns 'op(value)' or 'nothing'
+   */
+  chain<R2>(this: Just<R>, op: (value: R) => Just<R2>): Just<R2>;
+  chain<R2>(this: Just<R>, op: (value: R) => Nothing<R2>): Nothing<never>;
+  chain<R2>(this: Just<R>, op: (value: R) => Maybe<R2>): Maybe<R2>;
+  chain<R2>(this: Maybe<R>, op: (value: R) => Just<R2>): Maybe<R2>;
+  chain<R2>(this: Maybe<R>, op: (value: R) => Nothing<R2>): Nothing<never>;
+  chain<R2>(this: Maybe<R>, op: (value: R) => Maybe<R2>): Maybe<R2>;
+  /**
+   * Maybe fallback composition function
+   *
+   * Applied to 'just value' returns self without invoking composition function
+   * Applied to 'nothing' returns op()
+   *
+   * @template R2 transformer function result's underlying type
+   * @param op transformer to be invoked
+   * @returns 'just value' or 'op()'
+   */
+  orChain<R2>(this: Just<R>, op: () => Just<R2>): Just<R>;
+  orChain<R2>(this: Just<R>, op: () => Nothing<R2>): Just<R>;
+  orChain<R2>(this: Just<R>, op: () => Maybe<R2>): Just<R>;
+  orChain<R2>(this: Maybe<R>, op: () => Just<R2>): Just<R | R2>;
+  orChain<R2>(this: Maybe<R>, op: () => Nothing<R2>): Maybe<R>;
+  orChain<R2>(this: Maybe<R>, op: () => Maybe<R2>): Maybe<R | R2>;
+  /**
+   * Maybe pattern matching composition function
+   *
+   * Applied to 'just value' returns 'op.just(value)'
+   * Applied to 'nothing' returns op.nothing()
+   *
+   * @template R2 just transformer function result's underlying type
+   * @template R3 nothing transformer function result's underlying type
+   * @param op.just transformer to be invoked with underlying value in case of just
+   * @param op.nothing transformer to be invoked in case of nothing
+   * @returns 'op.just(value)' or 'op.nothing()'
+   */
+  matchChain<R2, R3 = R2>(this: Just<R>, op: {
+    just: (value: R) => Just<R2>;
+    nothing: () => Just<R3>;
+  }): Just<R2>;
+  matchChain<R2, R3 = R2>(this: Just<R>, op: {
+    just: (value: R) => Just<R2>;
+    nothing: () => Nothing<R3>;
+  }): Just<R2>;
+  matchChain<R2, R3 = R2>(this: Just<R>, op: {
+    just: (value: R) => Nothing<R2>;
+    nothing: () => Just<R3>;
+  }): Nothing<never>;
+  matchChain<R2, R3 = R2>(this: Just<R>, op: {
+    just: (value: R) => Nothing<R2>;
+    nothing: () => Nothing<R3>;
+  }): Nothing<never>;
+  matchChain<R2, R3 = R2>(this: Just<R>, op: {
+    just: (value: R) => Just<R2>;
+    nothing: () => Maybe<R3>;
+  }): Just<R2>;
+  matchChain<R2, R3 = R2>(this: Just<R>, op: {
+    just: (value: R) => Nothing<R2>;
+    nothing: () => Maybe<R3>;
+  }): Nothing<never>;
+  matchChain<R2, R3 = R2>(this: Just<R>, op: {
+    just: (value: R) => Maybe<R2>;
+    nothing: () => Just<R3>;
+  }): Maybe<R2>;
+  matchChain<R2, R3 = R2>(this: Just<R>, op: {
+    just: (value: R) => Maybe<R2>;
+    nothing: () => Nothing<R3>;
+  }): Maybe<R2>;
+  matchChain<R2, R3 = R2>(this: Just<R>, op: {
+    just: (value: R) => Maybe<R2>;
+    nothing: () => Maybe<R3>;
+  }): Maybe<R2>;
+  matchChain<R2, R3 = R2>(this: Maybe<R>, op: {
+    just: (value: R) => Just<R2>;
+    nothing: () => Just<R3>;
+  }): Just<R2 | R3>;
+  matchChain<R2, R3 = R2>(this: Maybe<R>, op: {
+    just: (value: R) => Just<R2>;
+    nothing: () => Nothing<R3>;
+  }): Maybe<R2>;
+  matchChain<R2, R3 = R2>(this: Maybe<R>, op: {
+    just: (value: R) => Nothing<R2>;
+    nothing: () => Just<R3>;
+  }): Maybe<R3>;
+  matchChain<R2, R3 = R2>(this: Maybe<R>, op: {
+    just: (value: R) => Nothing<R2>;
+    nothing: () => Nothing<R3>;
+  }): Nothing<never>;
+  matchChain<R2, R3 = R2>(this: Maybe<R>, op: {
+    just: (value: R) => Just<R2>;
+    nothing: () => Maybe<R3>;
+  }): Maybe<R2 | R3>;
+  matchChain<R2, R3 = R2>(this: Maybe<R>, op: {
+    just: (value: R) => Nothing<R2>;
+    nothing: () => Maybe<R3>;
+  }): Maybe<R3>;
+  matchChain<R2, R3 = R2>(this: Maybe<R>, op: {
+    just: (value: R) => Maybe<R2>;
+    nothing: () => Just<R3>;
+  }): Maybe<R2 | R3>;
+  matchChain<R2, R3 = R2>(this: Maybe<R>, op: {
+    just: (value: R) => Maybe<R2>;
+    nothing: () => Nothing<R3>;
+  }): Maybe<R2>;
+  matchChain<R2, R3 = R2>(this: Maybe<R>, op: {
+    just: (value: R) => Maybe<R2>;
+    nothing: () => Maybe<R3>;
+  }): Maybe<R2 | R3>;
+  /**
+   * Maybe type guard for 'just'
+   *
+   * @returns 'true' in case wrapped value exists (and resolves this type to be 'just')
+   *
+   * @example
+   * ```typescript
+   * if (maybe.isJust()) {
+   *   console.log(maybe.just);
+   * }
+   * ```
+   */
+  isJust(): this is Just<R>;
+  /**
+   * Maybe type guard for 'nothing'
+   *
+   * @returns 'true' in case wrapped value is 'nothing' (and resolves this type to be 'nothing')
+   *
+   * @example
+   * ```typescript
+   * if (maybe.isNothing()) {
+   *   console.log('nothing');
+   * }
+   * ```
+   */
+  isNothing(): this is Nothing<R>;
+  /**
+   * Wrap Maybe to singleton generator
+   *
+   * Useful in order to avoid ambiguous yield types
+   *
+   * @returns generator of Maybe wrapping this
+   */
+  generator: MaybeGeneratorFunction<[], R, Just<R>, R>;
+}
+/**
+ * Absolutely Nothing
+ *
+ * Maybe data type specialization representing an absence of any value
+ */
+export interface Nothing<R> {
+  /**
+   * Maybe peeker function
+   *
+   * Applied to 'just value' returns self invoking op(value) in process
+   * Applied to 'nothing' returns self without invoking callback
+   *
+   * @param op function to be invoked with underlying value
+   * @returns self
+   */
+  tap(op: (value: R) => void): this;
+  /**
+   * Maybe fallback peeker function
+   *
+   * Applied to 'just value' returns self without invoking callback
+   * Applied to 'nothing' returns self invoking op() in process
+   *
+   * @param op function to be invoked
+   * @returns self
+   */
+  orTap(op: () => void): this;
+  /**
+   * Maybe pattern matching peeker function
+   *
+   * Applied to 'just value' returns self invoking op.just(value) in process
+   * Applied to 'nothing' returns self invoking op.nothing() in process
+   *
+   * @param op.just function to be invoked with underlying value in case of just
+   * @param op.nothing function to be invoked in case of nothing
+   * @returns self
+   */
+  matchTap(op: {
+    just: (value: R) => void;
+    nothing: () => void;
+  }): this;
+  /**
+   * Maybe transformer function
+   *
+   * Applied to 'just value' returns 'just op(value)'
+   * Applied to 'nothing' returns self without invoking transformer
+   *
+   * @template R2 transformer function's return type
+   * @param op transformer to be invoked with underlying value
+   * @returns 'just op(value)' or 'nothing'
+   */
+  map<R2>(this: Nothing<R>, op: (value: R) => R2): Nothing<never>;
+  map<R2>(this: Maybe<R>, op: (value: R) => R2): Maybe<R2>;
+  /**
+   * Maybe fallback transformer function
+   *
+   * Applied to 'just value' returns self without invoking transformer
+   * Applied to 'nothing' returns 'just op()'
+   *
+   * @param op function to be invoked
+   * @returns 'just value' or 'just op()'
+   */
+  orMap<R2>(this: Nothing<R>, op: () => R2): Just<R2>;
+  orMap<R2>(this: Maybe<R>, op: () => R2): Just<R | R2>;
+  /**
+   * Maybe pattern matching extractor function
+   *
+   * Applied to 'just value' returns op.just(value)
+   * Applied to 'nothing' returns op.nothing()
+   *
+   * @template R2 just extractor function's return type
+   * @template R3 nothing extractor function's return type
+   * @param op.just extractor to be invoked with underlying value in case of just
+   * @param op.nothing extractor to be invoked in case of nothing
+   * @returns op.just(value) or op.nothing()
+   */
+  match<R2, R3 = R2>(this: Nothing<R>, op: {
+    just: (value: R) => R2;
+    nothing: () => R3;
+  }): R3;
+  match<R2, R3 = R2>(this: Maybe<R>, op: {
+    just: (value: R) => R2;
+    nothing: () => R3;
+  }): R2 | R3;
+  matchMap<R2, R3 = R2>(this: Nothing<R>, op: {
+    just: (value: R) => R2;
+    nothing: () => R3;
+  }): Just<R3>;
+  matchMap<R2, R3 = R2>(this: Maybe<R>, op: {
+    just: (value: R) => R2;
+    nothing: () => R3;
+  }): Just<R2 | R3>;
+  /**
+   * Maybe composition function
+   *
+   * Applied to 'just value' returns 'op(value)'
+   * Applied to 'nothing' returns self without invoking composition function
+   *
+   * @template R2 transformer function result's underlying type
+   * @param op transformer to be invoked with underlying value
+   * @returns 'op(value)' or 'nothing'
+   */
+  chain<R2>(this: Nothing<R>, op: (value: R) => Just<R2>): Nothing<never>;
+  chain<R2>(this: Nothing<R>, op: (value: R) => Nothing<R2>): Nothing<never>;
+  chain<R2>(this: Nothing<R>, op: (value: R) => Maybe<R2>): Nothing<never>;
+  chain<R2>(this: Maybe<R>, op: (value: R) => Just<R2>): Maybe<R2>;
+  chain<R2>(this: Maybe<R>, op: (value: R) => Nothing<R2>): Nothing<never>;
+  chain<R2>(this: Maybe<R>, op: (value: R) => Maybe<R2>): Maybe<R2>;
+  /**
+   * Maybe fallback composition function
+   *
+   * Applied to 'just value' returns self without invoking composition function
+   * Applied to 'nothing' returns op()
+   *
+   * @template R2 transformer function result's underlying type
+   * @param op transformer to be invoked
+   * @returns 'just value' or 'op()'
+   */
+  orChain<R2>(this: Nothing<R>, op: () => Just<R2>): Just<R2>;
+  orChain<R2>(this: Nothing<R>, op: () => Nothing<R2>): Nothing<never>;
+  orChain<R2>(this: Nothing<R>, op: () => Maybe<R2>): Maybe<R2>;
+  orChain<R2>(this: Maybe<R>, op: () => Just<R2>): Just<R | R2>;
+  orChain<R2>(this: Maybe<R>, op: () => Nothing<R2>): Maybe<R>;
+  orChain<R2>(this: Maybe<R>, op: () => Maybe<R2>): Maybe<R | R2>;
+  /**
+   * Maybe pattern matching composition function
+   *
+   * Applied to 'just value' returns 'op.just(value)'
+   * Applied to 'nothing' returns op.nothing()
+   *
+   * @template R2 just transformer function result's underlying type
+   * @template R3 nothing transformer function result's underlying type
+   * @param op.just transformer to be invoked with underlying value in case of just
+   * @param op.nothing transformer to be invoked in case of nothing
+   * @returns 'op.just(value)' or 'op.nothing()'
+   */
+  matchChain<R2, R3 = R2>(this: Nothing<R>, op: {
+    just: (value: R) => Just<R2>;
+    nothing: () => Just<R3>;
+  }): Just<R3>;
+  matchChain<R2, R3 = R2>(this: Nothing<R>, op: {
+    just: (value: R) => Just<R2>;
+    nothing: () => Nothing<R3>;
+  }): Nothing<never>;
+  matchChain<R2, R3 = R2>(this: Nothing<R>, op: {
+    just: (value: R) => Nothing<R2>;
+    nothing: () => Just<R3>;
+  }): Just<R3>;
+  matchChain<R2, R3 = R2>(this: Nothing<R>, op: {
+    just: (value: R) => Nothing<R2>;
+    nothing: () => Nothing<R3>;
+  }): Nothing<never>;
+  matchChain<R2, R3 = R2>(this: Nothing<R>, op: {
+    just: (value: R) => Just<R2>;
+    nothing: () => Maybe<R3>;
+  }): Maybe<R3>;
+  matchChain<R2, R3 = R2>(this: Nothing<R>, op: {
+    just: (value: R) => Nothing<R2>;
+    nothing: () => Maybe<R3>;
+  }): Maybe<R3>;
+  matchChain<R2, R3 = R2>(this: Nothing<R>, op: {
+    just: (value: R) => Maybe<R2>;
+    nothing: () => Just<R3>;
+  }): Just<R3>;
+  matchChain<R2, R3 = R2>(this: Nothing<R>, op: {
+    just: (value: R) => Maybe<R2>;
+    nothing: () => Nothing<R3>;
+  }): Nothing<never>;
+  matchChain<R2, R3 = R2>(this: Nothing<R>, op: {
+    just: (value: R) => Maybe<R2>;
+    nothing: () => Maybe<R3>;
+  }): Maybe<R3>;
+  matchChain<R2, R3 = R2>(this: Maybe<R>, op: {
+    just: (value: R) => Just<R2>;
+    nothing: () => Just<R3>;
+  }): Just<R2 | R3>;
+  matchChain<R2, R3 = R2>(this: Maybe<R>, op: {
+    just: (value: R) => Just<R2>;
+    nothing: () => Nothing<R3>;
+  }): Maybe<R2>;
+  matchChain<R2, R3 = R2>(this: Maybe<R>, op: {
+    just: (value: R) => Nothing<R2>;
+    nothing: () => Just<R3>;
+  }): Maybe<R3>;
+  matchChain<R2, R3 = R2>(this: Maybe<R>, op: {
+    just: (value: R) => Nothing<R2>;
+    nothing: () => Nothing<R3>;
+  }): Nothing<never>;
+  matchChain<R2, R3 = R2>(this: Maybe<R>, op: {
+    just: (value: R) => Just<R2>;
+    nothing: () => Maybe<R3>;
+  }): Maybe<R2 | R3>;
+  matchChain<R2, R3 = R2>(this: Maybe<R>, op: {
+    just: (value: R) => Nothing<R2>;
+    nothing: () => Maybe<R3>;
+  }): Maybe<R3>;
+  matchChain<R2, R3 = R2>(this: Maybe<R>, op: {
+    just: (value: R) => Maybe<R2>;
+    nothing: () => Just<R3>;
+  }): Maybe<R2 | R3>;
+  matchChain<R2, R3 = R2>(this: Maybe<R>, op: {
+    just: (value: R) => Maybe<R2>;
+    nothing: () => Nothing<R3>;
+  }): Maybe<R2>;
+  matchChain<R2, R3 = R2>(this: Maybe<R>, op: {
+    just: (value: R) => Maybe<R2>;
+    nothing: () => Maybe<R3>;
+  }): Maybe<R2 | R3>;
+  /**
+   * Maybe type guard for 'just'
+   *
+   * @returns 'true' in case wrapped value exists (and resolves this type to be 'just')
+   *
+   * @example
+   * ```typescript
+   * if (maybe.isJust()) {
+   *   console.log(maybe.just);
+   * }
+   * ```
+   */
+  isJust(): this is Just<R>;
+  /**
+   * Maybe type guard for 'nothing'
+   *
+   * @returns 'true' in case wrapped value is 'nothing' (and resolves this type to be 'nothing')
+   *
+   * @example
+   * ```typescript
+   * if (maybe.isNothing()) {
+   *   console.log('nothing');
+   * }
+   * ```
+   */
+  isNothing(): this is Nothing<R>;
+  /**
+   * Wrap Maybe to singleton generator
+   *
+   * Useful in order to avoid ambiguous yield types
+   *
+   * @returns generator of Maybe wrapping this
+   */
+  generator: MaybeGeneratorFunction<[], R, Nothing<R>, R>;
+}
+/**
+ * Generic Maybe monad interface
+ *
+ * As per classic Maybe monad implementation can either contain just a value or contain nothing
+ * Used throughout the library to represent optional return type, specifically return type of cancelled tasks
+ *
+ * @template R underlying value
+ */
+export type Maybe<R> = Just<R> | Nothing<R>;
+export declare namespace Just {
+  /**
+   * Standalone Just value extractor
+   *
+   * Useful for passing as a function to collection transformers
+   *
+   * @template R underlying value type
+   * @param just Just instance
+   * @returns underlying value
+   */
+  function just<R>(just: Just<R>): R;
+}
+export declare namespace Nothing {}
+export type MaybeGenerator<T, TT extends Maybe<T>, R> = Generator<TT, R, T>;
+export type MaybeGeneratorFunction<A extends unknown[], T, TT extends Maybe<T>, R> = (...args: A) => MaybeGenerator<T, TT, R>;
+export declare namespace Maybe {
+  /**
+   * Non-empty monad constructor
+   *
+   * @template R underlying type
+   * @param value underlying value
+   * @returns 'just value'
+   */
+  function just<R>(value: R): Just<R>;
+  /**
+   * Empty monad constructor
+   *
+   * @returns 'nothing'
+   */
+  function nothing<R = never>(): Nothing<R>;
+  /**
+   * Maybe constructor from optional value
+   *
+   * Resolves to 'nothing' in case of undefined value and 'just value' otherwise
+   *
+   * @param value possibly undefined value
+   * @returns either 'just value' or 'nothing'
+   */
+  function fromOptional(value: undefined): Nothing<never>;
+  function fromOptional<R>(value: Exclude<R, undefined>): Just<R>;
+  function fromOptional<R>(value: R | undefined): Maybe<R>;
+  /**
+   * Maybe constructor from optional or nullable value
+   *
+   * Resolves to 'nothing' in case of undefined or null value and 'just value' otherwise
+   *
+   * @param value possibly undefined value
+   * @returns either 'just value' or 'nothing'
+   */
+  function fromNullable(value: undefined): Nothing<never>;
+  function fromNullable(value: null): Nothing<never>;
+  function fromNullable<R>(value: Exclude<R, null | undefined>): Just<R>;
+  function fromNullable<R>(value: R | null | undefined): Maybe<R>;
+  /**
+   * Standalone Maybe value extractor
+   *
+   * Applied to 'just value' returns underlying value without using fallback
+   * Applied to 'nothing' returns fallback
+   *
+   * @template R underlying value type
+   * @template R2 fallback value type
+   * @param maybe Maybe instance
+   * @param fallback value to be returned in case of 'nothing'
+   * @returns underlying value or fallback
+   */
+  function fromMaybe<R>(maybe: Just<R>, fallback: unknown): R;
+  function fromMaybe<R, R2>(maybe: Nothing<R>, fallback: R2): R2;
+  function fromMaybe<R, R2>(maybe: Maybe<R>, fallback: R2): R | R2;
+  /**
+   * Standalone type guard for 'just'
+   *
+   * Useful for passing as a predicate to collection transformers
+   *
+   * @template R underlying value type
+   * @param maybe Maybe instance
+   * @returns 'true' in case wrapped value exists (and resolves argument type to be 'just')
+   */
+  function isJust<R>(maybe: Maybe<R>): maybe is Just<R>;
+  /**
+   * Standalone type guard for 'nothing'
+   *
+   * Useful for passing as a predicate to collection transformers
+   *
+   * @template R underlying value type
+   * @param maybe Maybe instance
+   * @returns 'true' in case wrapped value is 'nothing' (and resolves argument type to be 'nothing')
+   */
+  function isNothing<R>(maybe: Maybe<R>): maybe is Nothing<R>;
+  /**
+   * Standalone list predicate
+   *
+   * @param maybes a list of Maybe
+   * @returns true in case every list element is Just
+   */
+  function everyJust<R>(maybes: Maybe<R>[]): maybes is Just<R>[];
+  /**
+   * Standalone list predicate
+   *
+   * @param maybes a list of Maybe
+   * @returns true in case at least one list element is Just
+   */
+  function someJust<R>(maybes: Maybe<R>[]): boolean;
+  /**
+   * Standalone list predicate
+   *
+   * @param maybes a list of Maybe
+   * @returns true in case every list element is Nothing
+   */
+  function everyNothing<R>(maybes: Maybe<R>[]): maybes is Nothing<never>[];
+  /**
+   * Standalone list predicate
+   *
+   * @param maybes a list of Maybe
+   * @returns true in case at least one list element is Nothing
+   */
+  function someNothing<R>(maybes: Maybe<R>[]): boolean;
+  /**
+   * Create compound Maybe 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 convenient option for typescript is to use ```yield* maybe.generator()``` as otherwise 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 Maybe<T>, R>(maybeGeneratorFunction: MaybeGeneratorFunction<[], T, TT, R>): Maybe<R>;
+}
+//#endregion
+//#region src/either.d.ts
+/**
+ * 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 always 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 extractor function
+   *
+   * Applied to 'right value' returns op.right(value)
+   * Applied to 'left error' returns op.left(error)
+   *
+   * @template R2 right extractor function's return type
+   * @template R3 left extractor function's return type
+   * @param op.right extractor to be invoked with underlying value in case of 'right'
+   * @param op.left extractor to be invoked with underlying error in case of 'left'
+   * @returns op.right(value) or op.left(error)
+   */
+  match<R2, R3 = R2>(this: Right<R, L>, op: {
+    right: (value: R) => R2;
+    left: (error: L) => R3;
+  }): R2;
+  match<R2, R3 = R2>(this: Either<R, L>, op: {
+    right: (value: R) => R2;
+    left: (error: L) => R3;
+  }): R2 | R3;
+  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 error
+   * @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 Either to singleton generator
+   *
+   * Useful in order to avoid ambiguous yield types
+   *
+   * @returns generator of Either wrapping this
+   */
+  generator: EitherGeneratorFunction<[], R, Right<R, L>, R>;
+}
+/**
+ * Left (erroneous) value of type L
+ *
+ * Either data type specialization representing an erroneous value
+ *
+ * @template R underlying value type (needed for type merging, in fact always 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 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: 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 extractor function
+   *
+   * Applied to 'right value' returns op.right(value)
+   * Applied to 'left error' returns op.left(error)
+   *
+   * @template R2 right extractor function's return type
+   * @template R3 left extractor function's return type
+   * @param op.right extractor to be invoked with underlying value in case of 'right'
+   * @param op.left extractor to be invoked with underlying error in case of 'left'
+   * @returns op.right(value) or op.left(error)
+   */
+  match<R2, R3 = R2>(this: Left<R, L>, op: {
+    right: (value: R) => R2;
+    left: (error: L) => R3;
+  }): R3;
+  match<R2, R3 = R2>(this: Either<R, L>, op: {
+    right: (value: R) => R2;
+    left: (error: L) => R3;
+  }): R2 | R3;
+  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 error
+   * @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 Either to singleton generator
+   *
+   * Useful in order to avoid ambiguous yield types
+   *
+   * @returns generator of Either 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 either 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
+   *
+   * Useful 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
+   *
+   * Useful 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 Either value extractor
+   *
+   * Applied to 'right value' returns underlying value without using fallback
+   * Applied to 'left error' returns fallback
+   *
+   * @template R underlying value type
+   * @template L underlying error type
+   * @template R2 fallback value type
+   * @param either Either instance
+   * @param fallback value to be returned in case of 'left error'
+   * @returns underlying value or fallback
+   */
+  function fromEither<R, L>(either: Right<R, L>, fallback: unknown): R;
+  function fromEither<R, L, R2>(either: Left<R, L>, fallback: R2): R2;
+  function fromEither<R, L, R2>(either: Either<R, L>, fallback: R2): R | R2;
+  /**
+   * Standalone type guard for 'right'
+   *
+   * Useful 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'
+   *
+   * Useful 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 an Either within the generator function unwraps the Either and returns underlying value in case of success
+   * However the convenient option for typescript is to use ```yield* either.generator()``` as otherwise one may have to deal with union types
+   *
+   * @template TT yielded Either type
+   * @template R returned underlying type
+   * @param eitherGeneratorFunction Either generator function
+   * @returns Right wrapping the result of generator function or Left
+   */
+  function generate<T, TT extends Either<T, any>, R>(eitherGeneratorFunction: EitherGeneratorFunction<[], T, TT, R>): Either<R, any>;
+}
+//#endregion
+//#region src/task.d.ts
+/**
+ * Shortcut for monadic Either type, where erroneous value is of type any
+ *
+ * @template R underlying type
+ */
+export type Rejectable<R> = Either<R, any>;
+/**
+ * Shortcut for underlying task result type
+ *
+ * @template R underlying type
+ */
+export type Cancelable<R> = Maybe<Rejectable<R>>;
+/**
+ * Function returning Task
+ *
+ * @template A argument types
+ * @template R returned task resolve type
+ */
+export type TaskFunction<A extends unknown[], R> = (...args: A) => Task<R>;
+/**
+ * Task generator
+ *
+ * @template TT yielded task type
+ * @template R returned task resolve type
+ *
+ * @example
+ * ```typescript
+ * const generatorFunction = function*(): TaskGenerator<unknown, Task<string>, number> {
+ *   const v = yield* someTaskFunction().generator();
+ *
+ *   return v.length;
+ * };
+ * ```
+ */
+export type TaskGenerator<T, TT extends Task<T>, R> = Generator<TT, R, T>;
+/**
+ * Function returning task generator (generator function)
+ *
+ * @template A argument types
+ * @template TT yielded task type
+ * @template R returned task resolve type
+ *
+ * @example
+ * ```typescript
+ * const generatorFunction: TaskGeneratorFunction<[], unknown, Task<string>, number> = function*() {
+ *   const v = yield* someTaskFunction().generator();
+ *
+ *   return v.length;
+ * };
+ * ```
+ */
+export type TaskGeneratorFunction<A extends unknown[], T, TT extends Task<T>, R> = (...args: A) => TaskGenerator<T, TT, R>;
+/**
+ * Task monad interface
+ *
+ * @template R task resolve type
+ */
+export interface Task<R> extends TaskBase<R> {
+  /**
+   * Invoke callback when task is resolved (and only then)
+   *
+   * @param op callback to invoke
+   * @returns self
+   */
+  tap(op: (value: R) => void): Task<R>;
+  /**
+   * Invoke callback when task is rejected (and only then)
+   *
+   * @param op callback to invoke
+   * @returns self
+   */
+  tapRejected(op: (error: any) => void): Task<R>;
+  /**
+   * Invoke callback when task is canceled (and only then)
+   *
+   * @param op callback to invoke
+   * @returns self
+   */
+  tapCanceled(op: () => void): Task<R>;
+  /**
+   * Invoke a dedicated callback according to task resolution
+   *
+   * @param op.resolved callback to invoke on success
+   * @param op.rejected callback to invoke on failure
+   * @param op.canceled callback to invoke on cancelation
+   * @returns self
+   */
+  matchTap(op: {
+    resolved: (value: R) => void;
+    rejected: (error: any) => void;
+    canceled: () => void;
+  }): Task<R>;
+  /**
+   * Invoke transformer when task is resolved (and only then) and return it's result instead
+   *
+   * @template R2 transformer return type
+   * @param op transformer to invoke
+   * @returns task returning transformer result
+   */
+  map<R2>(op: (value: R) => R2): Task<R2>;
+  /**
+   * Invoke transformer when task is rejected (and only then) and return it's result instead
+   *
+   * @template R2 fallback return type
+   * @param op transformer to invoke
+   * @returns task returning fallback result in case of failure
+   */
+  mapRejected<R2>(op: (error: any) => R2): Task<R | R2>;
+  /**
+   * Invoke transformer when task is canceled (and only then) and return it's result instead
+   *
+   * @template R2 fallback return type
+   * @param op transformer to invoke
+   * @returns task returning fallback result in case of cancelation
+   */
+  mapCanceled<R2>(op: () => R2): Task<R | R2>;
+  /**
+   * Invoke a dedicated transformer according to task resolution
+   *
+   * @template R2 success transformer return type
+   * @template R3 failure transformer return type
+   * @template R4 cancelation transformer return type
+   * @param op.resolved transformer to invoke on success
+   * @param op.rejected transformer to invoke on failure
+   * @param op.canceled transformer to invoke on cancelation
+   * @returns task resolving to a corresponding transformer result
+   */
+  matchMap<R2, R3 = R2, R4 = R3>(op: {
+    resolved: (value: R) => R2;
+    rejected: (error: any) => R3;
+    canceled: () => R4;
+  }): Task<R2 | R3 | R4>;
+  /**
+   * Invoke transformer when task is resolved (and only then) and continue execution with it's result
+   *
+   * @template R2 transformer task resolve type
+   * @param op transformer to invoke
+   * @returns task chaining to transformer result task
+   */
+  chain<R2>(op: (value: R) => Task<R2>): Task<R2>;
+  /**
+   * Invoke transformer when task is rejected (and only then) and continue execution with it's result
+   *
+   * @template R2 fallback task resolve type
+   * @param op transformer to invoke
+   * @returns task chaining to fallback task in case of failure
+   */
+  chainRejected<R2>(op: (error: any) => Task<R2>): Task<R | R2>;
+  /**
+   * Invoke transformer when task is canceled (and only then) and continue execution with it's result
+   *
+   * @template R2 fallback task resolve type
+   * @param op transformer to invoke
+   * @returns task chaining to fallback task in case of cancelation
+   */
+  chainCanceled<R2>(op: () => Task<R2>): Task<R | R2>;
+  /**
+   * Invoke a dedicated transformer according to task resolution and continue execution with it's result
+   *
+   * @template R2 success transformer resolve type
+   * @template R3 failure transformer resolve type
+   * @template R4 cancelation transformer resolve type
+   * @param op.resolved transformer to invoke on success
+   * @param op.rejected transformer to invoke on failure
+   * @param op.canceled transformer to invoke on cancelation
+   * @returns task chaining to a corresponding transformer result
+   */
+  matchChain<R2, R3 = R2, R4 = R3>(op: {
+    resolved: (value: R) => Task<R2>;
+    rejected: (error: any) => Task<R3>;
+    canceled: () => Task<R4>;
+  }): Task<R2 | R3 | R4>;
+  resolved: () => Cancelable<R> | null;
+  /**
+   * Return underlying promise in order to await result
+   *
+   * @returns underlying promise
+   */
+  resolve: () => TaskInvoke<R>;
+  /**
+   * Invoke underlying canel method without error
+   */
+  cancel: () => boolean;
+  /**
+   * Invoke underlying canel method with error
+   *
+   * @param error error value to be injected from outside
+   */
+  reject: (error: any) => boolean;
+  /**
+   * Wrap task to singleton generator
+   *
+   * Userful in order to avoid ambiguous yied types
+   *
+   * @returns generator of task wrapping the task
+   * @example
+   * ```typescript
+   * const getString = () => Task.resolved('hello');
+   * const getLength = (data: string) => Task.resolved(data.length);
+   *
+   * // ..... //
+   *
+   * Task.generate(function* () {
+   *   const data = yield getString(); // data: string | number
+   *   const length = yield getLength(data); // length: string | number
+   *
+   *   return length;
+   * });
+   *
+   * // ..... //
+   *
+   * Task.generate(function* () {
+   *   const data = yield* getString().generator(); // data: string
+   *   const length = yield* getLength(data).generator(); // length: number
+   *
+   *   return length;
+   * });
+   * ```
+   */
+  generator: TaskGeneratorFunction<[], unknown, Task<R>, R>;
+}
+export declare namespace Task {
+  /**
+   * Custom task monad constructor
+   *
+   * @template R returned task's resolve type
+   * @param invoke promise defining task execution
+   * @param cancel cancelation function
+   * @returns task resolving to resolve value of invoke
+   *
+   * @note low-level primitive for creating custom tasks, not intended for general use
+   */
+  function create<R>(invoke: TaskInvoke<R>, cancel: TaskCancel): Task<R>;
+  /**
+   * Invariant task constructor creating resolved task from plain value
+   *
+   * @template R returned task's resolve type
+   * @param value value to be returned upon awaiting
+   * @returns task resolving to specified value
+   */
+  function resolved<R>(value: R): Task<R>;
+  /**
+   * Invariant task constructor creating rejected task from error value
+   *
+   * @template R returned task's resolve type
+   * @param error error to be returned upon awaiting
+   * @returns task resolving to specified value
+   */
+  function rejected<R>(error: any): Task<R>;
+  /**
+   * Invariant task constructor creating canceled task
+   *
+   * @template R returned task's resolve type
+   * @returns task resolving to specified value
+   */
+  function canceled<R>(): Task<R>;
+  /**
+   * Lift from promise to task resolving to that promise result
+   *
+   * Userfull for converting promises to tasks
+   * If converted task is canceled or failed externally return value will be ignored without side-effects
+   * All tasks are no-trowing by default, any occured errors are returned as Left<any>
+   *
+   * @template R returned task resolve type
+   * @param promise promise to be resolved
+   * @returns task resolving to specified promise value
+   *
+   * @example
+   * ```typescript
+   * const task = Task.fromPromise(someAsyncOperation('someData')).map((result) => result.length);
+   * ```
+   */
+  function fromPromise<R>(promise: PromiseLike<R>): Task<R>;
+  /**
+   * Lift from sync function to task resolving to said function result
+   *
+   * Generally, functions are not considered tasks as they cannot be interrupted in any way
+   * However there may be cases when impure function performs actions leading to cancelling or failing the task they are called from
+   * Without such wrapper such cases would lead to ignoring said cancelation and continuilg task chain
+   * This function is mostly used internally and is not expected to be widely used except of some edge scenarios
+   *
+   * If converted task is canceled or failed externally return value will be ignored without side-effects
+   * All tasks are no-trowing by default, any occured errors are returned as Left<any>
+   *
+   * @template R returned task resolve type
+   * @param producer function to be wrapped to a task
+   * @param cancelRef reference object allowing to set cancelation function prior to invoking function
+   * @returns task resolving to the specified function's result
+   *
+   * @example
+   * ```typescript
+   * const cancelRef = { cancel: () => {} };
+   *
+   * const task = Task.fromFunction(() => someFunction('someData'), cancelRef).map((result) => result.length);
+   * ```
+   */
+  function fromFunction<R>(producer: () => R, cancelRef: {
+    cancel: TaskCancel;
+  }): Task<R>;
+  /**
+   * Generic callback task
+   *
+   * Usefull for creating custom tasks from success and error callbacks and cancelaton function. Synchronous callbacks are not supported, @see fromFuction
+   *
+   * @param create task body with success and error callbacks
+   * @param cancel cancelation function intended for stopping task execution
+   * @returns task resolving to success value
+   *
+   * @example
+   * ```typescript
+   * export function timeout(delay: number) {
+   *   return fromCallback<NodeJS.Timeout, void>((resolve) => setTimeout(() => resolve(), delay), clearTimeout);
+   * }
+   * ```
+   */
+  function fromCallback<H, R>(create: (resolve: (result: R) => void, reject: (error: any) => void, cancel: () => void) => H, onCancel: (handler: H) => void): Task<R>;
+  /**
+   * Lift an async operation that accepts an AbortSignal into a Task.
+   *
+   * Creates an internal AbortController and passes its signal to `producer`.
+   * If the resulting task is canceled or rejected externally, `controller.abort()`
+   * is called automatically.
+   *
+   * @template R returned task resolve type
+   * @param producer factory function receiving an AbortSignal
+   * @returns task wrapping the operation
+   *
+   * @example
+   * ```typescript
+   * const fetchUser = (id: string) =>
+   *   Task.fromAbortSignal((signal) =>
+   *     fetch(`/api/users/${id}`, { signal }).then((res) => res.json())
+   *   );
+   * ```
+   */
+  function fromAbortSignal<R>(producer: (signal: AbortSignal) => PromiseLike<R>): Task<R>;
+  /**
+   * Convinience shortcut for yielding async functions as tasks
+   *
+   * @template R returned generator resolve type
+   * @param promise promise to be resolved
+   * @returns generator to be be used with yield*
+   */
+  function promiseGenerator<R>(promise: PromiseLike<R>): TaskGenerator<unknown, Task<R>, R>;
+  /**
+   * Convinience shortcut for yielding timers
+   *
+   * @template R returned generator resolve type
+   * @param promise promise to be resolved
+   * @returns generator to be be used with yield*
+   */
+  function timeoutGenerator(delay: number): TaskGenerator<unknown, Task<void>, void>;
+  /**
+   * Lift from function returning value/promise to function returning task resolving to that value
+   *
+   * Userfull for converting exising async functions to task functions for further use
+   *
+   * @template A returned function's argument types
+   * @template R returned function's result task's resolve type
+   * @param promiseFunction function returning promise or plain value to be resolved
+   * @returns task function wrapping specified promise function
+   * @see Task.fromPromise
+   *
+   * @example
+   * ```typescript
+   * const taskFunction = liftPromiseFunction(someAsyncOperation);
+   *
+   * const task = taskFunction('someData').map((result) => result.length);
+   * ```
+   */
+  function lift<A extends unknown[], R>(promiseFunction: (...args: A) => PromiseLike<R>): TaskFunction<A, R>;
+  /**
+   * Create compound task from generator function
+   *
+   * Applying yield to task within the generator function awaits the task and returns underlying value in case of success
+   * However the convinient option for typescript is to use ```yield* task.generator()``` as othervise one may have to deal with union types
+   *
+   * In case of failure an error is thrown and may be caught by try-catch
+   *
+   * If error is not caught the task is interrupted and returns 'just left error' immediately. In case of cancelation the task is interrupted and returns 'nothing' immediately
+   *
+   * @template TT yielded task type
+   * @template R returned task resolve type
+   * @param taskGeneratorFunction task generator function
+   * @returns task resolving to generator's return type
+   *
+   * @note compound task execution is interrupted only at yield statements, so despite returning immediately any promise-based chains would continue running until the first yield
+   * @note due to type unpredictability you HAVE to use ```.generator()``` together with yield* to avoid type issues, despite the fact that task may be yielded directly
+   *
+   * @example
+   * ```typescript
+   * const task = Task.generate(function*() {
+   *   try {
+   *     const value1 = yield* delayedValueTask('data', 400).generator();
+   *
+   *     const value2 = yield* delayedValueTask(value1.length, 300).generator();
+   *
+   *     return value2;
+   *   } catch (e) {
+   *     return -1;
+   *   }
+   * });
+   * ```
+   */
+  function generate<T, TT extends Task<T>, R>(taskGeneratorFunction: TaskGeneratorFunction<[], T, TT, R>): Task<R>;
+  /**
+   * Task function generator
+   *
+   * Simplifies wrighting functions returning generated tasks
+   *
+   * @template Args generator arguments
+   * @template TT yielded task type
+   * @template R returned task resolve type
+   * @param taskGeneratorFunction function* (...args) task generator function
+   * @returns task resolving to generator's return type
+   */
+  function generateFunction<A extends any[], T, TT extends Task<T>, R>(taskGeneratorFunction: TaskGeneratorFunction<A, T, TT, R>): TaskFunction<A, R>;
+  /**
+   * Generic timeout task
+   *
+   * Usefull for creating delays in task chains or implementing limiting tasks
+   *
+   * @param delay duration in ms after that the task resolves to void
+   * @returns task resolving to void (undefined) after specified delay
+   *
+   * @example
+   * ```typescript
+   * const delayedValueTask = <T>(value: T, delay: number) => Task.timeout(delay).map(() => value);
+   * // ... //
+   * const value = yield* delayedValueTask(42, 1000).generator();
+   *
+   * console.log("It's past 1 second and here's a value:", value)
+   * ```
+   */
+  function timeout(delay: number): Task<void>;
+  /**
+   * Start multiple tasks one after another
+   *
+   * @param taskFunctions list of task functions (without arguments)
+   * @returns composite task invoring every task in order and resolving to the list of results
+   */
+  function sequence<T>(taskFunctions: Iterable<TaskFunction<[], T>>): Task<T[]>;
+  /**
+   * Execute all tasks in parallel and return list of results
+   *
+   * Resulting task resolves when all tasks are resolved, returning list of tasks results maintaining result order
+   * In case of failure (external or internal) resulting task is immediately immediately rejected with that error and all pending tasks are canceled
+   * In case of cancelation resulting task is immediately immediately canceled together with all pending tasks
+   *
+   * @note direct equivalent of Promise.all
+   *
+   * @template T underlying task type
+   * @param tasks iterable of tasks to execute
+   * @retuirns task resolving to the list of results
+   */
+  function all<T>(tasks: Iterable<Task<T>>): Task<T[]>;
+  /**
+   * Execute all tasks in parallel and return the result of the first successful one
+   *
+   * Resulting task resolves when the first tasks is successfuly resolved, returning it's result
+   * In case of external task rejecttion all tasks are rejected with that error and resulting task is rejected with an array of errors
+   * In case of internal task rejection the execution is continued untill fthe first task resolves succesfully or all the tasks are rejected this way resulting task is rejected with an array of errors
+   * In case of cancelation resulting task is immediately immediately canceled together with all pending tasks
+   *
+   * @note direct equivalent of Promise.any
+   *
+   * @template T underlying task type
+   * @param tasks iterable of tasks to execute
+   * @retuirns task resolving to the result of first successfull task
+   */
+  function any<T>(tasks: Iterable<Task<T>>): Task<unknown>;
+  /**
+   * Limit task execution based on another task
+   *
+   * If the second task resolves sooner than the first, resulting task is canceled
+   * Otherwise the resulting task resolves together with the first one
+   *
+   * @param task task to limit
+   * @param limitTask limiting task
+   * @returns task limites according to limitTask
+   */
+  function limit<T>(task: Task<T>, limitTask: Task<void>): Task<unknown>;
+  /**
+   * Repeat task untill successful
+   *
+   * Given task is re-generated in case of failure (both external and internal)
+   * Resulting task is still cancelable by standard means
+   *
+   * @param taskFunction task preoducing function
+   */
+  function repeat<T>(taskFunction: TaskFunction<[], T>): Task<T>;
+}
+type TaskInvoke<R> = Promise<Cancelable<R>>;
+type TaskCancel = (error: Maybe<any>) => boolean;
+/**
+ * @hidden
+ */
+interface TaskBase<R> {
+  _invoke(op: (result: Cancelable<R>) => void): void;
+  _cancel(error: Maybe<any>): boolean;
+}
+//#endregion
+//# sourceMappingURL=t-tasks.d.ts.map