t-tasks 1.0.1 → 1.0.2

package/src/either.ts

@@ -41,7 +41,7 @@ export interface Right<R, L> {
    * @param op.left function to be invoked with underlying error in case of 'left'
    * @returns self
    */
-  matchTap(op: { right: (value: R) => void; left: (error: any) => void }): this;
+  matchTap(op: { right: (value: R) => void; left: (error: L) => void }): this;
 
   /**
    * Either transformer function
@@ -85,9 +85,9 @@ export interface Right<R, L> {
    * @returns 'right op.right(value)' or 'right op.left(error)'
    */
   // Right case
-  matchMap<R2, R3 = R2>(this: Right<R, L>, op: { right: (value: R) => R2; left: (error: any) => R3 }): Right<R2, never>;
+  matchMap<R2, R3 = R2>(this: Right<R, L>, op: { right: (value: R) => R2; left: (error: L) => R3 }): Right<R2, never>;
   // General case
-  matchMap<R2, R3 = R2>(this: Either<R, L>, op: { right: (value: R) => R2; left: (error: any) => R3 }): Right<R2 | 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
@@ -144,25 +144,25 @@ export interface Right<R, L> {
    * @returns 'op(value)' or 'op(error)'
    */
   // Right cases
-  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Right<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: any) => 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: any) => 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: any) => 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: any) => 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: any) => 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: any) => 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: any) => 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: any) => 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: any) => Either<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) => 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>;
   // General cases
-  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: any) => 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: any) => 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: any) => 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: any) => 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: any) => 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: any) => 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: any) => 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: any) => 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: any) => Either<R3, L3> }): Either<R2 | R3, L2 | 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'
@@ -191,6 +191,15 @@ export interface Right<R, L> {
    * ```
    */
   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>
 }
 
 /**
@@ -236,7 +245,7 @@ export interface Left<R, L> {
    * @param op.left function to be invoked with underlying error in case of 'left'
    * @returns self
    */
-  matchTap(op: { right: (value: R) => void; left: (error: any) => void }): this;
+  matchTap(op: { right: (value: R) => void; left: (error: L) => void }): this;
 
   /**
    * Either transformer function
@@ -280,9 +289,9 @@ export interface Left<R, L> {
    * @returns 'right op.right(value)' or 'right op.left(error)'
    */
   // Left case
-  matchMap<R2, R3 = R2>(this: Left<R, L>, op: { right: (value: R) => R2; left: (error: any) => R3 }): Right<R3, never>;
+  matchMap<R2, R3 = R2>(this: Left<R, L>, op: { right: (value: R) => R2; left: (error: L) => R3 }): Right<R3, never>;
   // General case
-  matchMap<R2, R3 = R2>(this: Either<R, L>, op: { right: (value: R) => R2; left: (error: any) => R3 }): Right<R2 | 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
@@ -339,25 +348,25 @@ export interface Left<R, L> {
    * @returns 'op(value)' or 'op(error)'
    */
   // Left cases
-  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Left<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: any) => 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: any) => 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: any) => 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: any) => 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: any) => 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: any) => 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: any) => 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: any) => 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: any) => Either<R3, L3> }): Either<R3, L3>;
+  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>;
   // General cases
-  matchChain<R2, L2, R3 = R2, L3 = L2>(this: Either<R, L>, op: { right: (value: R) => Right<R2, L2>; left: (error: any) => 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: any) => 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: any) => 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: any) => 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: any) => 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: any) => 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: any) => 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: any) => 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: any) => Either<R3, L3> }): Either<R2 | R3, L2 | 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'
@@ -386,6 +395,15 @@ export interface Left<R, L> {
    * ```
    */
   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>
 }
 
 /**
@@ -431,6 +449,9 @@ export namespace Left {
   }
 }
 
+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 namespace Either {
   /**
    * Right monad constructor
@@ -529,7 +550,7 @@ export namespace Either {
    * @param eithers a list of Either
    * @returns true in case at least one list element is Right
    */
-  export function someRight<R, L>(eithers: Either<R, L>[]): eithers is Right<R, never>[] {
+  export function someRight<R, L>(eithers: Either<R, L>[]): boolean {
     return eithers.some(Either.isRight);
   }
 
@@ -549,9 +570,38 @@ export namespace Either {
    * @param eithers a list of Either
    * @returns true in case at least one list element is Left
    */
-  export function someLeft<R, L>(eithers: Either<R, L>[]): eithers is Left<never, L>[] {
+  export function someLeft<R, L>(eithers: Either<R, L>[]): boolean {
     return eithers.some(Either.isLeft);
   }
+
+  /**
+   * 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
+   * ```
+   */
+  export function generate<T, TT extends Either<T, any>, R>(eitherGeneratorFunction: EitherGeneratorFunction<[], T, TT, R>): Either<R, any> {
+    const generator = eitherGeneratorFunction();
+
+    const sequentor = (next: IteratorResult<TT, R>): Either<R, any> => {
+      return next.done ? (
+        Either.right(next.value)
+      ) : (
+        next.value.matchChain<R, any>({
+          right: (value) => sequentor(generator.next(value)),
+          left: Either.left,
+        })
+      );
+    };
+
+    return Either.right(undefined).chain(() => sequentor(generator.next()));
+  }
 }
 
 /// --------------------------------------------------------------------------------------
@@ -596,6 +646,11 @@ class RightClass<R> implements Right<R, never> {
   matchChain<TT extends Either<unknown, unknown>>(op: { right: (value: R) => TT }) {
     return this.chain(op.right);
   }
+  generator() {
+    return (function*(value) {
+      return (yield value) as R;
+    })(this);
+  }
 }
 
 class LeftClass<L> implements Left<never, L> {
@@ -627,13 +682,18 @@ class LeftClass<L> implements Left<never, L> {
   isLeft(): this is Left<never, L> {
     return true;
   }
-  matchTap(op: { left: (error: any) => void }) {
+  matchTap(op: { left: (error: L) => void }) {
     return this.orTap(op.left);
   }
-  matchMap<R2>(op: { left: (error: any) => R2 }) {
+  matchMap<R2>(op: { left: (error: L) => R2 }) {
     return this.orMap(op.left);
   }
-  matchChain<TT extends Either<unknown, unknown>>(op: { left: (error: any) => TT }) {
+  matchChain<TT extends Either<unknown, unknown>>(op: { left: (error: L) => TT }) {
     return this.orChain(op.left);
   }
+  generator() {
+    return (function*(value) {
+      return (yield value) as never;
+    })(this);
+  }
 }

package/src/maybe.ts

@@ -186,6 +186,15 @@ export interface Just<R> {
    * ```
    */
   isNothing(): this is Nothing<R>;
+
+  /**
+   * Wrap Maybe to singleton generator
+   *
+   * Userful in order to avoid ambiguous yied types
+   *
+   * @returns generator of Maybe wrapping this
+   */
+  generator: MaybeGeneratorFunction<[], R, Just<R>, R>
 }
 
 /**
@@ -372,6 +381,15 @@ export interface Nothing<R> {
    * ```
    */
   isNothing(): this is Nothing<R>;
+
+  /**
+   * Wrap Maybe to singleton generator
+   *
+   * Userful in order to avoid ambiguous yied types
+   *
+   * @returns generator of Maybe wrapping this
+   */
+  generator: MaybeGeneratorFunction<[], R, Nothing<R>, R>
 }
 
 /**
@@ -401,6 +419,9 @@ export namespace Just {
 
 export 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 namespace Maybe {
   /**
    * Non-empty monad constructor
@@ -495,7 +516,7 @@ export namespace Maybe {
    * @param maybes a list of Maybe
    * @returns true in case al east one list element is Just
    */
-  export function someJust<R>(maybes: Maybe<R>[]): maybes is Just<R>[] {
+  export function someJust<R>(maybes: Maybe<R>[]): boolean {
     return maybes.some(Maybe.isJust);
   }
 
@@ -515,9 +536,38 @@ export namespace Maybe {
    * @param maybes a list of Maybe
    * @returns true in case at least one list element is Nothing
    */
-  export function someNothing<R>(maybes: Maybe<R>[]): maybes is Nothing<never>[] {
+  export function someNothing<R>(maybes: Maybe<R>[]): boolean {
     return maybes.some(Maybe.isNothing);
   }
+
+  /**
+   * 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 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
+   * ```
+   */
+  export function generate<T, TT extends Maybe<T>, R>(maybeGeneratorFunction: MaybeGeneratorFunction<[], T, TT, R>): Maybe<R> {
+    const generator = maybeGeneratorFunction();
+
+    const sequentor = (next: IteratorResult<TT, R>): Maybe<R> => {
+      return next.done ? (
+        Maybe.just(next.value)
+      ) : (
+        next.value.matchChain<R>({
+          just: (value) => sequentor(generator.next(value)),
+          nothing: Maybe.nothing,
+        })
+      );
+    };
+
+    return Maybe.just(undefined).chain(() => sequentor(generator.next()));
+  }
 }
 
 /// --------------------------------------------------------------------------------------
@@ -562,6 +612,11 @@ class JustClass<R> implements Just<R> {
   matchChain<RR extends Maybe<unknown>>(op: { just: (value: R) => RR }) {
     return this.chain(op.just);
   }
+  generator() {
+    return (function*(value) {
+      return (yield value) as R;
+    })(this);
+  }
 }
 
 class NothingClass implements Nothing<never> {
@@ -600,6 +655,11 @@ class NothingClass implements Nothing<never> {
   matchChain<RR extends Maybe<unknown>>(op: { nothing: () => RR }) {
     return this.orChain(op.nothing);
   }
+  generator() {
+    return (function*(value) {
+      return (yield value) as never;
+    })(this);
+  }
 }
 
 const staticNothing = new NothingClass();

package/src/task.ts

@@ -364,6 +364,17 @@ export namespace Task {
     return Task.fromPromise(promise).generator();
   }
 
+  /**
+   * 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*
+   */
+   export function timeoutGenerator(delay: number) {
+    return Task.timeout(delay).generator();
+  }
+
   /**
    * Lift from function returning value/promise to function returning task resolving to that value
    *
@@ -423,13 +434,15 @@ export namespace Task {
     const generator = taskGeneratorFunction();
 
     const sequentor = (next: IteratorResult<TT, R>): Task<R> => {
-      return next.done
-        ? Task.resolved(next.value)
-        : next.value.matchChain<R>({
-            resolved: (value) => sequentor(generator.next(value)),
-            rejected: (error) => sequentor(generator.throw(error)),
-            canceled: Task.canceled,
-          });
+      return next.done ? (
+        Task.resolved(next.value)
+      ) : (
+        next.value.matchChain<R>({
+          resolved: (value) => sequentor(generator.next(value)),
+          rejected: (error) => sequentor(generator.throw(error)),
+          canceled: Task.canceled,
+        })
+      );
     };
 
     return Task.resolved(undefined).chain(() => sequentor(generator.next()));