t-tasks 1.2.1 → 2.0.0

package/src/either.ts

@@ -4,7 +4,7 @@
  * 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)
+ * @template L underlying error type (needed for type merging, in fact always considered to be never)
  */
 export interface Right<R, L> {
   readonly right: R;
@@ -73,17 +73,22 @@ export interface Right<R, L> {
   orMap<R2>(this: Either<R, L>, op: (error: L) => R2): Right<R | R2, never>;
 
   /**
-   * Either pattern matching transformer function
+   * Either pattern matching extractor function
    *
-   * Applied to 'right value' returns 'right op.right(value)'
-   * Applied to 'left error' returns 'right op.left(error)'
+   * Applied to 'right value' returns op.right(value)
+   * Applied to 'left error' returns 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)'
+   * @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)
    */
+  // Right case
+  match<R2, R3 = R2>(this: Right<R, L>, op: { right: (value: R) => R2; left: (error: L) => R3 }): R2;
+  // General case
+  match<R2, R3 = R2>(this: Either<R, L>, op: { right: (value: R) => R2; left: (error: L) => R3 }): R2 | R3;
+
   // Right case
   matchMap<R2, R3 = R2>(this: Right<R, L>, op: { right: (value: R) => R2; left: (error: L) => R3 }): Right<R2, never>;
   // General case
@@ -117,7 +122,7 @@ export interface Right<R, L> {
    *
    * @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
+   * @param op transformer to be invoked with underlying error
    * @returns 'right value' or 'op(error)'
    */
   // Right cases
@@ -193,13 +198,13 @@ export interface Right<R, L> {
   isLeft(): this is Left<R, L>;
 
   /**
-   * Wrap Maybe to singleton generator
+   * Wrap Either to singleton generator
    *
-   * Userful in order to avoid ambiguous yied types
+   * Useful in order to avoid ambiguous yield types
    *
-   * @returns generator of Maybe wrapping this
+   * @returns generator of Either wrapping this
    */
-   generator: EitherGeneratorFunction<[], R, Right<R, L>, R>
+  generator: EitherGeneratorFunction<[], R, Right<R, L>, R>
 }
 
 /**
@@ -207,7 +212,7 @@ export interface Right<R, 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 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> {
@@ -230,7 +235,7 @@ export interface Left<R, L> {
    * 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
+   * @param op function to be invoked with underlying error
    * @returns self
    */
   orTap(op: (error: L) => void): this;
@@ -277,17 +282,22 @@ export interface Left<R, L> {
   orMap<R2>(this: Either<R, L>, op: (error: L) => R2): Right<R | R2, never>;
 
   /**
-   * Either pattern matching transformer function
+   * Either pattern matching extractor function
    *
-   * Applied to 'right value' returns 'right op.right(value)'
-   * Applied to 'left error' returns 'right op.left(error)'
+   * Applied to 'right value' returns op.right(value)
+   * Applied to 'left error' returns 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)'
+   * @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)
    */
+  // Left case
+  match<R2, R3 = R2>(this: Left<R, L>, op: { right: (value: R) => R2; left: (error: L) => R3 }): R3;
+  // General case
+  match<R2, R3 = R2>(this: Either<R, L>, op: { right: (value: R) => R2; left: (error: L) => R3 }): R2 | R3;
+
   // Left case
   matchMap<R2, R3 = R2>(this: Left<R, L>, op: { right: (value: R) => R2; left: (error: L) => R3 }): Right<R3, never>;
   // General case
@@ -304,7 +314,7 @@ export interface Left<R, L> {
    * @param op transformer to be invoked with underlying value
    * @returns 'op(value)' or 'left error'
    */
-  // Right cases
+  // Left cases
   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>;
@@ -321,7 +331,7 @@ export interface Left<R, L> {
    *
    * @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
+   * @param op transformer to be invoked with underlying error
    * @returns 'right value' or 'op(error)'
    */
   // Left cases
@@ -397,19 +407,19 @@ export interface Left<R, L> {
   isLeft(): this is Left<R, L>;
 
   /**
-   * Wrap Maybe to singleton generator
+   * Wrap Either to singleton generator
    *
-   * Userful in order to avoid ambiguous yied types
+   * Useful in order to avoid ambiguous yield types
    *
-   * @returns generator of Maybe wrapping this
+   * @returns generator of Either wrapping this
    */
-   generator: EitherGeneratorFunction<[], R, Left<R, L>, R>
+  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
+ * 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
@@ -421,7 +431,7 @@ export namespace Right {
   /**
    * Standalone Right value extractor
    *
-   * Userful for passing as a function to collection transformers
+   * Useful for passing as a function to collection transformers
    *
    * @template R underlying value type
    * @template L underlying error type
@@ -437,7 +447,7 @@ export namespace Left {
   /**
    * Standalone Left error extractor
    *
-   * Userful for passing as a function to collection transformers
+   * Useful for passing as a function to collection transformers
    *
    * @template R underlying value type
    * @template L underlying error type
@@ -508,10 +518,30 @@ export namespace Either {
     return Either.fromOptional(value, error).chain((v) => (v !== null ? Either.right(value) : Either.left(error)));
   }
 
+  /**
+   * 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
+   */
+  export function fromEither<R, L>(either: Right<R, L>, fallback: unknown): R;
+  export function fromEither<R, L, R2>(either: Left<R, L>, fallback: R2): R2;
+  export function fromEither<R, L, R2>(either: Either<R, L>, fallback: R2): R | R2;
+  export function fromEither<R, L, R2>(either: Either<R, L>, fallback: R2) {
+    return either.match({ right: (value) => value, left: () => fallback });
+  }
+
   /**
    * Standalone type guard for 'right'
    *
-   * Userful for passing as a predicate to collection transformers
+   * Useful for passing as a predicate to collection transformers
    *
    * @template R underlying value type
    * @param either Either instance
@@ -524,7 +554,7 @@ export namespace Either {
   /**
    * Standalone type guard for 'left'
    *
-   * Userful for passing as a predicate to collection transformers
+   * Useful for passing as a predicate to collection transformers
    *
    * @template R underlying value type
    * @param either Either instance
@@ -577,30 +607,27 @@ export namespace Either {
   /**
    * 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
+   * 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 Maybe type
+   * @template TT yielded Either type
    * @template R returned underlying type
-   * @param maybeGeneratorFunction Maybe generator function
-   * @returns Just wrapping the result of generator function or Nothing
-   * ```
+   * @param eitherGeneratorFunction Either generator function
+   * @returns Right wrapping the result of generator function or Left
    */
   export function generate<T, TT extends Either<T, any>, R>(eitherGeneratorFunction: EitherGeneratorFunction<[], T, TT, R>): Either<R, any> {
     const generator = eitherGeneratorFunction();
+    let next = generator.next();
 
-    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,
-        })
-      );
-    };
+    while (!next.done) {
+      if (next.value.isLeft()) {
+        return Either.left(next.value.left);
+      }
 
-    return Either.right(undefined).chain(() => sequentor(generator.next()));
+      next = generator.next(next.value.right);
+    }
+
+    return Either.right(next.value);
   }
 }
 
@@ -625,7 +652,7 @@ class RightClass<R> implements Right<R, never> {
   orMap() {
     return this;
   }
-  chain<TT extends Either<unknown, unknown>>(op: (value: R) => TT) {
+  chain<RR extends Either<unknown, unknown>>(op: (value: R) => RR) {
     return op(this.right);
   }
   orChain() {
@@ -637,13 +664,16 @@ class RightClass<R> implements Right<R, never> {
   isLeft(): this is Left<R, never> {
     return false;
   }
+  match<R2>(op: { right: (value: R) => R2 }) {
+    return op.right(this.right);
+  }
   matchTap(op: { right: (value: R) => void }) {
     return this.tap(op.right);
   }
   matchMap<R2>(op: { right: (value: R) => R2 }) {
     return this.map(op.right);
   }
-  matchChain<TT extends Either<unknown, unknown>>(op: { right: (value: R) => TT }) {
+  matchChain<RR extends Either<unknown, unknown>>(op: { right: (value: R) => RR }) {
     return this.chain(op.right);
   }
   generator() {
@@ -673,7 +703,7 @@ class LeftClass<L> implements Left<never, L> {
   chain() {
     return this;
   }
-  orChain<TT extends Either<unknown, unknown>>(op: (error: L) => TT) {
+  orChain<RR extends Either<unknown, unknown>>(op: (error: L) => RR) {
     return op(this.left);
   }
   isRight(): this is Right<never, L> {
@@ -682,13 +712,16 @@ class LeftClass<L> implements Left<never, L> {
   isLeft(): this is Left<never, L> {
     return true;
   }
+  match<R2>(op: { left: (error: L) => R2 }) {
+    return op.left(this.left);
+  }
   matchTap(op: { left: (error: L) => void }) {
     return this.orTap(op.left);
   }
   matchMap<R2>(op: { left: (error: L) => R2 }) {
     return this.orMap(op.left);
   }
-  matchChain<TT extends Either<unknown, unknown>>(op: { left: (error: L) => TT }) {
+  matchChain<RR extends Either<unknown, unknown>>(op: { left: (error: L) => RR }) {
     return this.orChain(op.left);
   }
   generator() {

package/src/maybe.ts

@@ -31,7 +31,7 @@ export interface Just<R> {
   orTap(op: () => void): this;
 
   /**
-   * Maybe patter matching peeker function
+   * 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
@@ -72,22 +72,28 @@ export interface Just<R> {
   orMap<R2>(this: Maybe<R>, op: () => R2): Just<R | R2>;
 
   /**
-   * Maybe patter matching transformer function
+   * Maybe pattern matching extractor function
    *
-   * Applied to 'just value' returns 'just op.just(value)'
-   * Applied to 'nothing' returns 'just op.nothing()'
+   * Applied to 'just value' returns op.just(value)
+   * Applied to 'nothing' returns op.nothing()
    *
-   * @template R2 just transformer function's return type
-   * @template R3 nothing transformer function's return 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 'just op.just(value)' or 'just 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()
    */
   // Just cases
+  match<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => R2; nothing: () => R3 }): R2;
+  // General case
+  match<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => R2; nothing: () => R3 }): R2 | R3;
+
+  // Nothing cases
   matchMap<R2, R3 = R2>(this: Just<R>, op: { just: (value: R) => R2; nothing: () => R3 }): Just<R2>;
   // General case
   matchMap<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => R2; nothing: () => R3 }): Just<R2 | R3>;
 
+
   /**
    * Maybe composition function
    *
@@ -110,7 +116,7 @@ export interface Just<R> {
   /**
    * Maybe fallback composition function
    *
-   * Applied to 'just value' returns self witjout invoking 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
@@ -127,7 +133,7 @@ export interface Just<R> {
   orChain<R2>(this: Maybe<R>, op: () => Maybe<R2>): Maybe<R | R2>;
 
   /**
-   * Maybe patter matching composition function
+   * Maybe pattern matching composition function
    *
    * Applied to 'just value' returns 'op.just(value)'
    * Applied to 'nothing' returns op.nothing()
@@ -180,7 +186,7 @@ export interface Just<R> {
    *
    * @example
    * ```typescript
-   * if (maybe.isNohing()) {
+   * if (maybe.isNothing()) {
    *   console.log('nothing');
    * }
    * ```
@@ -190,7 +196,7 @@ export interface Just<R> {
   /**
    * Wrap Maybe to singleton generator
    *
-   * Userful in order to avoid ambiguous yied types
+   * Useful in order to avoid ambiguous yield types
    *
    * @returns generator of Maybe wrapping this
    */
@@ -200,7 +206,7 @@ export interface Just<R> {
 /**
  * Absolutely Nothing
  *
- * Maybe data type specialiation representing an absence of any value
+ * Maybe data type specialization representing an absence of any value
  */
 export interface Nothing<R> {
   /**
@@ -226,7 +232,7 @@ export interface Nothing<R> {
   orTap(op: () => void): this;
 
   /**
-   * Maybe patter matching peeker function
+   * 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
@@ -267,20 +273,25 @@ export interface Nothing<R> {
   orMap<R2>(this: Maybe<R>, op: () => R2): Just<R | R2>;
 
   /**
-   * Maybe patter matching transformer function
+   * Maybe pattern matching extractor function
    *
-   * Applied to 'just value' returns 'just op.just(value)'
-   * Applied to 'nothing' returns 'just op.nothing()'
+   * Applied to 'just value' returns op.just(value)
+   * Applied to 'nothing' returns op.nothing()
    *
-   * @template R2 just transformer function's return type
-   * @template R3 nothing transformer function's return 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 'just op.just(value)' or 'just 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()
    */
   // Nothing cases
+  match<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => R2; nothing: () => R3 }): R3;
+  // General case
+  match<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => R2; nothing: () => R3 }): R2 | R3;
+
+  // Just cases
   matchMap<R2, R3 = R2>(this: Nothing<R>, op: { just: (value: R) => R2; nothing: () => R3 }): Just<R3>;
-  // General cases
+  // General case
   matchMap<R2, R3 = R2>(this: Maybe<R>, op: { just: (value: R) => R2; nothing: () => R3 }): Just<R2 | R3>;
 
   /**
@@ -305,7 +316,7 @@ export interface Nothing<R> {
   /**
    * Maybe fallback composition function
    *
-   * Applied to 'just value' returns self witjout invoking 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
@@ -322,7 +333,7 @@ export interface Nothing<R> {
   orChain<R2>(this: Maybe<R>, op: () => Maybe<R2>): Maybe<R | R2>;
 
   /**
-   * Maybe patter matching composition function
+   * Maybe pattern matching composition function
    *
    * Applied to 'just value' returns 'op.just(value)'
    * Applied to 'nothing' returns op.nothing()
@@ -375,7 +386,7 @@ export interface Nothing<R> {
    *
    * @example
    * ```typescript
-   * if (maybe.isNohing()) {
+   * if (maybe.isNothing()) {
    *   console.log('nothing');
    * }
    * ```
@@ -385,7 +396,7 @@ export interface Nothing<R> {
   /**
    * Wrap Maybe to singleton generator
    *
-   * Userful in order to avoid ambiguous yied types
+   * Useful in order to avoid ambiguous yield types
    *
    * @returns generator of Maybe wrapping this
    */
@@ -393,9 +404,9 @@ export interface Nothing<R> {
 }
 
 /**
- * Genric Maybe monad interface
+ * Generic Maybe monad interface
  *
- * As per classic Maybe monad implementation can eithr contain just a value or contain nothing
+ * 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
@@ -406,7 +417,7 @@ export namespace Just {
   /**
    * Standalone Just value extractor
    *
-   * Userful for passing as a function to collection transformers
+   * Useful for passing as a function to collection transformers
    *
    * @template R underlying value type
    * @param just Just instance
@@ -439,8 +450,8 @@ export namespace Maybe {
    *
    * @returns 'nothing'
    */
-  export function nothing(): Nothing<never> {
-    return staticNothing;
+  export function nothing<R = never>(): Nothing<R> {
+    return staticNothing as Nothing<R>;
   }
 
   /**
@@ -474,10 +485,29 @@ export namespace Maybe {
     return Maybe.fromOptional(value).chain((v) => (v !== null ? Maybe.just(v) : Maybe.nothing()));
   }
 
+  /**
+   * 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
+   */
+  export function fromMaybe<R>(maybe: Just<R>, fallback: unknown): R;
+  export function fromMaybe<R, R2>(maybe: Nothing<R>, fallback: R2): R2;
+  export function fromMaybe<R, R2>(maybe: Maybe<R>, fallback: R2): R | R2;
+  export function fromMaybe<R, R2>(maybe: Maybe<R>, fallback: R2) {
+    return maybe.match({ just: (value) => value, nothing: () => fallback });
+  }
+
   /**
    * Standalone type guard for 'just'
    *
-   * Userful for passing as a predicate to collection transformers
+   * Useful for passing as a predicate to collection transformers
    *
    * @template R underlying value type
    * @param maybe Maybe instance
@@ -490,13 +520,13 @@ export namespace Maybe {
   /**
    * Standalone type guard for 'nothing'
    *
-   * Userful for passing as a predicate to collection transformers
+   * 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')
    */
-  export function isNothing<R>(maybe: Maybe<R>): maybe is Nothing<never> {
+  export function isNothing<R>(maybe: Maybe<R>): maybe is Nothing<R> {
     return maybe.isNothing();
   }
 
@@ -514,7 +544,7 @@ export namespace Maybe {
    * Standalone list predicate
    *
    * @param maybes a list of Maybe
-   * @returns true in case al east one list element is Just
+   * @returns true in case at least one list element is Just
    */
   export function someJust<R>(maybes: Maybe<R>[]): boolean {
     return maybes.some(Maybe.isJust);
@@ -544,29 +574,26 @@ export namespace Maybe {
    * 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
+   * 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
-   * ```
    */
   export function generate<T, TT extends Maybe<T>, R>(maybeGeneratorFunction: MaybeGeneratorFunction<[], T, TT, R>): Maybe<R> {
     const generator = maybeGeneratorFunction();
+    let next = generator.next();
 
-    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,
-        })
-      );
-    };
+    while (!next.done) {
+      if (next.value.isNothing()) {
+        return Maybe.nothing();
+      }
 
-    return Maybe.just(undefined).chain(() => sequentor(generator.next()));
+      next = generator.next(next.value.just);
+    }
+
+    return Maybe.just(next.value);
   }
 }
 
@@ -603,6 +630,9 @@ class JustClass<R> implements Just<R> {
   isNothing(): this is Nothing<R> {
     return false;
   }
+  match<R2>(op: { just: (value: R) => R2 }) {
+    return op.just(this.just);
+  }
   matchTap(op: { just: (value: R) => void }) {
     return this.tap(op.just);
   }
@@ -646,6 +676,9 @@ class NothingClass implements Nothing<never> {
   isNothing(): this is Nothing<never> {
     return true;
   }
+  match<R2>(op: { nothing: () => R2 }) {
+    return op.nothing();
+  }
   matchTap(op: { nothing: () => void }) {
     return this.orTap(op.nothing);
   }