From e12e142200a05d3866f789417362f50578966492 Mon Sep 17 00:00:00 2001
From: Grzegorz Piwowarek <gpiwowarek@gmail.com>
Date: Mon, 3 Nov 2025 12:01:31 +0100
Subject: [PATCH 1/8] Lazy For() Comprehension

---
 vavr/generator/Generator.scala          |  146 +
 vavr/src-gen/main/java/io/vavr/API.java | 3654 +++++++++++++++++++++++
 2 files changed, 3800 insertions(+)

diff --git a/vavr/generator/Generator.scala b/vavr/generator/Generator.scala
index 7bf4464945..8fb823d49a 100644
--- a/vavr/generator/Generator.scala
+++ b/vavr/generator/Generator.scala
@@ -743,6 +743,150 @@ def generateMainClasses(): Unit = {
         """
       }
 
+      def genLazyFor(im: ImportManager, packageName: String, className: String): String = {
+        xs"""
+          ${
+          monadicTypesFor
+            .filterNot(_ == "Iterable")
+            .gen(mtype => (2 to N).gen(i => {
+              val forClassName = s"ForLazy$i$mtype"
+              val isComplex = monadicTypesThatNeedParameter.contains(mtype)
+              val parameterInset = if (isComplex) "L, " else ""
+              val generics = parameterInset + (1 to i).gen(j => s"T$j")(", ")
+
+              val params = (1 to i).gen { j =>
+                if (j == 1)
+                  s"$mtype<${parameterInset}T1> ts1"
+                else {
+                  val inputTypes = (1 until j).gen(k => s"T$k")(", ")
+                  s"Function${j - 1}<$inputTypes, $mtype<${parameterInset}T$j>> ts$j"
+                }
+              }(", ")
+
+              val ctorArgs = (1 to i).gen(j => s"ts$j")(", ")
+
+              xs"""
+                    /$javadoc
+                     * Creates a lazy {@code For}-comprehension over ${i.numerus(mtype)}.
+                     *
+                     * <p>The first argument ({@code ts1}) is the initial ${mtype}. Each subsequent
+                     * argument ({@code ts2} .. {@code ts$i}) is a function that receives all values
+                     * bound so far and returns the next ${mtype}. This only builds the lazy
+                     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+                     *
+                     ${(0 to i).gen(j => if (j == 0) "*" else s"* @param ts$j the ${j.ordinal} ${mtype}")("\n")}
+                     ${if (isComplex) s"* @param <L> the common left-hand type of all ${mtype}s\n" else ""}
+                     ${(1 to i).gen(j => s"* @param <T$j> the component type of the ${j.ordinal} ${mtype}")("\n")}
+                     * @return a new {@code $forClassName} builder of arity $i
+                     * @throws NullPointerException if any argument is {@code null}
+                     */
+                    public static <$generics> $forClassName<$generics> For($params) {
+                        ${(1 to i).gen(j => xs"""$Objects.requireNonNull(ts$j, "ts$j is null");""")("\n")}
+                        return new $forClassName<>($ctorArgs);
+                    }
+                  """
+            })("\n\n"))("\n\n")
+        }
+
+          ${
+          monadicTypesFor
+            .filterNot(_ == "Iterable")
+            .gen(mtype => (2 to N).gen(i => {
+              val rtype = mtype
+              val forClassName = s"ForLazy$i$mtype"
+              val parameterInset = if (monadicTypesThatNeedParameter.contains(mtype)) "L, " else ""
+              val generics = parameterInset + (1 to i).gen(j => s"T$j")(", ")
+              val functionType = i match {
+                case 2 => BiFunctionType
+                case _ => s"Function$i"
+              }
+              val args = (1 to i).gen(j => s"? super T$j")(", ")
+
+              val fields = (1 to i).gen { j =>
+                if (j == 1)
+                  s"private final $mtype<${parameterInset}T1> ts1;"
+                else {
+                  val inputTypes = (1 until j).gen(k => s"T$k")(", ")
+                  s"private final Function${j - 1}<$inputTypes, $mtype<${parameterInset}T$j>> ts$j;"
+                }
+              }("\n")
+
+              val ctorParams = (1 to i).gen { j =>
+                if (j == 1)
+                  s"$mtype<${parameterInset}T1> ts1"
+                else {
+                  val inputTypes = (1 until j).gen(k => s"T$k")(", ")
+                  s"Function${j - 1}<$inputTypes, $mtype<${parameterInset}T$j>> ts$j"
+                }
+              }(", ")
+
+              val assignments = (1 to i).gen(j => s"this.ts$j = ts$j;")("\n")
+
+              val yieldBody = {
+                def nestedLambda(j: Int): String = {
+                  val base = "                       "
+                  val indent = "  " * j
+                  if (j == i) {
+                    val argsList = (1 to i).map(k => s"t$k").mkString(", ")
+                    val inputArgs = (1 until i).map(k => s"t$k").mkString(", ")
+                    s"ts$i.apply($inputArgs).map(t$i -> f.apply($argsList))"
+                  } else if (j == 1) {
+                    s"ts1.flatMap(t1 -> {\n" +
+                      s"${base}${indent}  return ${nestedLambda(j + 1)};\n" +
+                      s"${base}${indent}})"
+                  } else {
+                    val inputArgs = (1 until j).map(k => s"t$k").mkString(", ")
+                    s"ts$j.apply($inputArgs).flatMap(t$j -> {\n" +
+                      s"${base}${indent}  return ${nestedLambda(j + 1)};\n" +
+                      s"${base}${indent}})"
+                  }
+                }
+
+                nestedLambda(1)
+              }
+
+              xs"""
+                  /$javadoc
+                   * A lazily evaluated {@code For}-comprehension with ${i.numerus(mtype)}.
+                   *
+                   * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+                   * Construction is side-effect free; underlying ${i.plural(mtype)} are only
+                   * traversed when {@code yield(...)} is invoked.</p>
+                   *
+                   ${if (monadicTypesThatNeedParameter.contains(mtype)) s"* @param <L> the common left-hand type of all ${mtype}s\n" else ""}
+                   ${(1 to i).gen(j => s"* @param <T$j> the component type of the ${j.ordinal} ${mtype}")("\n")}
+                   */
+                  public static class $forClassName<$generics> {
+
+                      $fields
+
+                      private $forClassName($ctorParams) {
+                          $assignments
+                      }
+
+                      /$javadoc
+                       * Produces results by mapping the Cartesian product of all bound values.
+                       *
+                       * <p>Evaluation is lazy and delegated to the underlying ${i.plural(mtype)} by
+                       * composing flatMap/map chains.</p>
+                       *
+                       * @param f a function that maps a tuple of bound values to a result
+                       * @param <R> the element type of the resulting {@code $rtype}
+                       * @return an {@code $rtype} containing mapped results
+                       * @throws NullPointerException if {@code f} is {@code null}
+                       */
+                      public <R> $rtype<${parameterInset}R> yield($functionType<$args, ? extends R> f) {
+                          $Objects.requireNonNull(f, "f is null");
+                          return $yieldBody;
+                      }
+                  }
+                """
+            })("\n\n"))("\n\n")
+        }
+        """
+      }
+
+
       def genFor(im: ImportManager, packageName: String, className: String): String = {
         xs"""
           //
@@ -1440,6 +1584,8 @@ def generateMainClasses(): Unit = {
 
             ${genFor(im, packageName, className)}
 
+            ${genLazyFor(im, packageName, className)}
+
             ${genMatch(im, packageName, className)}
         }
       """
diff --git a/vavr/src-gen/main/java/io/vavr/API.java b/vavr/src-gen/main/java/io/vavr/API.java
index 99c8a182b1..94fd4f1642 100644
--- a/vavr/src-gen/main/java/io/vavr/API.java
+++ b/vavr/src-gen/main/java/io/vavr/API.java
@@ -5740,6 +5740,3660 @@ public <R> Validation<L, R> yield(Function8<? super T1, ? super T2, ? super T3,
 
      }
 
+    /**
+     * Creates a lazy {@code For}-comprehension over two Options.
+     *
+     * <p>The first argument ({@code ts1}) is the initial Option. Each subsequent
+     * argument ({@code ts2} .. {@code ts2}) is a function that receives all values
+     * bound so far and returns the next Option. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st Option
+     * @param ts2 the 2nd Option
+
+     * @param <T1> the component type of the 1st Option
+     * @param <T2> the component type of the 2nd Option
+     * @return a new {@code ForLazy2Option} builder of arity 2
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <T1, T2> ForLazy2Option<T1, T2> For(Option<T1> ts1, Function1<T1, Option<T2>> ts2) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        return new ForLazy2Option<>(ts1, ts2);
+    }
+
+    /**
+     * Creates a lazy {@code For}-comprehension over three Options.
+     *
+     * <p>The first argument ({@code ts1}) is the initial Option. Each subsequent
+     * argument ({@code ts2} .. {@code ts3}) is a function that receives all values
+     * bound so far and returns the next Option. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st Option
+     * @param ts2 the 2nd Option
+     * @param ts3 the 3rd Option
+
+     * @param <T1> the component type of the 1st Option
+     * @param <T2> the component type of the 2nd Option
+     * @param <T3> the component type of the 3rd Option
+     * @return a new {@code ForLazy3Option} builder of arity 3
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <T1, T2, T3> ForLazy3Option<T1, T2, T3> For(Option<T1> ts1, Function1<T1, Option<T2>> ts2, Function2<T1, T2, Option<T3>> ts3) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        Objects.requireNonNull(ts3, "ts3 is null");
+        return new ForLazy3Option<>(ts1, ts2, ts3);
+    }
+
+    /**
+     * Creates a lazy {@code For}-comprehension over 4 Options.
+     *
+     * <p>The first argument ({@code ts1}) is the initial Option. Each subsequent
+     * argument ({@code ts2} .. {@code ts4}) is a function that receives all values
+     * bound so far and returns the next Option. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st Option
+     * @param ts2 the 2nd Option
+     * @param ts3 the 3rd Option
+     * @param ts4 the 4th Option
+
+     * @param <T1> the component type of the 1st Option
+     * @param <T2> the component type of the 2nd Option
+     * @param <T3> the component type of the 3rd Option
+     * @param <T4> the component type of the 4th Option
+     * @return a new {@code ForLazy4Option} builder of arity 4
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <T1, T2, T3, T4> ForLazy4Option<T1, T2, T3, T4> For(Option<T1> ts1, Function1<T1, Option<T2>> ts2, Function2<T1, T2, Option<T3>> ts3, Function3<T1, T2, T3, Option<T4>> ts4) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        Objects.requireNonNull(ts3, "ts3 is null");
+        Objects.requireNonNull(ts4, "ts4 is null");
+        return new ForLazy4Option<>(ts1, ts2, ts3, ts4);
+    }
+
+    /**
+     * Creates a lazy {@code For}-comprehension over 5 Options.
+     *
+     * <p>The first argument ({@code ts1}) is the initial Option. Each subsequent
+     * argument ({@code ts2} .. {@code ts5}) is a function that receives all values
+     * bound so far and returns the next Option. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st Option
+     * @param ts2 the 2nd Option
+     * @param ts3 the 3rd Option
+     * @param ts4 the 4th Option
+     * @param ts5 the 5th Option
+
+     * @param <T1> the component type of the 1st Option
+     * @param <T2> the component type of the 2nd Option
+     * @param <T3> the component type of the 3rd Option
+     * @param <T4> the component type of the 4th Option
+     * @param <T5> the component type of the 5th Option
+     * @return a new {@code ForLazy5Option} builder of arity 5
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <T1, T2, T3, T4, T5> ForLazy5Option<T1, T2, T3, T4, T5> For(Option<T1> ts1, Function1<T1, Option<T2>> ts2, Function2<T1, T2, Option<T3>> ts3, Function3<T1, T2, T3, Option<T4>> ts4, Function4<T1, T2, T3, T4, Option<T5>> ts5) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        Objects.requireNonNull(ts3, "ts3 is null");
+        Objects.requireNonNull(ts4, "ts4 is null");
+        Objects.requireNonNull(ts5, "ts5 is null");
+        return new ForLazy5Option<>(ts1, ts2, ts3, ts4, ts5);
+    }
+
+    /**
+     * Creates a lazy {@code For}-comprehension over 6 Options.
+     *
+     * <p>The first argument ({@code ts1}) is the initial Option. Each subsequent
+     * argument ({@code ts2} .. {@code ts6}) is a function that receives all values
+     * bound so far and returns the next Option. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st Option
+     * @param ts2 the 2nd Option
+     * @param ts3 the 3rd Option
+     * @param ts4 the 4th Option
+     * @param ts5 the 5th Option
+     * @param ts6 the 6th Option
+
+     * @param <T1> the component type of the 1st Option
+     * @param <T2> the component type of the 2nd Option
+     * @param <T3> the component type of the 3rd Option
+     * @param <T4> the component type of the 4th Option
+     * @param <T5> the component type of the 5th Option
+     * @param <T6> the component type of the 6th Option
+     * @return a new {@code ForLazy6Option} builder of arity 6
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <T1, T2, T3, T4, T5, T6> ForLazy6Option<T1, T2, T3, T4, T5, T6> For(Option<T1> ts1, Function1<T1, Option<T2>> ts2, Function2<T1, T2, Option<T3>> ts3, Function3<T1, T2, T3, Option<T4>> ts4, Function4<T1, T2, T3, T4, Option<T5>> ts5, Function5<T1, T2, T3, T4, T5, Option<T6>> ts6) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        Objects.requireNonNull(ts3, "ts3 is null");
+        Objects.requireNonNull(ts4, "ts4 is null");
+        Objects.requireNonNull(ts5, "ts5 is null");
+        Objects.requireNonNull(ts6, "ts6 is null");
+        return new ForLazy6Option<>(ts1, ts2, ts3, ts4, ts5, ts6);
+    }
+
+    /**
+     * Creates a lazy {@code For}-comprehension over 7 Options.
+     *
+     * <p>The first argument ({@code ts1}) is the initial Option. Each subsequent
+     * argument ({@code ts2} .. {@code ts7}) is a function that receives all values
+     * bound so far and returns the next Option. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st Option
+     * @param ts2 the 2nd Option
+     * @param ts3 the 3rd Option
+     * @param ts4 the 4th Option
+     * @param ts5 the 5th Option
+     * @param ts6 the 6th Option
+     * @param ts7 the 7th Option
+
+     * @param <T1> the component type of the 1st Option
+     * @param <T2> the component type of the 2nd Option
+     * @param <T3> the component type of the 3rd Option
+     * @param <T4> the component type of the 4th Option
+     * @param <T5> the component type of the 5th Option
+     * @param <T6> the component type of the 6th Option
+     * @param <T7> the component type of the 7th Option
+     * @return a new {@code ForLazy7Option} builder of arity 7
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <T1, T2, T3, T4, T5, T6, T7> ForLazy7Option<T1, T2, T3, T4, T5, T6, T7> For(Option<T1> ts1, Function1<T1, Option<T2>> ts2, Function2<T1, T2, Option<T3>> ts3, Function3<T1, T2, T3, Option<T4>> ts4, Function4<T1, T2, T3, T4, Option<T5>> ts5, Function5<T1, T2, T3, T4, T5, Option<T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, Option<T7>> ts7) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        Objects.requireNonNull(ts3, "ts3 is null");
+        Objects.requireNonNull(ts4, "ts4 is null");
+        Objects.requireNonNull(ts5, "ts5 is null");
+        Objects.requireNonNull(ts6, "ts6 is null");
+        Objects.requireNonNull(ts7, "ts7 is null");
+        return new ForLazy7Option<>(ts1, ts2, ts3, ts4, ts5, ts6, ts7);
+    }
+
+    /**
+     * Creates a lazy {@code For}-comprehension over 8 Options.
+     *
+     * <p>The first argument ({@code ts1}) is the initial Option. Each subsequent
+     * argument ({@code ts2} .. {@code ts8}) is a function that receives all values
+     * bound so far and returns the next Option. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st Option
+     * @param ts2 the 2nd Option
+     * @param ts3 the 3rd Option
+     * @param ts4 the 4th Option
+     * @param ts5 the 5th Option
+     * @param ts6 the 6th Option
+     * @param ts7 the 7th Option
+     * @param ts8 the 8th Option
+
+     * @param <T1> the component type of the 1st Option
+     * @param <T2> the component type of the 2nd Option
+     * @param <T3> the component type of the 3rd Option
+     * @param <T4> the component type of the 4th Option
+     * @param <T5> the component type of the 5th Option
+     * @param <T6> the component type of the 6th Option
+     * @param <T7> the component type of the 7th Option
+     * @param <T8> the component type of the 8th Option
+     * @return a new {@code ForLazy8Option} builder of arity 8
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <T1, T2, T3, T4, T5, T6, T7, T8> ForLazy8Option<T1, T2, T3, T4, T5, T6, T7, T8> For(Option<T1> ts1, Function1<T1, Option<T2>> ts2, Function2<T1, T2, Option<T3>> ts3, Function3<T1, T2, T3, Option<T4>> ts4, Function4<T1, T2, T3, T4, Option<T5>> ts5, Function5<T1, T2, T3, T4, T5, Option<T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, Option<T7>> ts7, Function7<T1, T2, T3, T4, T5, T6, T7, Option<T8>> ts8) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        Objects.requireNonNull(ts3, "ts3 is null");
+        Objects.requireNonNull(ts4, "ts4 is null");
+        Objects.requireNonNull(ts5, "ts5 is null");
+        Objects.requireNonNull(ts6, "ts6 is null");
+        Objects.requireNonNull(ts7, "ts7 is null");
+        Objects.requireNonNull(ts8, "ts8 is null");
+        return new ForLazy8Option<>(ts1, ts2, ts3, ts4, ts5, ts6, ts7, ts8);
+    }
+
+    /**
+     * Creates a lazy {@code For}-comprehension over two Futures.
+     *
+     * <p>The first argument ({@code ts1}) is the initial Future. Each subsequent
+     * argument ({@code ts2} .. {@code ts2}) is a function that receives all values
+     * bound so far and returns the next Future. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st Future
+     * @param ts2 the 2nd Future
+
+     * @param <T1> the component type of the 1st Future
+     * @param <T2> the component type of the 2nd Future
+     * @return a new {@code ForLazy2Future} builder of arity 2
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <T1, T2> ForLazy2Future<T1, T2> For(Future<T1> ts1, Function1<T1, Future<T2>> ts2) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        return new ForLazy2Future<>(ts1, ts2);
+    }
+
+    /**
+     * Creates a lazy {@code For}-comprehension over three Futures.
+     *
+     * <p>The first argument ({@code ts1}) is the initial Future. Each subsequent
+     * argument ({@code ts2} .. {@code ts3}) is a function that receives all values
+     * bound so far and returns the next Future. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st Future
+     * @param ts2 the 2nd Future
+     * @param ts3 the 3rd Future
+
+     * @param <T1> the component type of the 1st Future
+     * @param <T2> the component type of the 2nd Future
+     * @param <T3> the component type of the 3rd Future
+     * @return a new {@code ForLazy3Future} builder of arity 3
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <T1, T2, T3> ForLazy3Future<T1, T2, T3> For(Future<T1> ts1, Function1<T1, Future<T2>> ts2, Function2<T1, T2, Future<T3>> ts3) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        Objects.requireNonNull(ts3, "ts3 is null");
+        return new ForLazy3Future<>(ts1, ts2, ts3);
+    }
+
+    /**
+     * Creates a lazy {@code For}-comprehension over 4 Futures.
+     *
+     * <p>The first argument ({@code ts1}) is the initial Future. Each subsequent
+     * argument ({@code ts2} .. {@code ts4}) is a function that receives all values
+     * bound so far and returns the next Future. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st Future
+     * @param ts2 the 2nd Future
+     * @param ts3 the 3rd Future
+     * @param ts4 the 4th Future
+
+     * @param <T1> the component type of the 1st Future
+     * @param <T2> the component type of the 2nd Future
+     * @param <T3> the component type of the 3rd Future
+     * @param <T4> the component type of the 4th Future
+     * @return a new {@code ForLazy4Future} builder of arity 4
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <T1, T2, T3, T4> ForLazy4Future<T1, T2, T3, T4> For(Future<T1> ts1, Function1<T1, Future<T2>> ts2, Function2<T1, T2, Future<T3>> ts3, Function3<T1, T2, T3, Future<T4>> ts4) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        Objects.requireNonNull(ts3, "ts3 is null");
+        Objects.requireNonNull(ts4, "ts4 is null");
+        return new ForLazy4Future<>(ts1, ts2, ts3, ts4);
+    }
+
+    /**
+     * Creates a lazy {@code For}-comprehension over 5 Futures.
+     *
+     * <p>The first argument ({@code ts1}) is the initial Future. Each subsequent
+     * argument ({@code ts2} .. {@code ts5}) is a function that receives all values
+     * bound so far and returns the next Future. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st Future
+     * @param ts2 the 2nd Future
+     * @param ts3 the 3rd Future
+     * @param ts4 the 4th Future
+     * @param ts5 the 5th Future
+
+     * @param <T1> the component type of the 1st Future
+     * @param <T2> the component type of the 2nd Future
+     * @param <T3> the component type of the 3rd Future
+     * @param <T4> the component type of the 4th Future
+     * @param <T5> the component type of the 5th Future
+     * @return a new {@code ForLazy5Future} builder of arity 5
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <T1, T2, T3, T4, T5> ForLazy5Future<T1, T2, T3, T4, T5> For(Future<T1> ts1, Function1<T1, Future<T2>> ts2, Function2<T1, T2, Future<T3>> ts3, Function3<T1, T2, T3, Future<T4>> ts4, Function4<T1, T2, T3, T4, Future<T5>> ts5) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        Objects.requireNonNull(ts3, "ts3 is null");
+        Objects.requireNonNull(ts4, "ts4 is null");
+        Objects.requireNonNull(ts5, "ts5 is null");
+        return new ForLazy5Future<>(ts1, ts2, ts3, ts4, ts5);
+    }
+
+    /**
+     * Creates a lazy {@code For}-comprehension over 6 Futures.
+     *
+     * <p>The first argument ({@code ts1}) is the initial Future. Each subsequent
+     * argument ({@code ts2} .. {@code ts6}) is a function that receives all values
+     * bound so far and returns the next Future. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st Future
+     * @param ts2 the 2nd Future
+     * @param ts3 the 3rd Future
+     * @param ts4 the 4th Future
+     * @param ts5 the 5th Future
+     * @param ts6 the 6th Future
+
+     * @param <T1> the component type of the 1st Future
+     * @param <T2> the component type of the 2nd Future
+     * @param <T3> the component type of the 3rd Future
+     * @param <T4> the component type of the 4th Future
+     * @param <T5> the component type of the 5th Future
+     * @param <T6> the component type of the 6th Future
+     * @return a new {@code ForLazy6Future} builder of arity 6
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <T1, T2, T3, T4, T5, T6> ForLazy6Future<T1, T2, T3, T4, T5, T6> For(Future<T1> ts1, Function1<T1, Future<T2>> ts2, Function2<T1, T2, Future<T3>> ts3, Function3<T1, T2, T3, Future<T4>> ts4, Function4<T1, T2, T3, T4, Future<T5>> ts5, Function5<T1, T2, T3, T4, T5, Future<T6>> ts6) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        Objects.requireNonNull(ts3, "ts3 is null");
+        Objects.requireNonNull(ts4, "ts4 is null");
+        Objects.requireNonNull(ts5, "ts5 is null");
+        Objects.requireNonNull(ts6, "ts6 is null");
+        return new ForLazy6Future<>(ts1, ts2, ts3, ts4, ts5, ts6);
+    }
+
+    /**
+     * Creates a lazy {@code For}-comprehension over 7 Futures.
+     *
+     * <p>The first argument ({@code ts1}) is the initial Future. Each subsequent
+     * argument ({@code ts2} .. {@code ts7}) is a function that receives all values
+     * bound so far and returns the next Future. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st Future
+     * @param ts2 the 2nd Future
+     * @param ts3 the 3rd Future
+     * @param ts4 the 4th Future
+     * @param ts5 the 5th Future
+     * @param ts6 the 6th Future
+     * @param ts7 the 7th Future
+
+     * @param <T1> the component type of the 1st Future
+     * @param <T2> the component type of the 2nd Future
+     * @param <T3> the component type of the 3rd Future
+     * @param <T4> the component type of the 4th Future
+     * @param <T5> the component type of the 5th Future
+     * @param <T6> the component type of the 6th Future
+     * @param <T7> the component type of the 7th Future
+     * @return a new {@code ForLazy7Future} builder of arity 7
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <T1, T2, T3, T4, T5, T6, T7> ForLazy7Future<T1, T2, T3, T4, T5, T6, T7> For(Future<T1> ts1, Function1<T1, Future<T2>> ts2, Function2<T1, T2, Future<T3>> ts3, Function3<T1, T2, T3, Future<T4>> ts4, Function4<T1, T2, T3, T4, Future<T5>> ts5, Function5<T1, T2, T3, T4, T5, Future<T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, Future<T7>> ts7) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        Objects.requireNonNull(ts3, "ts3 is null");
+        Objects.requireNonNull(ts4, "ts4 is null");
+        Objects.requireNonNull(ts5, "ts5 is null");
+        Objects.requireNonNull(ts6, "ts6 is null");
+        Objects.requireNonNull(ts7, "ts7 is null");
+        return new ForLazy7Future<>(ts1, ts2, ts3, ts4, ts5, ts6, ts7);
+    }
+
+    /**
+     * Creates a lazy {@code For}-comprehension over 8 Futures.
+     *
+     * <p>The first argument ({@code ts1}) is the initial Future. Each subsequent
+     * argument ({@code ts2} .. {@code ts8}) is a function that receives all values
+     * bound so far and returns the next Future. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st Future
+     * @param ts2 the 2nd Future
+     * @param ts3 the 3rd Future
+     * @param ts4 the 4th Future
+     * @param ts5 the 5th Future
+     * @param ts6 the 6th Future
+     * @param ts7 the 7th Future
+     * @param ts8 the 8th Future
+
+     * @param <T1> the component type of the 1st Future
+     * @param <T2> the component type of the 2nd Future
+     * @param <T3> the component type of the 3rd Future
+     * @param <T4> the component type of the 4th Future
+     * @param <T5> the component type of the 5th Future
+     * @param <T6> the component type of the 6th Future
+     * @param <T7> the component type of the 7th Future
+     * @param <T8> the component type of the 8th Future
+     * @return a new {@code ForLazy8Future} builder of arity 8
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <T1, T2, T3, T4, T5, T6, T7, T8> ForLazy8Future<T1, T2, T3, T4, T5, T6, T7, T8> For(Future<T1> ts1, Function1<T1, Future<T2>> ts2, Function2<T1, T2, Future<T3>> ts3, Function3<T1, T2, T3, Future<T4>> ts4, Function4<T1, T2, T3, T4, Future<T5>> ts5, Function5<T1, T2, T3, T4, T5, Future<T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, Future<T7>> ts7, Function7<T1, T2, T3, T4, T5, T6, T7, Future<T8>> ts8) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        Objects.requireNonNull(ts3, "ts3 is null");
+        Objects.requireNonNull(ts4, "ts4 is null");
+        Objects.requireNonNull(ts5, "ts5 is null");
+        Objects.requireNonNull(ts6, "ts6 is null");
+        Objects.requireNonNull(ts7, "ts7 is null");
+        Objects.requireNonNull(ts8, "ts8 is null");
+        return new ForLazy8Future<>(ts1, ts2, ts3, ts4, ts5, ts6, ts7, ts8);
+    }
+
+    /**
+     * Creates a lazy {@code For}-comprehension over two Trys.
+     *
+     * <p>The first argument ({@code ts1}) is the initial Try. Each subsequent
+     * argument ({@code ts2} .. {@code ts2}) is a function that receives all values
+     * bound so far and returns the next Try. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st Try
+     * @param ts2 the 2nd Try
+
+     * @param <T1> the component type of the 1st Try
+     * @param <T2> the component type of the 2nd Try
+     * @return a new {@code ForLazy2Try} builder of arity 2
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <T1, T2> ForLazy2Try<T1, T2> For(Try<T1> ts1, Function1<T1, Try<T2>> ts2) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        return new ForLazy2Try<>(ts1, ts2);
+    }
+
+    /**
+     * Creates a lazy {@code For}-comprehension over three Trys.
+     *
+     * <p>The first argument ({@code ts1}) is the initial Try. Each subsequent
+     * argument ({@code ts2} .. {@code ts3}) is a function that receives all values
+     * bound so far and returns the next Try. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st Try
+     * @param ts2 the 2nd Try
+     * @param ts3 the 3rd Try
+
+     * @param <T1> the component type of the 1st Try
+     * @param <T2> the component type of the 2nd Try
+     * @param <T3> the component type of the 3rd Try
+     * @return a new {@code ForLazy3Try} builder of arity 3
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <T1, T2, T3> ForLazy3Try<T1, T2, T3> For(Try<T1> ts1, Function1<T1, Try<T2>> ts2, Function2<T1, T2, Try<T3>> ts3) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        Objects.requireNonNull(ts3, "ts3 is null");
+        return new ForLazy3Try<>(ts1, ts2, ts3);
+    }
+
+    /**
+     * Creates a lazy {@code For}-comprehension over 4 Trys.
+     *
+     * <p>The first argument ({@code ts1}) is the initial Try. Each subsequent
+     * argument ({@code ts2} .. {@code ts4}) is a function that receives all values
+     * bound so far and returns the next Try. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st Try
+     * @param ts2 the 2nd Try
+     * @param ts3 the 3rd Try
+     * @param ts4 the 4th Try
+
+     * @param <T1> the component type of the 1st Try
+     * @param <T2> the component type of the 2nd Try
+     * @param <T3> the component type of the 3rd Try
+     * @param <T4> the component type of the 4th Try
+     * @return a new {@code ForLazy4Try} builder of arity 4
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <T1, T2, T3, T4> ForLazy4Try<T1, T2, T3, T4> For(Try<T1> ts1, Function1<T1, Try<T2>> ts2, Function2<T1, T2, Try<T3>> ts3, Function3<T1, T2, T3, Try<T4>> ts4) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        Objects.requireNonNull(ts3, "ts3 is null");
+        Objects.requireNonNull(ts4, "ts4 is null");
+        return new ForLazy4Try<>(ts1, ts2, ts3, ts4);
+    }
+
+    /**
+     * Creates a lazy {@code For}-comprehension over 5 Trys.
+     *
+     * <p>The first argument ({@code ts1}) is the initial Try. Each subsequent
+     * argument ({@code ts2} .. {@code ts5}) is a function that receives all values
+     * bound so far and returns the next Try. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st Try
+     * @param ts2 the 2nd Try
+     * @param ts3 the 3rd Try
+     * @param ts4 the 4th Try
+     * @param ts5 the 5th Try
+
+     * @param <T1> the component type of the 1st Try
+     * @param <T2> the component type of the 2nd Try
+     * @param <T3> the component type of the 3rd Try
+     * @param <T4> the component type of the 4th Try
+     * @param <T5> the component type of the 5th Try
+     * @return a new {@code ForLazy5Try} builder of arity 5
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <T1, T2, T3, T4, T5> ForLazy5Try<T1, T2, T3, T4, T5> For(Try<T1> ts1, Function1<T1, Try<T2>> ts2, Function2<T1, T2, Try<T3>> ts3, Function3<T1, T2, T3, Try<T4>> ts4, Function4<T1, T2, T3, T4, Try<T5>> ts5) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        Objects.requireNonNull(ts3, "ts3 is null");
+        Objects.requireNonNull(ts4, "ts4 is null");
+        Objects.requireNonNull(ts5, "ts5 is null");
+        return new ForLazy5Try<>(ts1, ts2, ts3, ts4, ts5);
+    }
+
+    /**
+     * Creates a lazy {@code For}-comprehension over 6 Trys.
+     *
+     * <p>The first argument ({@code ts1}) is the initial Try. Each subsequent
+     * argument ({@code ts2} .. {@code ts6}) is a function that receives all values
+     * bound so far and returns the next Try. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st Try
+     * @param ts2 the 2nd Try
+     * @param ts3 the 3rd Try
+     * @param ts4 the 4th Try
+     * @param ts5 the 5th Try
+     * @param ts6 the 6th Try
+
+     * @param <T1> the component type of the 1st Try
+     * @param <T2> the component type of the 2nd Try
+     * @param <T3> the component type of the 3rd Try
+     * @param <T4> the component type of the 4th Try
+     * @param <T5> the component type of the 5th Try
+     * @param <T6> the component type of the 6th Try
+     * @return a new {@code ForLazy6Try} builder of arity 6
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <T1, T2, T3, T4, T5, T6> ForLazy6Try<T1, T2, T3, T4, T5, T6> For(Try<T1> ts1, Function1<T1, Try<T2>> ts2, Function2<T1, T2, Try<T3>> ts3, Function3<T1, T2, T3, Try<T4>> ts4, Function4<T1, T2, T3, T4, Try<T5>> ts5, Function5<T1, T2, T3, T4, T5, Try<T6>> ts6) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        Objects.requireNonNull(ts3, "ts3 is null");
+        Objects.requireNonNull(ts4, "ts4 is null");
+        Objects.requireNonNull(ts5, "ts5 is null");
+        Objects.requireNonNull(ts6, "ts6 is null");
+        return new ForLazy6Try<>(ts1, ts2, ts3, ts4, ts5, ts6);
+    }
+
+    /**
+     * Creates a lazy {@code For}-comprehension over 7 Trys.
+     *
+     * <p>The first argument ({@code ts1}) is the initial Try. Each subsequent
+     * argument ({@code ts2} .. {@code ts7}) is a function that receives all values
+     * bound so far and returns the next Try. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st Try
+     * @param ts2 the 2nd Try
+     * @param ts3 the 3rd Try
+     * @param ts4 the 4th Try
+     * @param ts5 the 5th Try
+     * @param ts6 the 6th Try
+     * @param ts7 the 7th Try
+
+     * @param <T1> the component type of the 1st Try
+     * @param <T2> the component type of the 2nd Try
+     * @param <T3> the component type of the 3rd Try
+     * @param <T4> the component type of the 4th Try
+     * @param <T5> the component type of the 5th Try
+     * @param <T6> the component type of the 6th Try
+     * @param <T7> the component type of the 7th Try
+     * @return a new {@code ForLazy7Try} builder of arity 7
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <T1, T2, T3, T4, T5, T6, T7> ForLazy7Try<T1, T2, T3, T4, T5, T6, T7> For(Try<T1> ts1, Function1<T1, Try<T2>> ts2, Function2<T1, T2, Try<T3>> ts3, Function3<T1, T2, T3, Try<T4>> ts4, Function4<T1, T2, T3, T4, Try<T5>> ts5, Function5<T1, T2, T3, T4, T5, Try<T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, Try<T7>> ts7) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        Objects.requireNonNull(ts3, "ts3 is null");
+        Objects.requireNonNull(ts4, "ts4 is null");
+        Objects.requireNonNull(ts5, "ts5 is null");
+        Objects.requireNonNull(ts6, "ts6 is null");
+        Objects.requireNonNull(ts7, "ts7 is null");
+        return new ForLazy7Try<>(ts1, ts2, ts3, ts4, ts5, ts6, ts7);
+    }
+
+    /**
+     * Creates a lazy {@code For}-comprehension over 8 Trys.
+     *
+     * <p>The first argument ({@code ts1}) is the initial Try. Each subsequent
+     * argument ({@code ts2} .. {@code ts8}) is a function that receives all values
+     * bound so far and returns the next Try. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st Try
+     * @param ts2 the 2nd Try
+     * @param ts3 the 3rd Try
+     * @param ts4 the 4th Try
+     * @param ts5 the 5th Try
+     * @param ts6 the 6th Try
+     * @param ts7 the 7th Try
+     * @param ts8 the 8th Try
+
+     * @param <T1> the component type of the 1st Try
+     * @param <T2> the component type of the 2nd Try
+     * @param <T3> the component type of the 3rd Try
+     * @param <T4> the component type of the 4th Try
+     * @param <T5> the component type of the 5th Try
+     * @param <T6> the component type of the 6th Try
+     * @param <T7> the component type of the 7th Try
+     * @param <T8> the component type of the 8th Try
+     * @return a new {@code ForLazy8Try} builder of arity 8
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <T1, T2, T3, T4, T5, T6, T7, T8> ForLazy8Try<T1, T2, T3, T4, T5, T6, T7, T8> For(Try<T1> ts1, Function1<T1, Try<T2>> ts2, Function2<T1, T2, Try<T3>> ts3, Function3<T1, T2, T3, Try<T4>> ts4, Function4<T1, T2, T3, T4, Try<T5>> ts5, Function5<T1, T2, T3, T4, T5, Try<T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, Try<T7>> ts7, Function7<T1, T2, T3, T4, T5, T6, T7, Try<T8>> ts8) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        Objects.requireNonNull(ts3, "ts3 is null");
+        Objects.requireNonNull(ts4, "ts4 is null");
+        Objects.requireNonNull(ts5, "ts5 is null");
+        Objects.requireNonNull(ts6, "ts6 is null");
+        Objects.requireNonNull(ts7, "ts7 is null");
+        Objects.requireNonNull(ts8, "ts8 is null");
+        return new ForLazy8Try<>(ts1, ts2, ts3, ts4, ts5, ts6, ts7, ts8);
+    }
+
+    /**
+     * Creates a lazy {@code For}-comprehension over two Lists.
+     *
+     * <p>The first argument ({@code ts1}) is the initial List. Each subsequent
+     * argument ({@code ts2} .. {@code ts2}) is a function that receives all values
+     * bound so far and returns the next List. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st List
+     * @param ts2 the 2nd List
+
+     * @param <T1> the component type of the 1st List
+     * @param <T2> the component type of the 2nd List
+     * @return a new {@code ForLazy2List} builder of arity 2
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <T1, T2> ForLazy2List<T1, T2> For(List<T1> ts1, Function1<T1, List<T2>> ts2) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        return new ForLazy2List<>(ts1, ts2);
+    }
+
+    /**
+     * Creates a lazy {@code For}-comprehension over three Lists.
+     *
+     * <p>The first argument ({@code ts1}) is the initial List. Each subsequent
+     * argument ({@code ts2} .. {@code ts3}) is a function that receives all values
+     * bound so far and returns the next List. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st List
+     * @param ts2 the 2nd List
+     * @param ts3 the 3rd List
+
+     * @param <T1> the component type of the 1st List
+     * @param <T2> the component type of the 2nd List
+     * @param <T3> the component type of the 3rd List
+     * @return a new {@code ForLazy3List} builder of arity 3
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <T1, T2, T3> ForLazy3List<T1, T2, T3> For(List<T1> ts1, Function1<T1, List<T2>> ts2, Function2<T1, T2, List<T3>> ts3) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        Objects.requireNonNull(ts3, "ts3 is null");
+        return new ForLazy3List<>(ts1, ts2, ts3);
+    }
+
+    /**
+     * Creates a lazy {@code For}-comprehension over 4 Lists.
+     *
+     * <p>The first argument ({@code ts1}) is the initial List. Each subsequent
+     * argument ({@code ts2} .. {@code ts4}) is a function that receives all values
+     * bound so far and returns the next List. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st List
+     * @param ts2 the 2nd List
+     * @param ts3 the 3rd List
+     * @param ts4 the 4th List
+
+     * @param <T1> the component type of the 1st List
+     * @param <T2> the component type of the 2nd List
+     * @param <T3> the component type of the 3rd List
+     * @param <T4> the component type of the 4th List
+     * @return a new {@code ForLazy4List} builder of arity 4
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <T1, T2, T3, T4> ForLazy4List<T1, T2, T3, T4> For(List<T1> ts1, Function1<T1, List<T2>> ts2, Function2<T1, T2, List<T3>> ts3, Function3<T1, T2, T3, List<T4>> ts4) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        Objects.requireNonNull(ts3, "ts3 is null");
+        Objects.requireNonNull(ts4, "ts4 is null");
+        return new ForLazy4List<>(ts1, ts2, ts3, ts4);
+    }
+
+    /**
+     * Creates a lazy {@code For}-comprehension over 5 Lists.
+     *
+     * <p>The first argument ({@code ts1}) is the initial List. Each subsequent
+     * argument ({@code ts2} .. {@code ts5}) is a function that receives all values
+     * bound so far and returns the next List. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st List
+     * @param ts2 the 2nd List
+     * @param ts3 the 3rd List
+     * @param ts4 the 4th List
+     * @param ts5 the 5th List
+
+     * @param <T1> the component type of the 1st List
+     * @param <T2> the component type of the 2nd List
+     * @param <T3> the component type of the 3rd List
+     * @param <T4> the component type of the 4th List
+     * @param <T5> the component type of the 5th List
+     * @return a new {@code ForLazy5List} builder of arity 5
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <T1, T2, T3, T4, T5> ForLazy5List<T1, T2, T3, T4, T5> For(List<T1> ts1, Function1<T1, List<T2>> ts2, Function2<T1, T2, List<T3>> ts3, Function3<T1, T2, T3, List<T4>> ts4, Function4<T1, T2, T3, T4, List<T5>> ts5) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        Objects.requireNonNull(ts3, "ts3 is null");
+        Objects.requireNonNull(ts4, "ts4 is null");
+        Objects.requireNonNull(ts5, "ts5 is null");
+        return new ForLazy5List<>(ts1, ts2, ts3, ts4, ts5);
+    }
+
+    /**
+     * Creates a lazy {@code For}-comprehension over 6 Lists.
+     *
+     * <p>The first argument ({@code ts1}) is the initial List. Each subsequent
+     * argument ({@code ts2} .. {@code ts6}) is a function that receives all values
+     * bound so far and returns the next List. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st List
+     * @param ts2 the 2nd List
+     * @param ts3 the 3rd List
+     * @param ts4 the 4th List
+     * @param ts5 the 5th List
+     * @param ts6 the 6th List
+
+     * @param <T1> the component type of the 1st List
+     * @param <T2> the component type of the 2nd List
+     * @param <T3> the component type of the 3rd List
+     * @param <T4> the component type of the 4th List
+     * @param <T5> the component type of the 5th List
+     * @param <T6> the component type of the 6th List
+     * @return a new {@code ForLazy6List} builder of arity 6
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <T1, T2, T3, T4, T5, T6> ForLazy6List<T1, T2, T3, T4, T5, T6> For(List<T1> ts1, Function1<T1, List<T2>> ts2, Function2<T1, T2, List<T3>> ts3, Function3<T1, T2, T3, List<T4>> ts4, Function4<T1, T2, T3, T4, List<T5>> ts5, Function5<T1, T2, T3, T4, T5, List<T6>> ts6) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        Objects.requireNonNull(ts3, "ts3 is null");
+        Objects.requireNonNull(ts4, "ts4 is null");
+        Objects.requireNonNull(ts5, "ts5 is null");
+        Objects.requireNonNull(ts6, "ts6 is null");
+        return new ForLazy6List<>(ts1, ts2, ts3, ts4, ts5, ts6);
+    }
+
+    /**
+     * Creates a lazy {@code For}-comprehension over 7 Lists.
+     *
+     * <p>The first argument ({@code ts1}) is the initial List. Each subsequent
+     * argument ({@code ts2} .. {@code ts7}) is a function that receives all values
+     * bound so far and returns the next List. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st List
+     * @param ts2 the 2nd List
+     * @param ts3 the 3rd List
+     * @param ts4 the 4th List
+     * @param ts5 the 5th List
+     * @param ts6 the 6th List
+     * @param ts7 the 7th List
+
+     * @param <T1> the component type of the 1st List
+     * @param <T2> the component type of the 2nd List
+     * @param <T3> the component type of the 3rd List
+     * @param <T4> the component type of the 4th List
+     * @param <T5> the component type of the 5th List
+     * @param <T6> the component type of the 6th List
+     * @param <T7> the component type of the 7th List
+     * @return a new {@code ForLazy7List} builder of arity 7
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <T1, T2, T3, T4, T5, T6, T7> ForLazy7List<T1, T2, T3, T4, T5, T6, T7> For(List<T1> ts1, Function1<T1, List<T2>> ts2, Function2<T1, T2, List<T3>> ts3, Function3<T1, T2, T3, List<T4>> ts4, Function4<T1, T2, T3, T4, List<T5>> ts5, Function5<T1, T2, T3, T4, T5, List<T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, List<T7>> ts7) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        Objects.requireNonNull(ts3, "ts3 is null");
+        Objects.requireNonNull(ts4, "ts4 is null");
+        Objects.requireNonNull(ts5, "ts5 is null");
+        Objects.requireNonNull(ts6, "ts6 is null");
+        Objects.requireNonNull(ts7, "ts7 is null");
+        return new ForLazy7List<>(ts1, ts2, ts3, ts4, ts5, ts6, ts7);
+    }
+
+    /**
+     * Creates a lazy {@code For}-comprehension over 8 Lists.
+     *
+     * <p>The first argument ({@code ts1}) is the initial List. Each subsequent
+     * argument ({@code ts2} .. {@code ts8}) is a function that receives all values
+     * bound so far and returns the next List. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st List
+     * @param ts2 the 2nd List
+     * @param ts3 the 3rd List
+     * @param ts4 the 4th List
+     * @param ts5 the 5th List
+     * @param ts6 the 6th List
+     * @param ts7 the 7th List
+     * @param ts8 the 8th List
+
+     * @param <T1> the component type of the 1st List
+     * @param <T2> the component type of the 2nd List
+     * @param <T3> the component type of the 3rd List
+     * @param <T4> the component type of the 4th List
+     * @param <T5> the component type of the 5th List
+     * @param <T6> the component type of the 6th List
+     * @param <T7> the component type of the 7th List
+     * @param <T8> the component type of the 8th List
+     * @return a new {@code ForLazy8List} builder of arity 8
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <T1, T2, T3, T4, T5, T6, T7, T8> ForLazy8List<T1, T2, T3, T4, T5, T6, T7, T8> For(List<T1> ts1, Function1<T1, List<T2>> ts2, Function2<T1, T2, List<T3>> ts3, Function3<T1, T2, T3, List<T4>> ts4, Function4<T1, T2, T3, T4, List<T5>> ts5, Function5<T1, T2, T3, T4, T5, List<T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, List<T7>> ts7, Function7<T1, T2, T3, T4, T5, T6, T7, List<T8>> ts8) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        Objects.requireNonNull(ts3, "ts3 is null");
+        Objects.requireNonNull(ts4, "ts4 is null");
+        Objects.requireNonNull(ts5, "ts5 is null");
+        Objects.requireNonNull(ts6, "ts6 is null");
+        Objects.requireNonNull(ts7, "ts7 is null");
+        Objects.requireNonNull(ts8, "ts8 is null");
+        return new ForLazy8List<>(ts1, ts2, ts3, ts4, ts5, ts6, ts7, ts8);
+    }
+
+    /**
+     * Creates a lazy {@code For}-comprehension over two Eithers.
+     *
+     * <p>The first argument ({@code ts1}) is the initial Either. Each subsequent
+     * argument ({@code ts2} .. {@code ts2}) is a function that receives all values
+     * bound so far and returns the next Either. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st Either
+     * @param ts2 the 2nd Either
+     * @param <L> the common left-hand type of all Eithers
+     * @param <T1> the component type of the 1st Either
+     * @param <T2> the component type of the 2nd Either
+     * @return a new {@code ForLazy2Either} builder of arity 2
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <L, T1, T2> ForLazy2Either<L, T1, T2> For(Either<L, T1> ts1, Function1<T1, Either<L, T2>> ts2) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        return new ForLazy2Either<>(ts1, ts2);
+    }
+
+    /**
+     * Creates a lazy {@code For}-comprehension over three Eithers.
+     *
+     * <p>The first argument ({@code ts1}) is the initial Either. Each subsequent
+     * argument ({@code ts2} .. {@code ts3}) is a function that receives all values
+     * bound so far and returns the next Either. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st Either
+     * @param ts2 the 2nd Either
+     * @param ts3 the 3rd Either
+     * @param <L> the common left-hand type of all Eithers
+     * @param <T1> the component type of the 1st Either
+     * @param <T2> the component type of the 2nd Either
+     * @param <T3> the component type of the 3rd Either
+     * @return a new {@code ForLazy3Either} builder of arity 3
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <L, T1, T2, T3> ForLazy3Either<L, T1, T2, T3> For(Either<L, T1> ts1, Function1<T1, Either<L, T2>> ts2, Function2<T1, T2, Either<L, T3>> ts3) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        Objects.requireNonNull(ts3, "ts3 is null");
+        return new ForLazy3Either<>(ts1, ts2, ts3);
+    }
+
+    /**
+     * Creates a lazy {@code For}-comprehension over 4 Eithers.
+     *
+     * <p>The first argument ({@code ts1}) is the initial Either. Each subsequent
+     * argument ({@code ts2} .. {@code ts4}) is a function that receives all values
+     * bound so far and returns the next Either. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st Either
+     * @param ts2 the 2nd Either
+     * @param ts3 the 3rd Either
+     * @param ts4 the 4th Either
+     * @param <L> the common left-hand type of all Eithers
+     * @param <T1> the component type of the 1st Either
+     * @param <T2> the component type of the 2nd Either
+     * @param <T3> the component type of the 3rd Either
+     * @param <T4> the component type of the 4th Either
+     * @return a new {@code ForLazy4Either} builder of arity 4
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <L, T1, T2, T3, T4> ForLazy4Either<L, T1, T2, T3, T4> For(Either<L, T1> ts1, Function1<T1, Either<L, T2>> ts2, Function2<T1, T2, Either<L, T3>> ts3, Function3<T1, T2, T3, Either<L, T4>> ts4) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        Objects.requireNonNull(ts3, "ts3 is null");
+        Objects.requireNonNull(ts4, "ts4 is null");
+        return new ForLazy4Either<>(ts1, ts2, ts3, ts4);
+    }
+
+    /**
+     * Creates a lazy {@code For}-comprehension over 5 Eithers.
+     *
+     * <p>The first argument ({@code ts1}) is the initial Either. Each subsequent
+     * argument ({@code ts2} .. {@code ts5}) is a function that receives all values
+     * bound so far and returns the next Either. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st Either
+     * @param ts2 the 2nd Either
+     * @param ts3 the 3rd Either
+     * @param ts4 the 4th Either
+     * @param ts5 the 5th Either
+     * @param <L> the common left-hand type of all Eithers
+     * @param <T1> the component type of the 1st Either
+     * @param <T2> the component type of the 2nd Either
+     * @param <T3> the component type of the 3rd Either
+     * @param <T4> the component type of the 4th Either
+     * @param <T5> the component type of the 5th Either
+     * @return a new {@code ForLazy5Either} builder of arity 5
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <L, T1, T2, T3, T4, T5> ForLazy5Either<L, T1, T2, T3, T4, T5> For(Either<L, T1> ts1, Function1<T1, Either<L, T2>> ts2, Function2<T1, T2, Either<L, T3>> ts3, Function3<T1, T2, T3, Either<L, T4>> ts4, Function4<T1, T2, T3, T4, Either<L, T5>> ts5) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        Objects.requireNonNull(ts3, "ts3 is null");
+        Objects.requireNonNull(ts4, "ts4 is null");
+        Objects.requireNonNull(ts5, "ts5 is null");
+        return new ForLazy5Either<>(ts1, ts2, ts3, ts4, ts5);
+    }
+
+    /**
+     * Creates a lazy {@code For}-comprehension over 6 Eithers.
+     *
+     * <p>The first argument ({@code ts1}) is the initial Either. Each subsequent
+     * argument ({@code ts2} .. {@code ts6}) is a function that receives all values
+     * bound so far and returns the next Either. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st Either
+     * @param ts2 the 2nd Either
+     * @param ts3 the 3rd Either
+     * @param ts4 the 4th Either
+     * @param ts5 the 5th Either
+     * @param ts6 the 6th Either
+     * @param <L> the common left-hand type of all Eithers
+     * @param <T1> the component type of the 1st Either
+     * @param <T2> the component type of the 2nd Either
+     * @param <T3> the component type of the 3rd Either
+     * @param <T4> the component type of the 4th Either
+     * @param <T5> the component type of the 5th Either
+     * @param <T6> the component type of the 6th Either
+     * @return a new {@code ForLazy6Either} builder of arity 6
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <L, T1, T2, T3, T4, T5, T6> ForLazy6Either<L, T1, T2, T3, T4, T5, T6> For(Either<L, T1> ts1, Function1<T1, Either<L, T2>> ts2, Function2<T1, T2, Either<L, T3>> ts3, Function3<T1, T2, T3, Either<L, T4>> ts4, Function4<T1, T2, T3, T4, Either<L, T5>> ts5, Function5<T1, T2, T3, T4, T5, Either<L, T6>> ts6) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        Objects.requireNonNull(ts3, "ts3 is null");
+        Objects.requireNonNull(ts4, "ts4 is null");
+        Objects.requireNonNull(ts5, "ts5 is null");
+        Objects.requireNonNull(ts6, "ts6 is null");
+        return new ForLazy6Either<>(ts1, ts2, ts3, ts4, ts5, ts6);
+    }
+
+    /**
+     * Creates a lazy {@code For}-comprehension over 7 Eithers.
+     *
+     * <p>The first argument ({@code ts1}) is the initial Either. Each subsequent
+     * argument ({@code ts2} .. {@code ts7}) is a function that receives all values
+     * bound so far and returns the next Either. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st Either
+     * @param ts2 the 2nd Either
+     * @param ts3 the 3rd Either
+     * @param ts4 the 4th Either
+     * @param ts5 the 5th Either
+     * @param ts6 the 6th Either
+     * @param ts7 the 7th Either
+     * @param <L> the common left-hand type of all Eithers
+     * @param <T1> the component type of the 1st Either
+     * @param <T2> the component type of the 2nd Either
+     * @param <T3> the component type of the 3rd Either
+     * @param <T4> the component type of the 4th Either
+     * @param <T5> the component type of the 5th Either
+     * @param <T6> the component type of the 6th Either
+     * @param <T7> the component type of the 7th Either
+     * @return a new {@code ForLazy7Either} builder of arity 7
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <L, T1, T2, T3, T4, T5, T6, T7> ForLazy7Either<L, T1, T2, T3, T4, T5, T6, T7> For(Either<L, T1> ts1, Function1<T1, Either<L, T2>> ts2, Function2<T1, T2, Either<L, T3>> ts3, Function3<T1, T2, T3, Either<L, T4>> ts4, Function4<T1, T2, T3, T4, Either<L, T5>> ts5, Function5<T1, T2, T3, T4, T5, Either<L, T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, Either<L, T7>> ts7) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        Objects.requireNonNull(ts3, "ts3 is null");
+        Objects.requireNonNull(ts4, "ts4 is null");
+        Objects.requireNonNull(ts5, "ts5 is null");
+        Objects.requireNonNull(ts6, "ts6 is null");
+        Objects.requireNonNull(ts7, "ts7 is null");
+        return new ForLazy7Either<>(ts1, ts2, ts3, ts4, ts5, ts6, ts7);
+    }
+
+    /**
+     * Creates a lazy {@code For}-comprehension over 8 Eithers.
+     *
+     * <p>The first argument ({@code ts1}) is the initial Either. Each subsequent
+     * argument ({@code ts2} .. {@code ts8}) is a function that receives all values
+     * bound so far and returns the next Either. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st Either
+     * @param ts2 the 2nd Either
+     * @param ts3 the 3rd Either
+     * @param ts4 the 4th Either
+     * @param ts5 the 5th Either
+     * @param ts6 the 6th Either
+     * @param ts7 the 7th Either
+     * @param ts8 the 8th Either
+     * @param <L> the common left-hand type of all Eithers
+     * @param <T1> the component type of the 1st Either
+     * @param <T2> the component type of the 2nd Either
+     * @param <T3> the component type of the 3rd Either
+     * @param <T4> the component type of the 4th Either
+     * @param <T5> the component type of the 5th Either
+     * @param <T6> the component type of the 6th Either
+     * @param <T7> the component type of the 7th Either
+     * @param <T8> the component type of the 8th Either
+     * @return a new {@code ForLazy8Either} builder of arity 8
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <L, T1, T2, T3, T4, T5, T6, T7, T8> ForLazy8Either<L, T1, T2, T3, T4, T5, T6, T7, T8> For(Either<L, T1> ts1, Function1<T1, Either<L, T2>> ts2, Function2<T1, T2, Either<L, T3>> ts3, Function3<T1, T2, T3, Either<L, T4>> ts4, Function4<T1, T2, T3, T4, Either<L, T5>> ts5, Function5<T1, T2, T3, T4, T5, Either<L, T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, Either<L, T7>> ts7, Function7<T1, T2, T3, T4, T5, T6, T7, Either<L, T8>> ts8) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        Objects.requireNonNull(ts3, "ts3 is null");
+        Objects.requireNonNull(ts4, "ts4 is null");
+        Objects.requireNonNull(ts5, "ts5 is null");
+        Objects.requireNonNull(ts6, "ts6 is null");
+        Objects.requireNonNull(ts7, "ts7 is null");
+        Objects.requireNonNull(ts8, "ts8 is null");
+        return new ForLazy8Either<>(ts1, ts2, ts3, ts4, ts5, ts6, ts7, ts8);
+    }
+
+    /**
+     * Creates a lazy {@code For}-comprehension over two Validations.
+     *
+     * <p>The first argument ({@code ts1}) is the initial Validation. Each subsequent
+     * argument ({@code ts2} .. {@code ts2}) is a function that receives all values
+     * bound so far and returns the next Validation. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st Validation
+     * @param ts2 the 2nd Validation
+     * @param <L> the common left-hand type of all Validations
+     * @param <T1> the component type of the 1st Validation
+     * @param <T2> the component type of the 2nd Validation
+     * @return a new {@code ForLazy2Validation} builder of arity 2
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <L, T1, T2> ForLazy2Validation<L, T1, T2> For(Validation<L, T1> ts1, Function1<T1, Validation<L, T2>> ts2) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        return new ForLazy2Validation<>(ts1, ts2);
+    }
+
+    /**
+     * Creates a lazy {@code For}-comprehension over three Validations.
+     *
+     * <p>The first argument ({@code ts1}) is the initial Validation. Each subsequent
+     * argument ({@code ts2} .. {@code ts3}) is a function that receives all values
+     * bound so far and returns the next Validation. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st Validation
+     * @param ts2 the 2nd Validation
+     * @param ts3 the 3rd Validation
+     * @param <L> the common left-hand type of all Validations
+     * @param <T1> the component type of the 1st Validation
+     * @param <T2> the component type of the 2nd Validation
+     * @param <T3> the component type of the 3rd Validation
+     * @return a new {@code ForLazy3Validation} builder of arity 3
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <L, T1, T2, T3> ForLazy3Validation<L, T1, T2, T3> For(Validation<L, T1> ts1, Function1<T1, Validation<L, T2>> ts2, Function2<T1, T2, Validation<L, T3>> ts3) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        Objects.requireNonNull(ts3, "ts3 is null");
+        return new ForLazy3Validation<>(ts1, ts2, ts3);
+    }
+
+    /**
+     * Creates a lazy {@code For}-comprehension over 4 Validations.
+     *
+     * <p>The first argument ({@code ts1}) is the initial Validation. Each subsequent
+     * argument ({@code ts2} .. {@code ts4}) is a function that receives all values
+     * bound so far and returns the next Validation. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st Validation
+     * @param ts2 the 2nd Validation
+     * @param ts3 the 3rd Validation
+     * @param ts4 the 4th Validation
+     * @param <L> the common left-hand type of all Validations
+     * @param <T1> the component type of the 1st Validation
+     * @param <T2> the component type of the 2nd Validation
+     * @param <T3> the component type of the 3rd Validation
+     * @param <T4> the component type of the 4th Validation
+     * @return a new {@code ForLazy4Validation} builder of arity 4
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <L, T1, T2, T3, T4> ForLazy4Validation<L, T1, T2, T3, T4> For(Validation<L, T1> ts1, Function1<T1, Validation<L, T2>> ts2, Function2<T1, T2, Validation<L, T3>> ts3, Function3<T1, T2, T3, Validation<L, T4>> ts4) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        Objects.requireNonNull(ts3, "ts3 is null");
+        Objects.requireNonNull(ts4, "ts4 is null");
+        return new ForLazy4Validation<>(ts1, ts2, ts3, ts4);
+    }
+
+    /**
+     * Creates a lazy {@code For}-comprehension over 5 Validations.
+     *
+     * <p>The first argument ({@code ts1}) is the initial Validation. Each subsequent
+     * argument ({@code ts2} .. {@code ts5}) is a function that receives all values
+     * bound so far and returns the next Validation. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st Validation
+     * @param ts2 the 2nd Validation
+     * @param ts3 the 3rd Validation
+     * @param ts4 the 4th Validation
+     * @param ts5 the 5th Validation
+     * @param <L> the common left-hand type of all Validations
+     * @param <T1> the component type of the 1st Validation
+     * @param <T2> the component type of the 2nd Validation
+     * @param <T3> the component type of the 3rd Validation
+     * @param <T4> the component type of the 4th Validation
+     * @param <T5> the component type of the 5th Validation
+     * @return a new {@code ForLazy5Validation} builder of arity 5
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <L, T1, T2, T3, T4, T5> ForLazy5Validation<L, T1, T2, T3, T4, T5> For(Validation<L, T1> ts1, Function1<T1, Validation<L, T2>> ts2, Function2<T1, T2, Validation<L, T3>> ts3, Function3<T1, T2, T3, Validation<L, T4>> ts4, Function4<T1, T2, T3, T4, Validation<L, T5>> ts5) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        Objects.requireNonNull(ts3, "ts3 is null");
+        Objects.requireNonNull(ts4, "ts4 is null");
+        Objects.requireNonNull(ts5, "ts5 is null");
+        return new ForLazy5Validation<>(ts1, ts2, ts3, ts4, ts5);
+    }
+
+    /**
+     * Creates a lazy {@code For}-comprehension over 6 Validations.
+     *
+     * <p>The first argument ({@code ts1}) is the initial Validation. Each subsequent
+     * argument ({@code ts2} .. {@code ts6}) is a function that receives all values
+     * bound so far and returns the next Validation. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st Validation
+     * @param ts2 the 2nd Validation
+     * @param ts3 the 3rd Validation
+     * @param ts4 the 4th Validation
+     * @param ts5 the 5th Validation
+     * @param ts6 the 6th Validation
+     * @param <L> the common left-hand type of all Validations
+     * @param <T1> the component type of the 1st Validation
+     * @param <T2> the component type of the 2nd Validation
+     * @param <T3> the component type of the 3rd Validation
+     * @param <T4> the component type of the 4th Validation
+     * @param <T5> the component type of the 5th Validation
+     * @param <T6> the component type of the 6th Validation
+     * @return a new {@code ForLazy6Validation} builder of arity 6
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <L, T1, T2, T3, T4, T5, T6> ForLazy6Validation<L, T1, T2, T3, T4, T5, T6> For(Validation<L, T1> ts1, Function1<T1, Validation<L, T2>> ts2, Function2<T1, T2, Validation<L, T3>> ts3, Function3<T1, T2, T3, Validation<L, T4>> ts4, Function4<T1, T2, T3, T4, Validation<L, T5>> ts5, Function5<T1, T2, T3, T4, T5, Validation<L, T6>> ts6) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        Objects.requireNonNull(ts3, "ts3 is null");
+        Objects.requireNonNull(ts4, "ts4 is null");
+        Objects.requireNonNull(ts5, "ts5 is null");
+        Objects.requireNonNull(ts6, "ts6 is null");
+        return new ForLazy6Validation<>(ts1, ts2, ts3, ts4, ts5, ts6);
+    }
+
+    /**
+     * Creates a lazy {@code For}-comprehension over 7 Validations.
+     *
+     * <p>The first argument ({@code ts1}) is the initial Validation. Each subsequent
+     * argument ({@code ts2} .. {@code ts7}) is a function that receives all values
+     * bound so far and returns the next Validation. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st Validation
+     * @param ts2 the 2nd Validation
+     * @param ts3 the 3rd Validation
+     * @param ts4 the 4th Validation
+     * @param ts5 the 5th Validation
+     * @param ts6 the 6th Validation
+     * @param ts7 the 7th Validation
+     * @param <L> the common left-hand type of all Validations
+     * @param <T1> the component type of the 1st Validation
+     * @param <T2> the component type of the 2nd Validation
+     * @param <T3> the component type of the 3rd Validation
+     * @param <T4> the component type of the 4th Validation
+     * @param <T5> the component type of the 5th Validation
+     * @param <T6> the component type of the 6th Validation
+     * @param <T7> the component type of the 7th Validation
+     * @return a new {@code ForLazy7Validation} builder of arity 7
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <L, T1, T2, T3, T4, T5, T6, T7> ForLazy7Validation<L, T1, T2, T3, T4, T5, T6, T7> For(Validation<L, T1> ts1, Function1<T1, Validation<L, T2>> ts2, Function2<T1, T2, Validation<L, T3>> ts3, Function3<T1, T2, T3, Validation<L, T4>> ts4, Function4<T1, T2, T3, T4, Validation<L, T5>> ts5, Function5<T1, T2, T3, T4, T5, Validation<L, T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, Validation<L, T7>> ts7) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        Objects.requireNonNull(ts3, "ts3 is null");
+        Objects.requireNonNull(ts4, "ts4 is null");
+        Objects.requireNonNull(ts5, "ts5 is null");
+        Objects.requireNonNull(ts6, "ts6 is null");
+        Objects.requireNonNull(ts7, "ts7 is null");
+        return new ForLazy7Validation<>(ts1, ts2, ts3, ts4, ts5, ts6, ts7);
+    }
+
+    /**
+     * Creates a lazy {@code For}-comprehension over 8 Validations.
+     *
+     * <p>The first argument ({@code ts1}) is the initial Validation. Each subsequent
+     * argument ({@code ts2} .. {@code ts8}) is a function that receives all values
+     * bound so far and returns the next Validation. This only builds the lazy
+     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     *
+     *
+     * @param ts1 the 1st Validation
+     * @param ts2 the 2nd Validation
+     * @param ts3 the 3rd Validation
+     * @param ts4 the 4th Validation
+     * @param ts5 the 5th Validation
+     * @param ts6 the 6th Validation
+     * @param ts7 the 7th Validation
+     * @param ts8 the 8th Validation
+     * @param <L> the common left-hand type of all Validations
+     * @param <T1> the component type of the 1st Validation
+     * @param <T2> the component type of the 2nd Validation
+     * @param <T3> the component type of the 3rd Validation
+     * @param <T4> the component type of the 4th Validation
+     * @param <T5> the component type of the 5th Validation
+     * @param <T6> the component type of the 6th Validation
+     * @param <T7> the component type of the 7th Validation
+     * @param <T8> the component type of the 8th Validation
+     * @return a new {@code ForLazy8Validation} builder of arity 8
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    public static <L, T1, T2, T3, T4, T5, T6, T7, T8> ForLazy8Validation<L, T1, T2, T3, T4, T5, T6, T7, T8> For(Validation<L, T1> ts1, Function1<T1, Validation<L, T2>> ts2, Function2<T1, T2, Validation<L, T3>> ts3, Function3<T1, T2, T3, Validation<L, T4>> ts4, Function4<T1, T2, T3, T4, Validation<L, T5>> ts5, Function5<T1, T2, T3, T4, T5, Validation<L, T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, Validation<L, T7>> ts7, Function7<T1, T2, T3, T4, T5, T6, T7, Validation<L, T8>> ts8) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        Objects.requireNonNull(ts3, "ts3 is null");
+        Objects.requireNonNull(ts4, "ts4 is null");
+        Objects.requireNonNull(ts5, "ts5 is null");
+        Objects.requireNonNull(ts6, "ts6 is null");
+        Objects.requireNonNull(ts7, "ts7 is null");
+        Objects.requireNonNull(ts8, "ts8 is null");
+        return new ForLazy8Validation<>(ts1, ts2, ts3, ts4, ts5, ts6, ts7, ts8);
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with two Options.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Options are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+
+     * @param <T1> the component type of the 1st Option
+     * @param <T2> the component type of the 2nd Option
+     */
+    public static class ForLazy2Option<T1, T2> {
+
+        private final Option<T1> ts1;
+        private final Function1<T1, Option<T2>> ts2;
+
+        private ForLazy2Option(Option<T1> ts1, Function1<T1, Option<T2>> ts2) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Options by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code Option}
+         * @return an {@code Option} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> Option<R> yield(BiFunction<? super T1, ? super T2, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).map(t2 -> f.apply(t1, t2));
+          });
+        }
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with three Options.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Options are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+
+     * @param <T1> the component type of the 1st Option
+     * @param <T2> the component type of the 2nd Option
+     * @param <T3> the component type of the 3rd Option
+     */
+    public static class ForLazy3Option<T1, T2, T3> {
+
+        private final Option<T1> ts1;
+        private final Function1<T1, Option<T2>> ts2;
+        private final Function2<T1, T2, Option<T3>> ts3;
+
+        private ForLazy3Option(Option<T1> ts1, Function1<T1, Option<T2>> ts2, Function2<T1, T2, Option<T3>> ts3) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+            this.ts3 = ts3;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Options by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code Option}
+         * @return an {@code Option} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> Option<R> yield(Function3<? super T1, ? super T2, ? super T3, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).flatMap(t2 -> {
+              return ts3.apply(t1, t2).map(t3 -> f.apply(t1, t2, t3));
+            });
+          });
+        }
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with 4 Options.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Options are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+
+     * @param <T1> the component type of the 1st Option
+     * @param <T2> the component type of the 2nd Option
+     * @param <T3> the component type of the 3rd Option
+     * @param <T4> the component type of the 4th Option
+     */
+    public static class ForLazy4Option<T1, T2, T3, T4> {
+
+        private final Option<T1> ts1;
+        private final Function1<T1, Option<T2>> ts2;
+        private final Function2<T1, T2, Option<T3>> ts3;
+        private final Function3<T1, T2, T3, Option<T4>> ts4;
+
+        private ForLazy4Option(Option<T1> ts1, Function1<T1, Option<T2>> ts2, Function2<T1, T2, Option<T3>> ts3, Function3<T1, T2, T3, Option<T4>> ts4) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+            this.ts3 = ts3;
+            this.ts4 = ts4;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Options by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code Option}
+         * @return an {@code Option} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> Option<R> yield(Function4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).flatMap(t2 -> {
+              return ts3.apply(t1, t2).flatMap(t3 -> {
+                return ts4.apply(t1, t2, t3).map(t4 -> f.apply(t1, t2, t3, t4));
+              });
+            });
+          });
+        }
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with 5 Options.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Options are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+
+     * @param <T1> the component type of the 1st Option
+     * @param <T2> the component type of the 2nd Option
+     * @param <T3> the component type of the 3rd Option
+     * @param <T4> the component type of the 4th Option
+     * @param <T5> the component type of the 5th Option
+     */
+    public static class ForLazy5Option<T1, T2, T3, T4, T5> {
+
+        private final Option<T1> ts1;
+        private final Function1<T1, Option<T2>> ts2;
+        private final Function2<T1, T2, Option<T3>> ts3;
+        private final Function3<T1, T2, T3, Option<T4>> ts4;
+        private final Function4<T1, T2, T3, T4, Option<T5>> ts5;
+
+        private ForLazy5Option(Option<T1> ts1, Function1<T1, Option<T2>> ts2, Function2<T1, T2, Option<T3>> ts3, Function3<T1, T2, T3, Option<T4>> ts4, Function4<T1, T2, T3, T4, Option<T5>> ts5) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+            this.ts3 = ts3;
+            this.ts4 = ts4;
+            this.ts5 = ts5;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Options by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code Option}
+         * @return an {@code Option} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> Option<R> yield(Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).flatMap(t2 -> {
+              return ts3.apply(t1, t2).flatMap(t3 -> {
+                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                  return ts5.apply(t1, t2, t3, t4).map(t5 -> f.apply(t1, t2, t3, t4, t5));
+                });
+              });
+            });
+          });
+        }
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with 6 Options.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Options are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+
+     * @param <T1> the component type of the 1st Option
+     * @param <T2> the component type of the 2nd Option
+     * @param <T3> the component type of the 3rd Option
+     * @param <T4> the component type of the 4th Option
+     * @param <T5> the component type of the 5th Option
+     * @param <T6> the component type of the 6th Option
+     */
+    public static class ForLazy6Option<T1, T2, T3, T4, T5, T6> {
+
+        private final Option<T1> ts1;
+        private final Function1<T1, Option<T2>> ts2;
+        private final Function2<T1, T2, Option<T3>> ts3;
+        private final Function3<T1, T2, T3, Option<T4>> ts4;
+        private final Function4<T1, T2, T3, T4, Option<T5>> ts5;
+        private final Function5<T1, T2, T3, T4, T5, Option<T6>> ts6;
+
+        private ForLazy6Option(Option<T1> ts1, Function1<T1, Option<T2>> ts2, Function2<T1, T2, Option<T3>> ts3, Function3<T1, T2, T3, Option<T4>> ts4, Function4<T1, T2, T3, T4, Option<T5>> ts5, Function5<T1, T2, T3, T4, T5, Option<T6>> ts6) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+            this.ts3 = ts3;
+            this.ts4 = ts4;
+            this.ts5 = ts5;
+            this.ts6 = ts6;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Options by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code Option}
+         * @return an {@code Option} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> Option<R> yield(Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).flatMap(t2 -> {
+              return ts3.apply(t1, t2).flatMap(t3 -> {
+                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                  return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
+                    return ts6.apply(t1, t2, t3, t4, t5).map(t6 -> f.apply(t1, t2, t3, t4, t5, t6));
+                  });
+                });
+              });
+            });
+          });
+        }
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with 7 Options.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Options are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+
+     * @param <T1> the component type of the 1st Option
+     * @param <T2> the component type of the 2nd Option
+     * @param <T3> the component type of the 3rd Option
+     * @param <T4> the component type of the 4th Option
+     * @param <T5> the component type of the 5th Option
+     * @param <T6> the component type of the 6th Option
+     * @param <T7> the component type of the 7th Option
+     */
+    public static class ForLazy7Option<T1, T2, T3, T4, T5, T6, T7> {
+
+        private final Option<T1> ts1;
+        private final Function1<T1, Option<T2>> ts2;
+        private final Function2<T1, T2, Option<T3>> ts3;
+        private final Function3<T1, T2, T3, Option<T4>> ts4;
+        private final Function4<T1, T2, T3, T4, Option<T5>> ts5;
+        private final Function5<T1, T2, T3, T4, T5, Option<T6>> ts6;
+        private final Function6<T1, T2, T3, T4, T5, T6, Option<T7>> ts7;
+
+        private ForLazy7Option(Option<T1> ts1, Function1<T1, Option<T2>> ts2, Function2<T1, T2, Option<T3>> ts3, Function3<T1, T2, T3, Option<T4>> ts4, Function4<T1, T2, T3, T4, Option<T5>> ts5, Function5<T1, T2, T3, T4, T5, Option<T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, Option<T7>> ts7) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+            this.ts3 = ts3;
+            this.ts4 = ts4;
+            this.ts5 = ts5;
+            this.ts6 = ts6;
+            this.ts7 = ts7;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Options by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code Option}
+         * @return an {@code Option} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> Option<R> yield(Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).flatMap(t2 -> {
+              return ts3.apply(t1, t2).flatMap(t3 -> {
+                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                  return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
+                    return ts6.apply(t1, t2, t3, t4, t5).flatMap(t6 -> {
+                      return ts7.apply(t1, t2, t3, t4, t5, t6).map(t7 -> f.apply(t1, t2, t3, t4, t5, t6, t7));
+                    });
+                  });
+                });
+              });
+            });
+          });
+        }
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with 8 Options.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Options are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+
+     * @param <T1> the component type of the 1st Option
+     * @param <T2> the component type of the 2nd Option
+     * @param <T3> the component type of the 3rd Option
+     * @param <T4> the component type of the 4th Option
+     * @param <T5> the component type of the 5th Option
+     * @param <T6> the component type of the 6th Option
+     * @param <T7> the component type of the 7th Option
+     * @param <T8> the component type of the 8th Option
+     */
+    public static class ForLazy8Option<T1, T2, T3, T4, T5, T6, T7, T8> {
+
+        private final Option<T1> ts1;
+        private final Function1<T1, Option<T2>> ts2;
+        private final Function2<T1, T2, Option<T3>> ts3;
+        private final Function3<T1, T2, T3, Option<T4>> ts4;
+        private final Function4<T1, T2, T3, T4, Option<T5>> ts5;
+        private final Function5<T1, T2, T3, T4, T5, Option<T6>> ts6;
+        private final Function6<T1, T2, T3, T4, T5, T6, Option<T7>> ts7;
+        private final Function7<T1, T2, T3, T4, T5, T6, T7, Option<T8>> ts8;
+
+        private ForLazy8Option(Option<T1> ts1, Function1<T1, Option<T2>> ts2, Function2<T1, T2, Option<T3>> ts3, Function3<T1, T2, T3, Option<T4>> ts4, Function4<T1, T2, T3, T4, Option<T5>> ts5, Function5<T1, T2, T3, T4, T5, Option<T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, Option<T7>> ts7, Function7<T1, T2, T3, T4, T5, T6, T7, Option<T8>> ts8) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+            this.ts3 = ts3;
+            this.ts4 = ts4;
+            this.ts5 = ts5;
+            this.ts6 = ts6;
+            this.ts7 = ts7;
+            this.ts8 = ts8;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Options by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code Option}
+         * @return an {@code Option} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> Option<R> yield(Function8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).flatMap(t2 -> {
+              return ts3.apply(t1, t2).flatMap(t3 -> {
+                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                  return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
+                    return ts6.apply(t1, t2, t3, t4, t5).flatMap(t6 -> {
+                      return ts7.apply(t1, t2, t3, t4, t5, t6).flatMap(t7 -> {
+                        return ts8.apply(t1, t2, t3, t4, t5, t6, t7).map(t8 -> f.apply(t1, t2, t3, t4, t5, t6, t7, t8));
+                      });
+                    });
+                  });
+                });
+              });
+            });
+          });
+        }
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with two Futures.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Futures are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+
+     * @param <T1> the component type of the 1st Future
+     * @param <T2> the component type of the 2nd Future
+     */
+    public static class ForLazy2Future<T1, T2> {
+
+        private final Future<T1> ts1;
+        private final Function1<T1, Future<T2>> ts2;
+
+        private ForLazy2Future(Future<T1> ts1, Function1<T1, Future<T2>> ts2) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Futures by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code Future}
+         * @return an {@code Future} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> Future<R> yield(BiFunction<? super T1, ? super T2, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).map(t2 -> f.apply(t1, t2));
+          });
+        }
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with three Futures.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Futures are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+
+     * @param <T1> the component type of the 1st Future
+     * @param <T2> the component type of the 2nd Future
+     * @param <T3> the component type of the 3rd Future
+     */
+    public static class ForLazy3Future<T1, T2, T3> {
+
+        private final Future<T1> ts1;
+        private final Function1<T1, Future<T2>> ts2;
+        private final Function2<T1, T2, Future<T3>> ts3;
+
+        private ForLazy3Future(Future<T1> ts1, Function1<T1, Future<T2>> ts2, Function2<T1, T2, Future<T3>> ts3) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+            this.ts3 = ts3;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Futures by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code Future}
+         * @return an {@code Future} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> Future<R> yield(Function3<? super T1, ? super T2, ? super T3, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).flatMap(t2 -> {
+              return ts3.apply(t1, t2).map(t3 -> f.apply(t1, t2, t3));
+            });
+          });
+        }
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with 4 Futures.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Futures are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+
+     * @param <T1> the component type of the 1st Future
+     * @param <T2> the component type of the 2nd Future
+     * @param <T3> the component type of the 3rd Future
+     * @param <T4> the component type of the 4th Future
+     */
+    public static class ForLazy4Future<T1, T2, T3, T4> {
+
+        private final Future<T1> ts1;
+        private final Function1<T1, Future<T2>> ts2;
+        private final Function2<T1, T2, Future<T3>> ts3;
+        private final Function3<T1, T2, T3, Future<T4>> ts4;
+
+        private ForLazy4Future(Future<T1> ts1, Function1<T1, Future<T2>> ts2, Function2<T1, T2, Future<T3>> ts3, Function3<T1, T2, T3, Future<T4>> ts4) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+            this.ts3 = ts3;
+            this.ts4 = ts4;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Futures by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code Future}
+         * @return an {@code Future} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> Future<R> yield(Function4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).flatMap(t2 -> {
+              return ts3.apply(t1, t2).flatMap(t3 -> {
+                return ts4.apply(t1, t2, t3).map(t4 -> f.apply(t1, t2, t3, t4));
+              });
+            });
+          });
+        }
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with 5 Futures.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Futures are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+
+     * @param <T1> the component type of the 1st Future
+     * @param <T2> the component type of the 2nd Future
+     * @param <T3> the component type of the 3rd Future
+     * @param <T4> the component type of the 4th Future
+     * @param <T5> the component type of the 5th Future
+     */
+    public static class ForLazy5Future<T1, T2, T3, T4, T5> {
+
+        private final Future<T1> ts1;
+        private final Function1<T1, Future<T2>> ts2;
+        private final Function2<T1, T2, Future<T3>> ts3;
+        private final Function3<T1, T2, T3, Future<T4>> ts4;
+        private final Function4<T1, T2, T3, T4, Future<T5>> ts5;
+
+        private ForLazy5Future(Future<T1> ts1, Function1<T1, Future<T2>> ts2, Function2<T1, T2, Future<T3>> ts3, Function3<T1, T2, T3, Future<T4>> ts4, Function4<T1, T2, T3, T4, Future<T5>> ts5) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+            this.ts3 = ts3;
+            this.ts4 = ts4;
+            this.ts5 = ts5;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Futures by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code Future}
+         * @return an {@code Future} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> Future<R> yield(Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).flatMap(t2 -> {
+              return ts3.apply(t1, t2).flatMap(t3 -> {
+                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                  return ts5.apply(t1, t2, t3, t4).map(t5 -> f.apply(t1, t2, t3, t4, t5));
+                });
+              });
+            });
+          });
+        }
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with 6 Futures.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Futures are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+
+     * @param <T1> the component type of the 1st Future
+     * @param <T2> the component type of the 2nd Future
+     * @param <T3> the component type of the 3rd Future
+     * @param <T4> the component type of the 4th Future
+     * @param <T5> the component type of the 5th Future
+     * @param <T6> the component type of the 6th Future
+     */
+    public static class ForLazy6Future<T1, T2, T3, T4, T5, T6> {
+
+        private final Future<T1> ts1;
+        private final Function1<T1, Future<T2>> ts2;
+        private final Function2<T1, T2, Future<T3>> ts3;
+        private final Function3<T1, T2, T3, Future<T4>> ts4;
+        private final Function4<T1, T2, T3, T4, Future<T5>> ts5;
+        private final Function5<T1, T2, T3, T4, T5, Future<T6>> ts6;
+
+        private ForLazy6Future(Future<T1> ts1, Function1<T1, Future<T2>> ts2, Function2<T1, T2, Future<T3>> ts3, Function3<T1, T2, T3, Future<T4>> ts4, Function4<T1, T2, T3, T4, Future<T5>> ts5, Function5<T1, T2, T3, T4, T5, Future<T6>> ts6) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+            this.ts3 = ts3;
+            this.ts4 = ts4;
+            this.ts5 = ts5;
+            this.ts6 = ts6;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Futures by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code Future}
+         * @return an {@code Future} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> Future<R> yield(Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).flatMap(t2 -> {
+              return ts3.apply(t1, t2).flatMap(t3 -> {
+                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                  return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
+                    return ts6.apply(t1, t2, t3, t4, t5).map(t6 -> f.apply(t1, t2, t3, t4, t5, t6));
+                  });
+                });
+              });
+            });
+          });
+        }
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with 7 Futures.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Futures are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+
+     * @param <T1> the component type of the 1st Future
+     * @param <T2> the component type of the 2nd Future
+     * @param <T3> the component type of the 3rd Future
+     * @param <T4> the component type of the 4th Future
+     * @param <T5> the component type of the 5th Future
+     * @param <T6> the component type of the 6th Future
+     * @param <T7> the component type of the 7th Future
+     */
+    public static class ForLazy7Future<T1, T2, T3, T4, T5, T6, T7> {
+
+        private final Future<T1> ts1;
+        private final Function1<T1, Future<T2>> ts2;
+        private final Function2<T1, T2, Future<T3>> ts3;
+        private final Function3<T1, T2, T3, Future<T4>> ts4;
+        private final Function4<T1, T2, T3, T4, Future<T5>> ts5;
+        private final Function5<T1, T2, T3, T4, T5, Future<T6>> ts6;
+        private final Function6<T1, T2, T3, T4, T5, T6, Future<T7>> ts7;
+
+        private ForLazy7Future(Future<T1> ts1, Function1<T1, Future<T2>> ts2, Function2<T1, T2, Future<T3>> ts3, Function3<T1, T2, T3, Future<T4>> ts4, Function4<T1, T2, T3, T4, Future<T5>> ts5, Function5<T1, T2, T3, T4, T5, Future<T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, Future<T7>> ts7) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+            this.ts3 = ts3;
+            this.ts4 = ts4;
+            this.ts5 = ts5;
+            this.ts6 = ts6;
+            this.ts7 = ts7;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Futures by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code Future}
+         * @return an {@code Future} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> Future<R> yield(Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).flatMap(t2 -> {
+              return ts3.apply(t1, t2).flatMap(t3 -> {
+                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                  return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
+                    return ts6.apply(t1, t2, t3, t4, t5).flatMap(t6 -> {
+                      return ts7.apply(t1, t2, t3, t4, t5, t6).map(t7 -> f.apply(t1, t2, t3, t4, t5, t6, t7));
+                    });
+                  });
+                });
+              });
+            });
+          });
+        }
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with 8 Futures.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Futures are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+
+     * @param <T1> the component type of the 1st Future
+     * @param <T2> the component type of the 2nd Future
+     * @param <T3> the component type of the 3rd Future
+     * @param <T4> the component type of the 4th Future
+     * @param <T5> the component type of the 5th Future
+     * @param <T6> the component type of the 6th Future
+     * @param <T7> the component type of the 7th Future
+     * @param <T8> the component type of the 8th Future
+     */
+    public static class ForLazy8Future<T1, T2, T3, T4, T5, T6, T7, T8> {
+
+        private final Future<T1> ts1;
+        private final Function1<T1, Future<T2>> ts2;
+        private final Function2<T1, T2, Future<T3>> ts3;
+        private final Function3<T1, T2, T3, Future<T4>> ts4;
+        private final Function4<T1, T2, T3, T4, Future<T5>> ts5;
+        private final Function5<T1, T2, T3, T4, T5, Future<T6>> ts6;
+        private final Function6<T1, T2, T3, T4, T5, T6, Future<T7>> ts7;
+        private final Function7<T1, T2, T3, T4, T5, T6, T7, Future<T8>> ts8;
+
+        private ForLazy8Future(Future<T1> ts1, Function1<T1, Future<T2>> ts2, Function2<T1, T2, Future<T3>> ts3, Function3<T1, T2, T3, Future<T4>> ts4, Function4<T1, T2, T3, T4, Future<T5>> ts5, Function5<T1, T2, T3, T4, T5, Future<T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, Future<T7>> ts7, Function7<T1, T2, T3, T4, T5, T6, T7, Future<T8>> ts8) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+            this.ts3 = ts3;
+            this.ts4 = ts4;
+            this.ts5 = ts5;
+            this.ts6 = ts6;
+            this.ts7 = ts7;
+            this.ts8 = ts8;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Futures by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code Future}
+         * @return an {@code Future} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> Future<R> yield(Function8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).flatMap(t2 -> {
+              return ts3.apply(t1, t2).flatMap(t3 -> {
+                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                  return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
+                    return ts6.apply(t1, t2, t3, t4, t5).flatMap(t6 -> {
+                      return ts7.apply(t1, t2, t3, t4, t5, t6).flatMap(t7 -> {
+                        return ts8.apply(t1, t2, t3, t4, t5, t6, t7).map(t8 -> f.apply(t1, t2, t3, t4, t5, t6, t7, t8));
+                      });
+                    });
+                  });
+                });
+              });
+            });
+          });
+        }
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with two Trys.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Trys are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+
+     * @param <T1> the component type of the 1st Try
+     * @param <T2> the component type of the 2nd Try
+     */
+    public static class ForLazy2Try<T1, T2> {
+
+        private final Try<T1> ts1;
+        private final Function1<T1, Try<T2>> ts2;
+
+        private ForLazy2Try(Try<T1> ts1, Function1<T1, Try<T2>> ts2) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Trys by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code Try}
+         * @return an {@code Try} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> Try<R> yield(BiFunction<? super T1, ? super T2, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).map(t2 -> f.apply(t1, t2));
+          });
+        }
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with three Trys.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Trys are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+
+     * @param <T1> the component type of the 1st Try
+     * @param <T2> the component type of the 2nd Try
+     * @param <T3> the component type of the 3rd Try
+     */
+    public static class ForLazy3Try<T1, T2, T3> {
+
+        private final Try<T1> ts1;
+        private final Function1<T1, Try<T2>> ts2;
+        private final Function2<T1, T2, Try<T3>> ts3;
+
+        private ForLazy3Try(Try<T1> ts1, Function1<T1, Try<T2>> ts2, Function2<T1, T2, Try<T3>> ts3) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+            this.ts3 = ts3;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Trys by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code Try}
+         * @return an {@code Try} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> Try<R> yield(Function3<? super T1, ? super T2, ? super T3, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).flatMap(t2 -> {
+              return ts3.apply(t1, t2).map(t3 -> f.apply(t1, t2, t3));
+            });
+          });
+        }
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with 4 Trys.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Trys are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+
+     * @param <T1> the component type of the 1st Try
+     * @param <T2> the component type of the 2nd Try
+     * @param <T3> the component type of the 3rd Try
+     * @param <T4> the component type of the 4th Try
+     */
+    public static class ForLazy4Try<T1, T2, T3, T4> {
+
+        private final Try<T1> ts1;
+        private final Function1<T1, Try<T2>> ts2;
+        private final Function2<T1, T2, Try<T3>> ts3;
+        private final Function3<T1, T2, T3, Try<T4>> ts4;
+
+        private ForLazy4Try(Try<T1> ts1, Function1<T1, Try<T2>> ts2, Function2<T1, T2, Try<T3>> ts3, Function3<T1, T2, T3, Try<T4>> ts4) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+            this.ts3 = ts3;
+            this.ts4 = ts4;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Trys by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code Try}
+         * @return an {@code Try} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> Try<R> yield(Function4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).flatMap(t2 -> {
+              return ts3.apply(t1, t2).flatMap(t3 -> {
+                return ts4.apply(t1, t2, t3).map(t4 -> f.apply(t1, t2, t3, t4));
+              });
+            });
+          });
+        }
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with 5 Trys.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Trys are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+
+     * @param <T1> the component type of the 1st Try
+     * @param <T2> the component type of the 2nd Try
+     * @param <T3> the component type of the 3rd Try
+     * @param <T4> the component type of the 4th Try
+     * @param <T5> the component type of the 5th Try
+     */
+    public static class ForLazy5Try<T1, T2, T3, T4, T5> {
+
+        private final Try<T1> ts1;
+        private final Function1<T1, Try<T2>> ts2;
+        private final Function2<T1, T2, Try<T3>> ts3;
+        private final Function3<T1, T2, T3, Try<T4>> ts4;
+        private final Function4<T1, T2, T3, T4, Try<T5>> ts5;
+
+        private ForLazy5Try(Try<T1> ts1, Function1<T1, Try<T2>> ts2, Function2<T1, T2, Try<T3>> ts3, Function3<T1, T2, T3, Try<T4>> ts4, Function4<T1, T2, T3, T4, Try<T5>> ts5) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+            this.ts3 = ts3;
+            this.ts4 = ts4;
+            this.ts5 = ts5;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Trys by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code Try}
+         * @return an {@code Try} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> Try<R> yield(Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).flatMap(t2 -> {
+              return ts3.apply(t1, t2).flatMap(t3 -> {
+                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                  return ts5.apply(t1, t2, t3, t4).map(t5 -> f.apply(t1, t2, t3, t4, t5));
+                });
+              });
+            });
+          });
+        }
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with 6 Trys.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Trys are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+
+     * @param <T1> the component type of the 1st Try
+     * @param <T2> the component type of the 2nd Try
+     * @param <T3> the component type of the 3rd Try
+     * @param <T4> the component type of the 4th Try
+     * @param <T5> the component type of the 5th Try
+     * @param <T6> the component type of the 6th Try
+     */
+    public static class ForLazy6Try<T1, T2, T3, T4, T5, T6> {
+
+        private final Try<T1> ts1;
+        private final Function1<T1, Try<T2>> ts2;
+        private final Function2<T1, T2, Try<T3>> ts3;
+        private final Function3<T1, T2, T3, Try<T4>> ts4;
+        private final Function4<T1, T2, T3, T4, Try<T5>> ts5;
+        private final Function5<T1, T2, T3, T4, T5, Try<T6>> ts6;
+
+        private ForLazy6Try(Try<T1> ts1, Function1<T1, Try<T2>> ts2, Function2<T1, T2, Try<T3>> ts3, Function3<T1, T2, T3, Try<T4>> ts4, Function4<T1, T2, T3, T4, Try<T5>> ts5, Function5<T1, T2, T3, T4, T5, Try<T6>> ts6) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+            this.ts3 = ts3;
+            this.ts4 = ts4;
+            this.ts5 = ts5;
+            this.ts6 = ts6;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Trys by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code Try}
+         * @return an {@code Try} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> Try<R> yield(Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).flatMap(t2 -> {
+              return ts3.apply(t1, t2).flatMap(t3 -> {
+                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                  return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
+                    return ts6.apply(t1, t2, t3, t4, t5).map(t6 -> f.apply(t1, t2, t3, t4, t5, t6));
+                  });
+                });
+              });
+            });
+          });
+        }
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with 7 Trys.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Trys are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+
+     * @param <T1> the component type of the 1st Try
+     * @param <T2> the component type of the 2nd Try
+     * @param <T3> the component type of the 3rd Try
+     * @param <T4> the component type of the 4th Try
+     * @param <T5> the component type of the 5th Try
+     * @param <T6> the component type of the 6th Try
+     * @param <T7> the component type of the 7th Try
+     */
+    public static class ForLazy7Try<T1, T2, T3, T4, T5, T6, T7> {
+
+        private final Try<T1> ts1;
+        private final Function1<T1, Try<T2>> ts2;
+        private final Function2<T1, T2, Try<T3>> ts3;
+        private final Function3<T1, T2, T3, Try<T4>> ts4;
+        private final Function4<T1, T2, T3, T4, Try<T5>> ts5;
+        private final Function5<T1, T2, T3, T4, T5, Try<T6>> ts6;
+        private final Function6<T1, T2, T3, T4, T5, T6, Try<T7>> ts7;
+
+        private ForLazy7Try(Try<T1> ts1, Function1<T1, Try<T2>> ts2, Function2<T1, T2, Try<T3>> ts3, Function3<T1, T2, T3, Try<T4>> ts4, Function4<T1, T2, T3, T4, Try<T5>> ts5, Function5<T1, T2, T3, T4, T5, Try<T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, Try<T7>> ts7) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+            this.ts3 = ts3;
+            this.ts4 = ts4;
+            this.ts5 = ts5;
+            this.ts6 = ts6;
+            this.ts7 = ts7;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Trys by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code Try}
+         * @return an {@code Try} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> Try<R> yield(Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).flatMap(t2 -> {
+              return ts3.apply(t1, t2).flatMap(t3 -> {
+                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                  return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
+                    return ts6.apply(t1, t2, t3, t4, t5).flatMap(t6 -> {
+                      return ts7.apply(t1, t2, t3, t4, t5, t6).map(t7 -> f.apply(t1, t2, t3, t4, t5, t6, t7));
+                    });
+                  });
+                });
+              });
+            });
+          });
+        }
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with 8 Trys.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Trys are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+
+     * @param <T1> the component type of the 1st Try
+     * @param <T2> the component type of the 2nd Try
+     * @param <T3> the component type of the 3rd Try
+     * @param <T4> the component type of the 4th Try
+     * @param <T5> the component type of the 5th Try
+     * @param <T6> the component type of the 6th Try
+     * @param <T7> the component type of the 7th Try
+     * @param <T8> the component type of the 8th Try
+     */
+    public static class ForLazy8Try<T1, T2, T3, T4, T5, T6, T7, T8> {
+
+        private final Try<T1> ts1;
+        private final Function1<T1, Try<T2>> ts2;
+        private final Function2<T1, T2, Try<T3>> ts3;
+        private final Function3<T1, T2, T3, Try<T4>> ts4;
+        private final Function4<T1, T2, T3, T4, Try<T5>> ts5;
+        private final Function5<T1, T2, T3, T4, T5, Try<T6>> ts6;
+        private final Function6<T1, T2, T3, T4, T5, T6, Try<T7>> ts7;
+        private final Function7<T1, T2, T3, T4, T5, T6, T7, Try<T8>> ts8;
+
+        private ForLazy8Try(Try<T1> ts1, Function1<T1, Try<T2>> ts2, Function2<T1, T2, Try<T3>> ts3, Function3<T1, T2, T3, Try<T4>> ts4, Function4<T1, T2, T3, T4, Try<T5>> ts5, Function5<T1, T2, T3, T4, T5, Try<T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, Try<T7>> ts7, Function7<T1, T2, T3, T4, T5, T6, T7, Try<T8>> ts8) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+            this.ts3 = ts3;
+            this.ts4 = ts4;
+            this.ts5 = ts5;
+            this.ts6 = ts6;
+            this.ts7 = ts7;
+            this.ts8 = ts8;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Trys by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code Try}
+         * @return an {@code Try} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> Try<R> yield(Function8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).flatMap(t2 -> {
+              return ts3.apply(t1, t2).flatMap(t3 -> {
+                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                  return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
+                    return ts6.apply(t1, t2, t3, t4, t5).flatMap(t6 -> {
+                      return ts7.apply(t1, t2, t3, t4, t5, t6).flatMap(t7 -> {
+                        return ts8.apply(t1, t2, t3, t4, t5, t6, t7).map(t8 -> f.apply(t1, t2, t3, t4, t5, t6, t7, t8));
+                      });
+                    });
+                  });
+                });
+              });
+            });
+          });
+        }
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with two Lists.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Lists are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+
+     * @param <T1> the component type of the 1st List
+     * @param <T2> the component type of the 2nd List
+     */
+    public static class ForLazy2List<T1, T2> {
+
+        private final List<T1> ts1;
+        private final Function1<T1, List<T2>> ts2;
+
+        private ForLazy2List(List<T1> ts1, Function1<T1, List<T2>> ts2) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Lists by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code List}
+         * @return an {@code List} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> List<R> yield(BiFunction<? super T1, ? super T2, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).map(t2 -> f.apply(t1, t2));
+          });
+        }
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with three Lists.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Lists are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+
+     * @param <T1> the component type of the 1st List
+     * @param <T2> the component type of the 2nd List
+     * @param <T3> the component type of the 3rd List
+     */
+    public static class ForLazy3List<T1, T2, T3> {
+
+        private final List<T1> ts1;
+        private final Function1<T1, List<T2>> ts2;
+        private final Function2<T1, T2, List<T3>> ts3;
+
+        private ForLazy3List(List<T1> ts1, Function1<T1, List<T2>> ts2, Function2<T1, T2, List<T3>> ts3) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+            this.ts3 = ts3;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Lists by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code List}
+         * @return an {@code List} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> List<R> yield(Function3<? super T1, ? super T2, ? super T3, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).flatMap(t2 -> {
+              return ts3.apply(t1, t2).map(t3 -> f.apply(t1, t2, t3));
+            });
+          });
+        }
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with 4 Lists.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Lists are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+
+     * @param <T1> the component type of the 1st List
+     * @param <T2> the component type of the 2nd List
+     * @param <T3> the component type of the 3rd List
+     * @param <T4> the component type of the 4th List
+     */
+    public static class ForLazy4List<T1, T2, T3, T4> {
+
+        private final List<T1> ts1;
+        private final Function1<T1, List<T2>> ts2;
+        private final Function2<T1, T2, List<T3>> ts3;
+        private final Function3<T1, T2, T3, List<T4>> ts4;
+
+        private ForLazy4List(List<T1> ts1, Function1<T1, List<T2>> ts2, Function2<T1, T2, List<T3>> ts3, Function3<T1, T2, T3, List<T4>> ts4) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+            this.ts3 = ts3;
+            this.ts4 = ts4;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Lists by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code List}
+         * @return an {@code List} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> List<R> yield(Function4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).flatMap(t2 -> {
+              return ts3.apply(t1, t2).flatMap(t3 -> {
+                return ts4.apply(t1, t2, t3).map(t4 -> f.apply(t1, t2, t3, t4));
+              });
+            });
+          });
+        }
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with 5 Lists.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Lists are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+
+     * @param <T1> the component type of the 1st List
+     * @param <T2> the component type of the 2nd List
+     * @param <T3> the component type of the 3rd List
+     * @param <T4> the component type of the 4th List
+     * @param <T5> the component type of the 5th List
+     */
+    public static class ForLazy5List<T1, T2, T3, T4, T5> {
+
+        private final List<T1> ts1;
+        private final Function1<T1, List<T2>> ts2;
+        private final Function2<T1, T2, List<T3>> ts3;
+        private final Function3<T1, T2, T3, List<T4>> ts4;
+        private final Function4<T1, T2, T3, T4, List<T5>> ts5;
+
+        private ForLazy5List(List<T1> ts1, Function1<T1, List<T2>> ts2, Function2<T1, T2, List<T3>> ts3, Function3<T1, T2, T3, List<T4>> ts4, Function4<T1, T2, T3, T4, List<T5>> ts5) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+            this.ts3 = ts3;
+            this.ts4 = ts4;
+            this.ts5 = ts5;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Lists by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code List}
+         * @return an {@code List} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> List<R> yield(Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).flatMap(t2 -> {
+              return ts3.apply(t1, t2).flatMap(t3 -> {
+                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                  return ts5.apply(t1, t2, t3, t4).map(t5 -> f.apply(t1, t2, t3, t4, t5));
+                });
+              });
+            });
+          });
+        }
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with 6 Lists.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Lists are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+
+     * @param <T1> the component type of the 1st List
+     * @param <T2> the component type of the 2nd List
+     * @param <T3> the component type of the 3rd List
+     * @param <T4> the component type of the 4th List
+     * @param <T5> the component type of the 5th List
+     * @param <T6> the component type of the 6th List
+     */
+    public static class ForLazy6List<T1, T2, T3, T4, T5, T6> {
+
+        private final List<T1> ts1;
+        private final Function1<T1, List<T2>> ts2;
+        private final Function2<T1, T2, List<T3>> ts3;
+        private final Function3<T1, T2, T3, List<T4>> ts4;
+        private final Function4<T1, T2, T3, T4, List<T5>> ts5;
+        private final Function5<T1, T2, T3, T4, T5, List<T6>> ts6;
+
+        private ForLazy6List(List<T1> ts1, Function1<T1, List<T2>> ts2, Function2<T1, T2, List<T3>> ts3, Function3<T1, T2, T3, List<T4>> ts4, Function4<T1, T2, T3, T4, List<T5>> ts5, Function5<T1, T2, T3, T4, T5, List<T6>> ts6) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+            this.ts3 = ts3;
+            this.ts4 = ts4;
+            this.ts5 = ts5;
+            this.ts6 = ts6;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Lists by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code List}
+         * @return an {@code List} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> List<R> yield(Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).flatMap(t2 -> {
+              return ts3.apply(t1, t2).flatMap(t3 -> {
+                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                  return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
+                    return ts6.apply(t1, t2, t3, t4, t5).map(t6 -> f.apply(t1, t2, t3, t4, t5, t6));
+                  });
+                });
+              });
+            });
+          });
+        }
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with 7 Lists.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Lists are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+
+     * @param <T1> the component type of the 1st List
+     * @param <T2> the component type of the 2nd List
+     * @param <T3> the component type of the 3rd List
+     * @param <T4> the component type of the 4th List
+     * @param <T5> the component type of the 5th List
+     * @param <T6> the component type of the 6th List
+     * @param <T7> the component type of the 7th List
+     */
+    public static class ForLazy7List<T1, T2, T3, T4, T5, T6, T7> {
+
+        private final List<T1> ts1;
+        private final Function1<T1, List<T2>> ts2;
+        private final Function2<T1, T2, List<T3>> ts3;
+        private final Function3<T1, T2, T3, List<T4>> ts4;
+        private final Function4<T1, T2, T3, T4, List<T5>> ts5;
+        private final Function5<T1, T2, T3, T4, T5, List<T6>> ts6;
+        private final Function6<T1, T2, T3, T4, T5, T6, List<T7>> ts7;
+
+        private ForLazy7List(List<T1> ts1, Function1<T1, List<T2>> ts2, Function2<T1, T2, List<T3>> ts3, Function3<T1, T2, T3, List<T4>> ts4, Function4<T1, T2, T3, T4, List<T5>> ts5, Function5<T1, T2, T3, T4, T5, List<T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, List<T7>> ts7) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+            this.ts3 = ts3;
+            this.ts4 = ts4;
+            this.ts5 = ts5;
+            this.ts6 = ts6;
+            this.ts7 = ts7;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Lists by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code List}
+         * @return an {@code List} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> List<R> yield(Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).flatMap(t2 -> {
+              return ts3.apply(t1, t2).flatMap(t3 -> {
+                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                  return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
+                    return ts6.apply(t1, t2, t3, t4, t5).flatMap(t6 -> {
+                      return ts7.apply(t1, t2, t3, t4, t5, t6).map(t7 -> f.apply(t1, t2, t3, t4, t5, t6, t7));
+                    });
+                  });
+                });
+              });
+            });
+          });
+        }
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with 8 Lists.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Lists are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+
+     * @param <T1> the component type of the 1st List
+     * @param <T2> the component type of the 2nd List
+     * @param <T3> the component type of the 3rd List
+     * @param <T4> the component type of the 4th List
+     * @param <T5> the component type of the 5th List
+     * @param <T6> the component type of the 6th List
+     * @param <T7> the component type of the 7th List
+     * @param <T8> the component type of the 8th List
+     */
+    public static class ForLazy8List<T1, T2, T3, T4, T5, T6, T7, T8> {
+
+        private final List<T1> ts1;
+        private final Function1<T1, List<T2>> ts2;
+        private final Function2<T1, T2, List<T3>> ts3;
+        private final Function3<T1, T2, T3, List<T4>> ts4;
+        private final Function4<T1, T2, T3, T4, List<T5>> ts5;
+        private final Function5<T1, T2, T3, T4, T5, List<T6>> ts6;
+        private final Function6<T1, T2, T3, T4, T5, T6, List<T7>> ts7;
+        private final Function7<T1, T2, T3, T4, T5, T6, T7, List<T8>> ts8;
+
+        private ForLazy8List(List<T1> ts1, Function1<T1, List<T2>> ts2, Function2<T1, T2, List<T3>> ts3, Function3<T1, T2, T3, List<T4>> ts4, Function4<T1, T2, T3, T4, List<T5>> ts5, Function5<T1, T2, T3, T4, T5, List<T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, List<T7>> ts7, Function7<T1, T2, T3, T4, T5, T6, T7, List<T8>> ts8) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+            this.ts3 = ts3;
+            this.ts4 = ts4;
+            this.ts5 = ts5;
+            this.ts6 = ts6;
+            this.ts7 = ts7;
+            this.ts8 = ts8;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Lists by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code List}
+         * @return an {@code List} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> List<R> yield(Function8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).flatMap(t2 -> {
+              return ts3.apply(t1, t2).flatMap(t3 -> {
+                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                  return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
+                    return ts6.apply(t1, t2, t3, t4, t5).flatMap(t6 -> {
+                      return ts7.apply(t1, t2, t3, t4, t5, t6).flatMap(t7 -> {
+                        return ts8.apply(t1, t2, t3, t4, t5, t6, t7).map(t8 -> f.apply(t1, t2, t3, t4, t5, t6, t7, t8));
+                      });
+                    });
+                  });
+                });
+              });
+            });
+          });
+        }
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with two Eithers.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Eithers are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+     * @param <L> the common left-hand type of all Eithers
+     * @param <T1> the component type of the 1st Either
+     * @param <T2> the component type of the 2nd Either
+     */
+    public static class ForLazy2Either<L, T1, T2> {
+
+        private final Either<L, T1> ts1;
+        private final Function1<T1, Either<L, T2>> ts2;
+
+        private ForLazy2Either(Either<L, T1> ts1, Function1<T1, Either<L, T2>> ts2) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Eithers by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code Either}
+         * @return an {@code Either} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> Either<L, R> yield(BiFunction<? super T1, ? super T2, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).map(t2 -> f.apply(t1, t2));
+          });
+        }
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with three Eithers.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Eithers are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+     * @param <L> the common left-hand type of all Eithers
+     * @param <T1> the component type of the 1st Either
+     * @param <T2> the component type of the 2nd Either
+     * @param <T3> the component type of the 3rd Either
+     */
+    public static class ForLazy3Either<L, T1, T2, T3> {
+
+        private final Either<L, T1> ts1;
+        private final Function1<T1, Either<L, T2>> ts2;
+        private final Function2<T1, T2, Either<L, T3>> ts3;
+
+        private ForLazy3Either(Either<L, T1> ts1, Function1<T1, Either<L, T2>> ts2, Function2<T1, T2, Either<L, T3>> ts3) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+            this.ts3 = ts3;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Eithers by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code Either}
+         * @return an {@code Either} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> Either<L, R> yield(Function3<? super T1, ? super T2, ? super T3, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).flatMap(t2 -> {
+              return ts3.apply(t1, t2).map(t3 -> f.apply(t1, t2, t3));
+            });
+          });
+        }
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with 4 Eithers.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Eithers are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+     * @param <L> the common left-hand type of all Eithers
+     * @param <T1> the component type of the 1st Either
+     * @param <T2> the component type of the 2nd Either
+     * @param <T3> the component type of the 3rd Either
+     * @param <T4> the component type of the 4th Either
+     */
+    public static class ForLazy4Either<L, T1, T2, T3, T4> {
+
+        private final Either<L, T1> ts1;
+        private final Function1<T1, Either<L, T2>> ts2;
+        private final Function2<T1, T2, Either<L, T3>> ts3;
+        private final Function3<T1, T2, T3, Either<L, T4>> ts4;
+
+        private ForLazy4Either(Either<L, T1> ts1, Function1<T1, Either<L, T2>> ts2, Function2<T1, T2, Either<L, T3>> ts3, Function3<T1, T2, T3, Either<L, T4>> ts4) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+            this.ts3 = ts3;
+            this.ts4 = ts4;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Eithers by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code Either}
+         * @return an {@code Either} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> Either<L, R> yield(Function4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).flatMap(t2 -> {
+              return ts3.apply(t1, t2).flatMap(t3 -> {
+                return ts4.apply(t1, t2, t3).map(t4 -> f.apply(t1, t2, t3, t4));
+              });
+            });
+          });
+        }
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with 5 Eithers.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Eithers are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+     * @param <L> the common left-hand type of all Eithers
+     * @param <T1> the component type of the 1st Either
+     * @param <T2> the component type of the 2nd Either
+     * @param <T3> the component type of the 3rd Either
+     * @param <T4> the component type of the 4th Either
+     * @param <T5> the component type of the 5th Either
+     */
+    public static class ForLazy5Either<L, T1, T2, T3, T4, T5> {
+
+        private final Either<L, T1> ts1;
+        private final Function1<T1, Either<L, T2>> ts2;
+        private final Function2<T1, T2, Either<L, T3>> ts3;
+        private final Function3<T1, T2, T3, Either<L, T4>> ts4;
+        private final Function4<T1, T2, T3, T4, Either<L, T5>> ts5;
+
+        private ForLazy5Either(Either<L, T1> ts1, Function1<T1, Either<L, T2>> ts2, Function2<T1, T2, Either<L, T3>> ts3, Function3<T1, T2, T3, Either<L, T4>> ts4, Function4<T1, T2, T3, T4, Either<L, T5>> ts5) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+            this.ts3 = ts3;
+            this.ts4 = ts4;
+            this.ts5 = ts5;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Eithers by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code Either}
+         * @return an {@code Either} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> Either<L, R> yield(Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).flatMap(t2 -> {
+              return ts3.apply(t1, t2).flatMap(t3 -> {
+                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                  return ts5.apply(t1, t2, t3, t4).map(t5 -> f.apply(t1, t2, t3, t4, t5));
+                });
+              });
+            });
+          });
+        }
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with 6 Eithers.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Eithers are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+     * @param <L> the common left-hand type of all Eithers
+     * @param <T1> the component type of the 1st Either
+     * @param <T2> the component type of the 2nd Either
+     * @param <T3> the component type of the 3rd Either
+     * @param <T4> the component type of the 4th Either
+     * @param <T5> the component type of the 5th Either
+     * @param <T6> the component type of the 6th Either
+     */
+    public static class ForLazy6Either<L, T1, T2, T3, T4, T5, T6> {
+
+        private final Either<L, T1> ts1;
+        private final Function1<T1, Either<L, T2>> ts2;
+        private final Function2<T1, T2, Either<L, T3>> ts3;
+        private final Function3<T1, T2, T3, Either<L, T4>> ts4;
+        private final Function4<T1, T2, T3, T4, Either<L, T5>> ts5;
+        private final Function5<T1, T2, T3, T4, T5, Either<L, T6>> ts6;
+
+        private ForLazy6Either(Either<L, T1> ts1, Function1<T1, Either<L, T2>> ts2, Function2<T1, T2, Either<L, T3>> ts3, Function3<T1, T2, T3, Either<L, T4>> ts4, Function4<T1, T2, T3, T4, Either<L, T5>> ts5, Function5<T1, T2, T3, T4, T5, Either<L, T6>> ts6) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+            this.ts3 = ts3;
+            this.ts4 = ts4;
+            this.ts5 = ts5;
+            this.ts6 = ts6;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Eithers by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code Either}
+         * @return an {@code Either} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> Either<L, R> yield(Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).flatMap(t2 -> {
+              return ts3.apply(t1, t2).flatMap(t3 -> {
+                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                  return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
+                    return ts6.apply(t1, t2, t3, t4, t5).map(t6 -> f.apply(t1, t2, t3, t4, t5, t6));
+                  });
+                });
+              });
+            });
+          });
+        }
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with 7 Eithers.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Eithers are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+     * @param <L> the common left-hand type of all Eithers
+     * @param <T1> the component type of the 1st Either
+     * @param <T2> the component type of the 2nd Either
+     * @param <T3> the component type of the 3rd Either
+     * @param <T4> the component type of the 4th Either
+     * @param <T5> the component type of the 5th Either
+     * @param <T6> the component type of the 6th Either
+     * @param <T7> the component type of the 7th Either
+     */
+    public static class ForLazy7Either<L, T1, T2, T3, T4, T5, T6, T7> {
+
+        private final Either<L, T1> ts1;
+        private final Function1<T1, Either<L, T2>> ts2;
+        private final Function2<T1, T2, Either<L, T3>> ts3;
+        private final Function3<T1, T2, T3, Either<L, T4>> ts4;
+        private final Function4<T1, T2, T3, T4, Either<L, T5>> ts5;
+        private final Function5<T1, T2, T3, T4, T5, Either<L, T6>> ts6;
+        private final Function6<T1, T2, T3, T4, T5, T6, Either<L, T7>> ts7;
+
+        private ForLazy7Either(Either<L, T1> ts1, Function1<T1, Either<L, T2>> ts2, Function2<T1, T2, Either<L, T3>> ts3, Function3<T1, T2, T3, Either<L, T4>> ts4, Function4<T1, T2, T3, T4, Either<L, T5>> ts5, Function5<T1, T2, T3, T4, T5, Either<L, T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, Either<L, T7>> ts7) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+            this.ts3 = ts3;
+            this.ts4 = ts4;
+            this.ts5 = ts5;
+            this.ts6 = ts6;
+            this.ts7 = ts7;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Eithers by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code Either}
+         * @return an {@code Either} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> Either<L, R> yield(Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).flatMap(t2 -> {
+              return ts3.apply(t1, t2).flatMap(t3 -> {
+                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                  return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
+                    return ts6.apply(t1, t2, t3, t4, t5).flatMap(t6 -> {
+                      return ts7.apply(t1, t2, t3, t4, t5, t6).map(t7 -> f.apply(t1, t2, t3, t4, t5, t6, t7));
+                    });
+                  });
+                });
+              });
+            });
+          });
+        }
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with 8 Eithers.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Eithers are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+     * @param <L> the common left-hand type of all Eithers
+     * @param <T1> the component type of the 1st Either
+     * @param <T2> the component type of the 2nd Either
+     * @param <T3> the component type of the 3rd Either
+     * @param <T4> the component type of the 4th Either
+     * @param <T5> the component type of the 5th Either
+     * @param <T6> the component type of the 6th Either
+     * @param <T7> the component type of the 7th Either
+     * @param <T8> the component type of the 8th Either
+     */
+    public static class ForLazy8Either<L, T1, T2, T3, T4, T5, T6, T7, T8> {
+
+        private final Either<L, T1> ts1;
+        private final Function1<T1, Either<L, T2>> ts2;
+        private final Function2<T1, T2, Either<L, T3>> ts3;
+        private final Function3<T1, T2, T3, Either<L, T4>> ts4;
+        private final Function4<T1, T2, T3, T4, Either<L, T5>> ts5;
+        private final Function5<T1, T2, T3, T4, T5, Either<L, T6>> ts6;
+        private final Function6<T1, T2, T3, T4, T5, T6, Either<L, T7>> ts7;
+        private final Function7<T1, T2, T3, T4, T5, T6, T7, Either<L, T8>> ts8;
+
+        private ForLazy8Either(Either<L, T1> ts1, Function1<T1, Either<L, T2>> ts2, Function2<T1, T2, Either<L, T3>> ts3, Function3<T1, T2, T3, Either<L, T4>> ts4, Function4<T1, T2, T3, T4, Either<L, T5>> ts5, Function5<T1, T2, T3, T4, T5, Either<L, T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, Either<L, T7>> ts7, Function7<T1, T2, T3, T4, T5, T6, T7, Either<L, T8>> ts8) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+            this.ts3 = ts3;
+            this.ts4 = ts4;
+            this.ts5 = ts5;
+            this.ts6 = ts6;
+            this.ts7 = ts7;
+            this.ts8 = ts8;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Eithers by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code Either}
+         * @return an {@code Either} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> Either<L, R> yield(Function8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).flatMap(t2 -> {
+              return ts3.apply(t1, t2).flatMap(t3 -> {
+                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                  return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
+                    return ts6.apply(t1, t2, t3, t4, t5).flatMap(t6 -> {
+                      return ts7.apply(t1, t2, t3, t4, t5, t6).flatMap(t7 -> {
+                        return ts8.apply(t1, t2, t3, t4, t5, t6, t7).map(t8 -> f.apply(t1, t2, t3, t4, t5, t6, t7, t8));
+                      });
+                    });
+                  });
+                });
+              });
+            });
+          });
+        }
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with two Validations.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Validations are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+     * @param <L> the common left-hand type of all Validations
+     * @param <T1> the component type of the 1st Validation
+     * @param <T2> the component type of the 2nd Validation
+     */
+    public static class ForLazy2Validation<L, T1, T2> {
+
+        private final Validation<L, T1> ts1;
+        private final Function1<T1, Validation<L, T2>> ts2;
+
+        private ForLazy2Validation(Validation<L, T1> ts1, Function1<T1, Validation<L, T2>> ts2) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Validations by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code Validation}
+         * @return an {@code Validation} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> Validation<L, R> yield(BiFunction<? super T1, ? super T2, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).map(t2 -> f.apply(t1, t2));
+          });
+        }
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with three Validations.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Validations are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+     * @param <L> the common left-hand type of all Validations
+     * @param <T1> the component type of the 1st Validation
+     * @param <T2> the component type of the 2nd Validation
+     * @param <T3> the component type of the 3rd Validation
+     */
+    public static class ForLazy3Validation<L, T1, T2, T3> {
+
+        private final Validation<L, T1> ts1;
+        private final Function1<T1, Validation<L, T2>> ts2;
+        private final Function2<T1, T2, Validation<L, T3>> ts3;
+
+        private ForLazy3Validation(Validation<L, T1> ts1, Function1<T1, Validation<L, T2>> ts2, Function2<T1, T2, Validation<L, T3>> ts3) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+            this.ts3 = ts3;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Validations by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code Validation}
+         * @return an {@code Validation} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> Validation<L, R> yield(Function3<? super T1, ? super T2, ? super T3, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).flatMap(t2 -> {
+              return ts3.apply(t1, t2).map(t3 -> f.apply(t1, t2, t3));
+            });
+          });
+        }
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with 4 Validations.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Validations are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+     * @param <L> the common left-hand type of all Validations
+     * @param <T1> the component type of the 1st Validation
+     * @param <T2> the component type of the 2nd Validation
+     * @param <T3> the component type of the 3rd Validation
+     * @param <T4> the component type of the 4th Validation
+     */
+    public static class ForLazy4Validation<L, T1, T2, T3, T4> {
+
+        private final Validation<L, T1> ts1;
+        private final Function1<T1, Validation<L, T2>> ts2;
+        private final Function2<T1, T2, Validation<L, T3>> ts3;
+        private final Function3<T1, T2, T3, Validation<L, T4>> ts4;
+
+        private ForLazy4Validation(Validation<L, T1> ts1, Function1<T1, Validation<L, T2>> ts2, Function2<T1, T2, Validation<L, T3>> ts3, Function3<T1, T2, T3, Validation<L, T4>> ts4) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+            this.ts3 = ts3;
+            this.ts4 = ts4;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Validations by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code Validation}
+         * @return an {@code Validation} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> Validation<L, R> yield(Function4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).flatMap(t2 -> {
+              return ts3.apply(t1, t2).flatMap(t3 -> {
+                return ts4.apply(t1, t2, t3).map(t4 -> f.apply(t1, t2, t3, t4));
+              });
+            });
+          });
+        }
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with 5 Validations.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Validations are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+     * @param <L> the common left-hand type of all Validations
+     * @param <T1> the component type of the 1st Validation
+     * @param <T2> the component type of the 2nd Validation
+     * @param <T3> the component type of the 3rd Validation
+     * @param <T4> the component type of the 4th Validation
+     * @param <T5> the component type of the 5th Validation
+     */
+    public static class ForLazy5Validation<L, T1, T2, T3, T4, T5> {
+
+        private final Validation<L, T1> ts1;
+        private final Function1<T1, Validation<L, T2>> ts2;
+        private final Function2<T1, T2, Validation<L, T3>> ts3;
+        private final Function3<T1, T2, T3, Validation<L, T4>> ts4;
+        private final Function4<T1, T2, T3, T4, Validation<L, T5>> ts5;
+
+        private ForLazy5Validation(Validation<L, T1> ts1, Function1<T1, Validation<L, T2>> ts2, Function2<T1, T2, Validation<L, T3>> ts3, Function3<T1, T2, T3, Validation<L, T4>> ts4, Function4<T1, T2, T3, T4, Validation<L, T5>> ts5) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+            this.ts3 = ts3;
+            this.ts4 = ts4;
+            this.ts5 = ts5;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Validations by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code Validation}
+         * @return an {@code Validation} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> Validation<L, R> yield(Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).flatMap(t2 -> {
+              return ts3.apply(t1, t2).flatMap(t3 -> {
+                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                  return ts5.apply(t1, t2, t3, t4).map(t5 -> f.apply(t1, t2, t3, t4, t5));
+                });
+              });
+            });
+          });
+        }
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with 6 Validations.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Validations are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+     * @param <L> the common left-hand type of all Validations
+     * @param <T1> the component type of the 1st Validation
+     * @param <T2> the component type of the 2nd Validation
+     * @param <T3> the component type of the 3rd Validation
+     * @param <T4> the component type of the 4th Validation
+     * @param <T5> the component type of the 5th Validation
+     * @param <T6> the component type of the 6th Validation
+     */
+    public static class ForLazy6Validation<L, T1, T2, T3, T4, T5, T6> {
+
+        private final Validation<L, T1> ts1;
+        private final Function1<T1, Validation<L, T2>> ts2;
+        private final Function2<T1, T2, Validation<L, T3>> ts3;
+        private final Function3<T1, T2, T3, Validation<L, T4>> ts4;
+        private final Function4<T1, T2, T3, T4, Validation<L, T5>> ts5;
+        private final Function5<T1, T2, T3, T4, T5, Validation<L, T6>> ts6;
+
+        private ForLazy6Validation(Validation<L, T1> ts1, Function1<T1, Validation<L, T2>> ts2, Function2<T1, T2, Validation<L, T3>> ts3, Function3<T1, T2, T3, Validation<L, T4>> ts4, Function4<T1, T2, T3, T4, Validation<L, T5>> ts5, Function5<T1, T2, T3, T4, T5, Validation<L, T6>> ts6) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+            this.ts3 = ts3;
+            this.ts4 = ts4;
+            this.ts5 = ts5;
+            this.ts6 = ts6;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Validations by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code Validation}
+         * @return an {@code Validation} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> Validation<L, R> yield(Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).flatMap(t2 -> {
+              return ts3.apply(t1, t2).flatMap(t3 -> {
+                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                  return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
+                    return ts6.apply(t1, t2, t3, t4, t5).map(t6 -> f.apply(t1, t2, t3, t4, t5, t6));
+                  });
+                });
+              });
+            });
+          });
+        }
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with 7 Validations.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Validations are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+     * @param <L> the common left-hand type of all Validations
+     * @param <T1> the component type of the 1st Validation
+     * @param <T2> the component type of the 2nd Validation
+     * @param <T3> the component type of the 3rd Validation
+     * @param <T4> the component type of the 4th Validation
+     * @param <T5> the component type of the 5th Validation
+     * @param <T6> the component type of the 6th Validation
+     * @param <T7> the component type of the 7th Validation
+     */
+    public static class ForLazy7Validation<L, T1, T2, T3, T4, T5, T6, T7> {
+
+        private final Validation<L, T1> ts1;
+        private final Function1<T1, Validation<L, T2>> ts2;
+        private final Function2<T1, T2, Validation<L, T3>> ts3;
+        private final Function3<T1, T2, T3, Validation<L, T4>> ts4;
+        private final Function4<T1, T2, T3, T4, Validation<L, T5>> ts5;
+        private final Function5<T1, T2, T3, T4, T5, Validation<L, T6>> ts6;
+        private final Function6<T1, T2, T3, T4, T5, T6, Validation<L, T7>> ts7;
+
+        private ForLazy7Validation(Validation<L, T1> ts1, Function1<T1, Validation<L, T2>> ts2, Function2<T1, T2, Validation<L, T3>> ts3, Function3<T1, T2, T3, Validation<L, T4>> ts4, Function4<T1, T2, T3, T4, Validation<L, T5>> ts5, Function5<T1, T2, T3, T4, T5, Validation<L, T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, Validation<L, T7>> ts7) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+            this.ts3 = ts3;
+            this.ts4 = ts4;
+            this.ts5 = ts5;
+            this.ts6 = ts6;
+            this.ts7 = ts7;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Validations by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code Validation}
+         * @return an {@code Validation} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> Validation<L, R> yield(Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).flatMap(t2 -> {
+              return ts3.apply(t1, t2).flatMap(t3 -> {
+                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                  return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
+                    return ts6.apply(t1, t2, t3, t4, t5).flatMap(t6 -> {
+                      return ts7.apply(t1, t2, t3, t4, t5, t6).map(t7 -> f.apply(t1, t2, t3, t4, t5, t6, t7));
+                    });
+                  });
+                });
+              });
+            });
+          });
+        }
+    }
+
+    /**
+     * A lazily evaluated {@code For}-comprehension with 8 Validations.
+     *
+     * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
+     * Construction is side-effect free; underlying Validations are only
+     * traversed when {@code yield(...)} is invoked.</p>
+     *
+     * @param <L> the common left-hand type of all Validations
+     * @param <T1> the component type of the 1st Validation
+     * @param <T2> the component type of the 2nd Validation
+     * @param <T3> the component type of the 3rd Validation
+     * @param <T4> the component type of the 4th Validation
+     * @param <T5> the component type of the 5th Validation
+     * @param <T6> the component type of the 6th Validation
+     * @param <T7> the component type of the 7th Validation
+     * @param <T8> the component type of the 8th Validation
+     */
+    public static class ForLazy8Validation<L, T1, T2, T3, T4, T5, T6, T7, T8> {
+
+        private final Validation<L, T1> ts1;
+        private final Function1<T1, Validation<L, T2>> ts2;
+        private final Function2<T1, T2, Validation<L, T3>> ts3;
+        private final Function3<T1, T2, T3, Validation<L, T4>> ts4;
+        private final Function4<T1, T2, T3, T4, Validation<L, T5>> ts5;
+        private final Function5<T1, T2, T3, T4, T5, Validation<L, T6>> ts6;
+        private final Function6<T1, T2, T3, T4, T5, T6, Validation<L, T7>> ts7;
+        private final Function7<T1, T2, T3, T4, T5, T6, T7, Validation<L, T8>> ts8;
+
+        private ForLazy8Validation(Validation<L, T1> ts1, Function1<T1, Validation<L, T2>> ts2, Function2<T1, T2, Validation<L, T3>> ts3, Function3<T1, T2, T3, Validation<L, T4>> ts4, Function4<T1, T2, T3, T4, Validation<L, T5>> ts5, Function5<T1, T2, T3, T4, T5, Validation<L, T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, Validation<L, T7>> ts7, Function7<T1, T2, T3, T4, T5, T6, T7, Validation<L, T8>> ts8) {
+            this.ts1 = ts1;
+            this.ts2 = ts2;
+            this.ts3 = ts3;
+            this.ts4 = ts4;
+            this.ts5 = ts5;
+            this.ts6 = ts6;
+            this.ts7 = ts7;
+            this.ts8 = ts8;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Validations by
+         * composing flatMap/map chains.</p>
+         *
+         * @param f a function that maps a tuple of bound values to a result
+         * @param <R> the element type of the resulting {@code Validation}
+         * @return an {@code Validation} containing mapped results
+         * @throws NullPointerException if {@code f} is {@code null}
+         */
+        public <R> Validation<L, R> yield(Function8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R> f) {
+            Objects.requireNonNull(f, "f is null");
+            return ts1.flatMap(t1 -> {
+            return ts2.apply(t1).flatMap(t2 -> {
+              return ts3.apply(t1, t2).flatMap(t3 -> {
+                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                  return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
+                    return ts6.apply(t1, t2, t3, t4, t5).flatMap(t6 -> {
+                      return ts7.apply(t1, t2, t3, t4, t5, t6).flatMap(t7 -> {
+                        return ts8.apply(t1, t2, t3, t4, t5, t6, t7).map(t8 -> f.apply(t1, t2, t3, t4, t5, t6, t7, t8));
+                      });
+                    });
+                  });
+                });
+              });
+            });
+          });
+        }
+    }
+
     //
     // Structural Pattern Matching
     //

From ab3abdec6504626719433083a6519e6007611246 Mon Sep 17 00:00:00 2001
From: Grzegorz Piwowarek <gpiwowarek@gmail.com>
Date: Tue, 4 Nov 2025 22:21:26 +0100
Subject: [PATCH 2/8] type variance

---
 vavr/generator/Generator.scala          |   6 +-
 vavr/src-gen/main/java/io/vavr/API.java | 528 ++++++++++++------------
 2 files changed, 267 insertions(+), 267 deletions(-)

diff --git a/vavr/generator/Generator.scala b/vavr/generator/Generator.scala
index 8fb823d49a..3ac6981820 100644
--- a/vavr/generator/Generator.scala
+++ b/vavr/generator/Generator.scala
@@ -758,7 +758,7 @@ def generateMainClasses(): Unit = {
                 if (j == 1)
                   s"$mtype<${parameterInset}T1> ts1"
                 else {
-                  val inputTypes = (1 until j).gen(k => s"T$k")(", ")
+                  val inputTypes = (1 until j).gen(k => s"? super T$k")(", ")
                   s"Function${j - 1}<$inputTypes, $mtype<${parameterInset}T$j>> ts$j"
                 }
               }(", ")
@@ -806,7 +806,7 @@ def generateMainClasses(): Unit = {
                 if (j == 1)
                   s"private final $mtype<${parameterInset}T1> ts1;"
                 else {
-                  val inputTypes = (1 until j).gen(k => s"T$k")(", ")
+                  val inputTypes = (1 until j).gen(k => s"? super T$k")(", ")
                   s"private final Function${j - 1}<$inputTypes, $mtype<${parameterInset}T$j>> ts$j;"
                 }
               }("\n")
@@ -815,7 +815,7 @@ def generateMainClasses(): Unit = {
                 if (j == 1)
                   s"$mtype<${parameterInset}T1> ts1"
                 else {
-                  val inputTypes = (1 until j).gen(k => s"T$k")(", ")
+                  val inputTypes = (1 until j).gen(k => s"? super T$k")(", ")
                   s"Function${j - 1}<$inputTypes, $mtype<${parameterInset}T$j>> ts$j"
                 }
               }(", ")
diff --git a/vavr/src-gen/main/java/io/vavr/API.java b/vavr/src-gen/main/java/io/vavr/API.java
index 94fd4f1642..50ee6d9a7e 100644
--- a/vavr/src-gen/main/java/io/vavr/API.java
+++ b/vavr/src-gen/main/java/io/vavr/API.java
@@ -5757,7 +5757,7 @@ public <R> Validation<L, R> yield(Function8<? super T1, ? super T2, ? super T3,
      * @return a new {@code ForLazy2Option} builder of arity 2
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <T1, T2> ForLazy2Option<T1, T2> For(Option<T1> ts1, Function1<T1, Option<T2>> ts2) {
+    public static <T1, T2> ForLazy2Option<T1, T2> For(Option<T1> ts1, Function1<? super T1, Option<T2>> ts2) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         return new ForLazy2Option<>(ts1, ts2);
@@ -5782,7 +5782,7 @@ public static <T1, T2> ForLazy2Option<T1, T2> For(Option<T1> ts1, Function1<T1,
      * @return a new {@code ForLazy3Option} builder of arity 3
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <T1, T2, T3> ForLazy3Option<T1, T2, T3> For(Option<T1> ts1, Function1<T1, Option<T2>> ts2, Function2<T1, T2, Option<T3>> ts3) {
+    public static <T1, T2, T3> ForLazy3Option<T1, T2, T3> For(Option<T1> ts1, Function1<? super T1, Option<T2>> ts2, Function2<? super T1, ? super T2, Option<T3>> ts3) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         Objects.requireNonNull(ts3, "ts3 is null");
@@ -5810,7 +5810,7 @@ public static <T1, T2, T3> ForLazy3Option<T1, T2, T3> For(Option<T1> ts1, Functi
      * @return a new {@code ForLazy4Option} builder of arity 4
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <T1, T2, T3, T4> ForLazy4Option<T1, T2, T3, T4> For(Option<T1> ts1, Function1<T1, Option<T2>> ts2, Function2<T1, T2, Option<T3>> ts3, Function3<T1, T2, T3, Option<T4>> ts4) {
+    public static <T1, T2, T3, T4> ForLazy4Option<T1, T2, T3, T4> For(Option<T1> ts1, Function1<? super T1, Option<T2>> ts2, Function2<? super T1, ? super T2, Option<T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Option<T4>> ts4) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         Objects.requireNonNull(ts3, "ts3 is null");
@@ -5841,7 +5841,7 @@ public static <T1, T2, T3, T4> ForLazy4Option<T1, T2, T3, T4> For(Option<T1> ts1
      * @return a new {@code ForLazy5Option} builder of arity 5
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <T1, T2, T3, T4, T5> ForLazy5Option<T1, T2, T3, T4, T5> For(Option<T1> ts1, Function1<T1, Option<T2>> ts2, Function2<T1, T2, Option<T3>> ts3, Function3<T1, T2, T3, Option<T4>> ts4, Function4<T1, T2, T3, T4, Option<T5>> ts5) {
+    public static <T1, T2, T3, T4, T5> ForLazy5Option<T1, T2, T3, T4, T5> For(Option<T1> ts1, Function1<? super T1, Option<T2>> ts2, Function2<? super T1, ? super T2, Option<T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Option<T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, Option<T5>> ts5) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         Objects.requireNonNull(ts3, "ts3 is null");
@@ -5875,7 +5875,7 @@ public static <T1, T2, T3, T4, T5> ForLazy5Option<T1, T2, T3, T4, T5> For(Option
      * @return a new {@code ForLazy6Option} builder of arity 6
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <T1, T2, T3, T4, T5, T6> ForLazy6Option<T1, T2, T3, T4, T5, T6> For(Option<T1> ts1, Function1<T1, Option<T2>> ts2, Function2<T1, T2, Option<T3>> ts3, Function3<T1, T2, T3, Option<T4>> ts4, Function4<T1, T2, T3, T4, Option<T5>> ts5, Function5<T1, T2, T3, T4, T5, Option<T6>> ts6) {
+    public static <T1, T2, T3, T4, T5, T6> ForLazy6Option<T1, T2, T3, T4, T5, T6> For(Option<T1> ts1, Function1<? super T1, Option<T2>> ts2, Function2<? super T1, ? super T2, Option<T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Option<T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, Option<T5>> ts5, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Option<T6>> ts6) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         Objects.requireNonNull(ts3, "ts3 is null");
@@ -5912,7 +5912,7 @@ public static <T1, T2, T3, T4, T5, T6> ForLazy6Option<T1, T2, T3, T4, T5, T6> Fo
      * @return a new {@code ForLazy7Option} builder of arity 7
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <T1, T2, T3, T4, T5, T6, T7> ForLazy7Option<T1, T2, T3, T4, T5, T6, T7> For(Option<T1> ts1, Function1<T1, Option<T2>> ts2, Function2<T1, T2, Option<T3>> ts3, Function3<T1, T2, T3, Option<T4>> ts4, Function4<T1, T2, T3, T4, Option<T5>> ts5, Function5<T1, T2, T3, T4, T5, Option<T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, Option<T7>> ts7) {
+    public static <T1, T2, T3, T4, T5, T6, T7> ForLazy7Option<T1, T2, T3, T4, T5, T6, T7> For(Option<T1> ts1, Function1<? super T1, Option<T2>> ts2, Function2<? super T1, ? super T2, Option<T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Option<T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, Option<T5>> ts5, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Option<T6>> ts6, Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, Option<T7>> ts7) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         Objects.requireNonNull(ts3, "ts3 is null");
@@ -5952,7 +5952,7 @@ public static <T1, T2, T3, T4, T5, T6, T7> ForLazy7Option<T1, T2, T3, T4, T5, T6
      * @return a new {@code ForLazy8Option} builder of arity 8
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <T1, T2, T3, T4, T5, T6, T7, T8> ForLazy8Option<T1, T2, T3, T4, T5, T6, T7, T8> For(Option<T1> ts1, Function1<T1, Option<T2>> ts2, Function2<T1, T2, Option<T3>> ts3, Function3<T1, T2, T3, Option<T4>> ts4, Function4<T1, T2, T3, T4, Option<T5>> ts5, Function5<T1, T2, T3, T4, T5, Option<T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, Option<T7>> ts7, Function7<T1, T2, T3, T4, T5, T6, T7, Option<T8>> ts8) {
+    public static <T1, T2, T3, T4, T5, T6, T7, T8> ForLazy8Option<T1, T2, T3, T4, T5, T6, T7, T8> For(Option<T1> ts1, Function1<? super T1, Option<T2>> ts2, Function2<? super T1, ? super T2, Option<T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Option<T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, Option<T5>> ts5, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Option<T6>> ts6, Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, Option<T7>> ts7, Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, Option<T8>> ts8) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         Objects.requireNonNull(ts3, "ts3 is null");
@@ -5981,7 +5981,7 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8> ForLazy8Option<T1, T2, T3, T4, T5
      * @return a new {@code ForLazy2Future} builder of arity 2
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <T1, T2> ForLazy2Future<T1, T2> For(Future<T1> ts1, Function1<T1, Future<T2>> ts2) {
+    public static <T1, T2> ForLazy2Future<T1, T2> For(Future<T1> ts1, Function1<? super T1, Future<T2>> ts2) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         return new ForLazy2Future<>(ts1, ts2);
@@ -6006,7 +6006,7 @@ public static <T1, T2> ForLazy2Future<T1, T2> For(Future<T1> ts1, Function1<T1,
      * @return a new {@code ForLazy3Future} builder of arity 3
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <T1, T2, T3> ForLazy3Future<T1, T2, T3> For(Future<T1> ts1, Function1<T1, Future<T2>> ts2, Function2<T1, T2, Future<T3>> ts3) {
+    public static <T1, T2, T3> ForLazy3Future<T1, T2, T3> For(Future<T1> ts1, Function1<? super T1, Future<T2>> ts2, Function2<? super T1, ? super T2, Future<T3>> ts3) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         Objects.requireNonNull(ts3, "ts3 is null");
@@ -6034,7 +6034,7 @@ public static <T1, T2, T3> ForLazy3Future<T1, T2, T3> For(Future<T1> ts1, Functi
      * @return a new {@code ForLazy4Future} builder of arity 4
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <T1, T2, T3, T4> ForLazy4Future<T1, T2, T3, T4> For(Future<T1> ts1, Function1<T1, Future<T2>> ts2, Function2<T1, T2, Future<T3>> ts3, Function3<T1, T2, T3, Future<T4>> ts4) {
+    public static <T1, T2, T3, T4> ForLazy4Future<T1, T2, T3, T4> For(Future<T1> ts1, Function1<? super T1, Future<T2>> ts2, Function2<? super T1, ? super T2, Future<T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Future<T4>> ts4) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         Objects.requireNonNull(ts3, "ts3 is null");
@@ -6065,7 +6065,7 @@ public static <T1, T2, T3, T4> ForLazy4Future<T1, T2, T3, T4> For(Future<T1> ts1
      * @return a new {@code ForLazy5Future} builder of arity 5
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <T1, T2, T3, T4, T5> ForLazy5Future<T1, T2, T3, T4, T5> For(Future<T1> ts1, Function1<T1, Future<T2>> ts2, Function2<T1, T2, Future<T3>> ts3, Function3<T1, T2, T3, Future<T4>> ts4, Function4<T1, T2, T3, T4, Future<T5>> ts5) {
+    public static <T1, T2, T3, T4, T5> ForLazy5Future<T1, T2, T3, T4, T5> For(Future<T1> ts1, Function1<? super T1, Future<T2>> ts2, Function2<? super T1, ? super T2, Future<T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Future<T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, Future<T5>> ts5) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         Objects.requireNonNull(ts3, "ts3 is null");
@@ -6099,7 +6099,7 @@ public static <T1, T2, T3, T4, T5> ForLazy5Future<T1, T2, T3, T4, T5> For(Future
      * @return a new {@code ForLazy6Future} builder of arity 6
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <T1, T2, T3, T4, T5, T6> ForLazy6Future<T1, T2, T3, T4, T5, T6> For(Future<T1> ts1, Function1<T1, Future<T2>> ts2, Function2<T1, T2, Future<T3>> ts3, Function3<T1, T2, T3, Future<T4>> ts4, Function4<T1, T2, T3, T4, Future<T5>> ts5, Function5<T1, T2, T3, T4, T5, Future<T6>> ts6) {
+    public static <T1, T2, T3, T4, T5, T6> ForLazy6Future<T1, T2, T3, T4, T5, T6> For(Future<T1> ts1, Function1<? super T1, Future<T2>> ts2, Function2<? super T1, ? super T2, Future<T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Future<T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, Future<T5>> ts5, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Future<T6>> ts6) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         Objects.requireNonNull(ts3, "ts3 is null");
@@ -6136,7 +6136,7 @@ public static <T1, T2, T3, T4, T5, T6> ForLazy6Future<T1, T2, T3, T4, T5, T6> Fo
      * @return a new {@code ForLazy7Future} builder of arity 7
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <T1, T2, T3, T4, T5, T6, T7> ForLazy7Future<T1, T2, T3, T4, T5, T6, T7> For(Future<T1> ts1, Function1<T1, Future<T2>> ts2, Function2<T1, T2, Future<T3>> ts3, Function3<T1, T2, T3, Future<T4>> ts4, Function4<T1, T2, T3, T4, Future<T5>> ts5, Function5<T1, T2, T3, T4, T5, Future<T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, Future<T7>> ts7) {
+    public static <T1, T2, T3, T4, T5, T6, T7> ForLazy7Future<T1, T2, T3, T4, T5, T6, T7> For(Future<T1> ts1, Function1<? super T1, Future<T2>> ts2, Function2<? super T1, ? super T2, Future<T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Future<T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, Future<T5>> ts5, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Future<T6>> ts6, Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, Future<T7>> ts7) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         Objects.requireNonNull(ts3, "ts3 is null");
@@ -6176,7 +6176,7 @@ public static <T1, T2, T3, T4, T5, T6, T7> ForLazy7Future<T1, T2, T3, T4, T5, T6
      * @return a new {@code ForLazy8Future} builder of arity 8
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <T1, T2, T3, T4, T5, T6, T7, T8> ForLazy8Future<T1, T2, T3, T4, T5, T6, T7, T8> For(Future<T1> ts1, Function1<T1, Future<T2>> ts2, Function2<T1, T2, Future<T3>> ts3, Function3<T1, T2, T3, Future<T4>> ts4, Function4<T1, T2, T3, T4, Future<T5>> ts5, Function5<T1, T2, T3, T4, T5, Future<T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, Future<T7>> ts7, Function7<T1, T2, T3, T4, T5, T6, T7, Future<T8>> ts8) {
+    public static <T1, T2, T3, T4, T5, T6, T7, T8> ForLazy8Future<T1, T2, T3, T4, T5, T6, T7, T8> For(Future<T1> ts1, Function1<? super T1, Future<T2>> ts2, Function2<? super T1, ? super T2, Future<T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Future<T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, Future<T5>> ts5, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Future<T6>> ts6, Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, Future<T7>> ts7, Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, Future<T8>> ts8) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         Objects.requireNonNull(ts3, "ts3 is null");
@@ -6205,7 +6205,7 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8> ForLazy8Future<T1, T2, T3, T4, T5
      * @return a new {@code ForLazy2Try} builder of arity 2
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <T1, T2> ForLazy2Try<T1, T2> For(Try<T1> ts1, Function1<T1, Try<T2>> ts2) {
+    public static <T1, T2> ForLazy2Try<T1, T2> For(Try<T1> ts1, Function1<? super T1, Try<T2>> ts2) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         return new ForLazy2Try<>(ts1, ts2);
@@ -6230,7 +6230,7 @@ public static <T1, T2> ForLazy2Try<T1, T2> For(Try<T1> ts1, Function1<T1, Try<T2
      * @return a new {@code ForLazy3Try} builder of arity 3
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <T1, T2, T3> ForLazy3Try<T1, T2, T3> For(Try<T1> ts1, Function1<T1, Try<T2>> ts2, Function2<T1, T2, Try<T3>> ts3) {
+    public static <T1, T2, T3> ForLazy3Try<T1, T2, T3> For(Try<T1> ts1, Function1<? super T1, Try<T2>> ts2, Function2<? super T1, ? super T2, Try<T3>> ts3) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         Objects.requireNonNull(ts3, "ts3 is null");
@@ -6258,7 +6258,7 @@ public static <T1, T2, T3> ForLazy3Try<T1, T2, T3> For(Try<T1> ts1, Function1<T1
      * @return a new {@code ForLazy4Try} builder of arity 4
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <T1, T2, T3, T4> ForLazy4Try<T1, T2, T3, T4> For(Try<T1> ts1, Function1<T1, Try<T2>> ts2, Function2<T1, T2, Try<T3>> ts3, Function3<T1, T2, T3, Try<T4>> ts4) {
+    public static <T1, T2, T3, T4> ForLazy4Try<T1, T2, T3, T4> For(Try<T1> ts1, Function1<? super T1, Try<T2>> ts2, Function2<? super T1, ? super T2, Try<T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Try<T4>> ts4) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         Objects.requireNonNull(ts3, "ts3 is null");
@@ -6289,7 +6289,7 @@ public static <T1, T2, T3, T4> ForLazy4Try<T1, T2, T3, T4> For(Try<T1> ts1, Func
      * @return a new {@code ForLazy5Try} builder of arity 5
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <T1, T2, T3, T4, T5> ForLazy5Try<T1, T2, T3, T4, T5> For(Try<T1> ts1, Function1<T1, Try<T2>> ts2, Function2<T1, T2, Try<T3>> ts3, Function3<T1, T2, T3, Try<T4>> ts4, Function4<T1, T2, T3, T4, Try<T5>> ts5) {
+    public static <T1, T2, T3, T4, T5> ForLazy5Try<T1, T2, T3, T4, T5> For(Try<T1> ts1, Function1<? super T1, Try<T2>> ts2, Function2<? super T1, ? super T2, Try<T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Try<T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, Try<T5>> ts5) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         Objects.requireNonNull(ts3, "ts3 is null");
@@ -6323,7 +6323,7 @@ public static <T1, T2, T3, T4, T5> ForLazy5Try<T1, T2, T3, T4, T5> For(Try<T1> t
      * @return a new {@code ForLazy6Try} builder of arity 6
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <T1, T2, T3, T4, T5, T6> ForLazy6Try<T1, T2, T3, T4, T5, T6> For(Try<T1> ts1, Function1<T1, Try<T2>> ts2, Function2<T1, T2, Try<T3>> ts3, Function3<T1, T2, T3, Try<T4>> ts4, Function4<T1, T2, T3, T4, Try<T5>> ts5, Function5<T1, T2, T3, T4, T5, Try<T6>> ts6) {
+    public static <T1, T2, T3, T4, T5, T6> ForLazy6Try<T1, T2, T3, T4, T5, T6> For(Try<T1> ts1, Function1<? super T1, Try<T2>> ts2, Function2<? super T1, ? super T2, Try<T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Try<T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, Try<T5>> ts5, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Try<T6>> ts6) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         Objects.requireNonNull(ts3, "ts3 is null");
@@ -6360,7 +6360,7 @@ public static <T1, T2, T3, T4, T5, T6> ForLazy6Try<T1, T2, T3, T4, T5, T6> For(T
      * @return a new {@code ForLazy7Try} builder of arity 7
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <T1, T2, T3, T4, T5, T6, T7> ForLazy7Try<T1, T2, T3, T4, T5, T6, T7> For(Try<T1> ts1, Function1<T1, Try<T2>> ts2, Function2<T1, T2, Try<T3>> ts3, Function3<T1, T2, T3, Try<T4>> ts4, Function4<T1, T2, T3, T4, Try<T5>> ts5, Function5<T1, T2, T3, T4, T5, Try<T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, Try<T7>> ts7) {
+    public static <T1, T2, T3, T4, T5, T6, T7> ForLazy7Try<T1, T2, T3, T4, T5, T6, T7> For(Try<T1> ts1, Function1<? super T1, Try<T2>> ts2, Function2<? super T1, ? super T2, Try<T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Try<T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, Try<T5>> ts5, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Try<T6>> ts6, Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, Try<T7>> ts7) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         Objects.requireNonNull(ts3, "ts3 is null");
@@ -6400,7 +6400,7 @@ public static <T1, T2, T3, T4, T5, T6, T7> ForLazy7Try<T1, T2, T3, T4, T5, T6, T
      * @return a new {@code ForLazy8Try} builder of arity 8
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <T1, T2, T3, T4, T5, T6, T7, T8> ForLazy8Try<T1, T2, T3, T4, T5, T6, T7, T8> For(Try<T1> ts1, Function1<T1, Try<T2>> ts2, Function2<T1, T2, Try<T3>> ts3, Function3<T1, T2, T3, Try<T4>> ts4, Function4<T1, T2, T3, T4, Try<T5>> ts5, Function5<T1, T2, T3, T4, T5, Try<T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, Try<T7>> ts7, Function7<T1, T2, T3, T4, T5, T6, T7, Try<T8>> ts8) {
+    public static <T1, T2, T3, T4, T5, T6, T7, T8> ForLazy8Try<T1, T2, T3, T4, T5, T6, T7, T8> For(Try<T1> ts1, Function1<? super T1, Try<T2>> ts2, Function2<? super T1, ? super T2, Try<T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Try<T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, Try<T5>> ts5, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Try<T6>> ts6, Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, Try<T7>> ts7, Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, Try<T8>> ts8) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         Objects.requireNonNull(ts3, "ts3 is null");
@@ -6429,7 +6429,7 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8> ForLazy8Try<T1, T2, T3, T4, T5, T
      * @return a new {@code ForLazy2List} builder of arity 2
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <T1, T2> ForLazy2List<T1, T2> For(List<T1> ts1, Function1<T1, List<T2>> ts2) {
+    public static <T1, T2> ForLazy2List<T1, T2> For(List<T1> ts1, Function1<? super T1, List<T2>> ts2) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         return new ForLazy2List<>(ts1, ts2);
@@ -6454,7 +6454,7 @@ public static <T1, T2> ForLazy2List<T1, T2> For(List<T1> ts1, Function1<T1, List
      * @return a new {@code ForLazy3List} builder of arity 3
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <T1, T2, T3> ForLazy3List<T1, T2, T3> For(List<T1> ts1, Function1<T1, List<T2>> ts2, Function2<T1, T2, List<T3>> ts3) {
+    public static <T1, T2, T3> ForLazy3List<T1, T2, T3> For(List<T1> ts1, Function1<? super T1, List<T2>> ts2, Function2<? super T1, ? super T2, List<T3>> ts3) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         Objects.requireNonNull(ts3, "ts3 is null");
@@ -6482,7 +6482,7 @@ public static <T1, T2, T3> ForLazy3List<T1, T2, T3> For(List<T1> ts1, Function1<
      * @return a new {@code ForLazy4List} builder of arity 4
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <T1, T2, T3, T4> ForLazy4List<T1, T2, T3, T4> For(List<T1> ts1, Function1<T1, List<T2>> ts2, Function2<T1, T2, List<T3>> ts3, Function3<T1, T2, T3, List<T4>> ts4) {
+    public static <T1, T2, T3, T4> ForLazy4List<T1, T2, T3, T4> For(List<T1> ts1, Function1<? super T1, List<T2>> ts2, Function2<? super T1, ? super T2, List<T3>> ts3, Function3<? super T1, ? super T2, ? super T3, List<T4>> ts4) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         Objects.requireNonNull(ts3, "ts3 is null");
@@ -6513,7 +6513,7 @@ public static <T1, T2, T3, T4> ForLazy4List<T1, T2, T3, T4> For(List<T1> ts1, Fu
      * @return a new {@code ForLazy5List} builder of arity 5
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <T1, T2, T3, T4, T5> ForLazy5List<T1, T2, T3, T4, T5> For(List<T1> ts1, Function1<T1, List<T2>> ts2, Function2<T1, T2, List<T3>> ts3, Function3<T1, T2, T3, List<T4>> ts4, Function4<T1, T2, T3, T4, List<T5>> ts5) {
+    public static <T1, T2, T3, T4, T5> ForLazy5List<T1, T2, T3, T4, T5> For(List<T1> ts1, Function1<? super T1, List<T2>> ts2, Function2<? super T1, ? super T2, List<T3>> ts3, Function3<? super T1, ? super T2, ? super T3, List<T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, List<T5>> ts5) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         Objects.requireNonNull(ts3, "ts3 is null");
@@ -6547,7 +6547,7 @@ public static <T1, T2, T3, T4, T5> ForLazy5List<T1, T2, T3, T4, T5> For(List<T1>
      * @return a new {@code ForLazy6List} builder of arity 6
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <T1, T2, T3, T4, T5, T6> ForLazy6List<T1, T2, T3, T4, T5, T6> For(List<T1> ts1, Function1<T1, List<T2>> ts2, Function2<T1, T2, List<T3>> ts3, Function3<T1, T2, T3, List<T4>> ts4, Function4<T1, T2, T3, T4, List<T5>> ts5, Function5<T1, T2, T3, T4, T5, List<T6>> ts6) {
+    public static <T1, T2, T3, T4, T5, T6> ForLazy6List<T1, T2, T3, T4, T5, T6> For(List<T1> ts1, Function1<? super T1, List<T2>> ts2, Function2<? super T1, ? super T2, List<T3>> ts3, Function3<? super T1, ? super T2, ? super T3, List<T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, List<T5>> ts5, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, List<T6>> ts6) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         Objects.requireNonNull(ts3, "ts3 is null");
@@ -6584,7 +6584,7 @@ public static <T1, T2, T3, T4, T5, T6> ForLazy6List<T1, T2, T3, T4, T5, T6> For(
      * @return a new {@code ForLazy7List} builder of arity 7
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <T1, T2, T3, T4, T5, T6, T7> ForLazy7List<T1, T2, T3, T4, T5, T6, T7> For(List<T1> ts1, Function1<T1, List<T2>> ts2, Function2<T1, T2, List<T3>> ts3, Function3<T1, T2, T3, List<T4>> ts4, Function4<T1, T2, T3, T4, List<T5>> ts5, Function5<T1, T2, T3, T4, T5, List<T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, List<T7>> ts7) {
+    public static <T1, T2, T3, T4, T5, T6, T7> ForLazy7List<T1, T2, T3, T4, T5, T6, T7> For(List<T1> ts1, Function1<? super T1, List<T2>> ts2, Function2<? super T1, ? super T2, List<T3>> ts3, Function3<? super T1, ? super T2, ? super T3, List<T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, List<T5>> ts5, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, List<T6>> ts6, Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, List<T7>> ts7) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         Objects.requireNonNull(ts3, "ts3 is null");
@@ -6624,7 +6624,7 @@ public static <T1, T2, T3, T4, T5, T6, T7> ForLazy7List<T1, T2, T3, T4, T5, T6,
      * @return a new {@code ForLazy8List} builder of arity 8
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <T1, T2, T3, T4, T5, T6, T7, T8> ForLazy8List<T1, T2, T3, T4, T5, T6, T7, T8> For(List<T1> ts1, Function1<T1, List<T2>> ts2, Function2<T1, T2, List<T3>> ts3, Function3<T1, T2, T3, List<T4>> ts4, Function4<T1, T2, T3, T4, List<T5>> ts5, Function5<T1, T2, T3, T4, T5, List<T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, List<T7>> ts7, Function7<T1, T2, T3, T4, T5, T6, T7, List<T8>> ts8) {
+    public static <T1, T2, T3, T4, T5, T6, T7, T8> ForLazy8List<T1, T2, T3, T4, T5, T6, T7, T8> For(List<T1> ts1, Function1<? super T1, List<T2>> ts2, Function2<? super T1, ? super T2, List<T3>> ts3, Function3<? super T1, ? super T2, ? super T3, List<T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, List<T5>> ts5, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, List<T6>> ts6, Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, List<T7>> ts7, Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, List<T8>> ts8) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         Objects.requireNonNull(ts3, "ts3 is null");
@@ -6653,7 +6653,7 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8> ForLazy8List<T1, T2, T3, T4, T5,
      * @return a new {@code ForLazy2Either} builder of arity 2
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <L, T1, T2> ForLazy2Either<L, T1, T2> For(Either<L, T1> ts1, Function1<T1, Either<L, T2>> ts2) {
+    public static <L, T1, T2> ForLazy2Either<L, T1, T2> For(Either<L, T1> ts1, Function1<? super T1, Either<L, T2>> ts2) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         return new ForLazy2Either<>(ts1, ts2);
@@ -6678,7 +6678,7 @@ public static <L, T1, T2> ForLazy2Either<L, T1, T2> For(Either<L, T1> ts1, Funct
      * @return a new {@code ForLazy3Either} builder of arity 3
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <L, T1, T2, T3> ForLazy3Either<L, T1, T2, T3> For(Either<L, T1> ts1, Function1<T1, Either<L, T2>> ts2, Function2<T1, T2, Either<L, T3>> ts3) {
+    public static <L, T1, T2, T3> ForLazy3Either<L, T1, T2, T3> For(Either<L, T1> ts1, Function1<? super T1, Either<L, T2>> ts2, Function2<? super T1, ? super T2, Either<L, T3>> ts3) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         Objects.requireNonNull(ts3, "ts3 is null");
@@ -6706,7 +6706,7 @@ public static <L, T1, T2, T3> ForLazy3Either<L, T1, T2, T3> For(Either<L, T1> ts
      * @return a new {@code ForLazy4Either} builder of arity 4
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <L, T1, T2, T3, T4> ForLazy4Either<L, T1, T2, T3, T4> For(Either<L, T1> ts1, Function1<T1, Either<L, T2>> ts2, Function2<T1, T2, Either<L, T3>> ts3, Function3<T1, T2, T3, Either<L, T4>> ts4) {
+    public static <L, T1, T2, T3, T4> ForLazy4Either<L, T1, T2, T3, T4> For(Either<L, T1> ts1, Function1<? super T1, Either<L, T2>> ts2, Function2<? super T1, ? super T2, Either<L, T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Either<L, T4>> ts4) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         Objects.requireNonNull(ts3, "ts3 is null");
@@ -6737,7 +6737,7 @@ public static <L, T1, T2, T3, T4> ForLazy4Either<L, T1, T2, T3, T4> For(Either<L
      * @return a new {@code ForLazy5Either} builder of arity 5
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <L, T1, T2, T3, T4, T5> ForLazy5Either<L, T1, T2, T3, T4, T5> For(Either<L, T1> ts1, Function1<T1, Either<L, T2>> ts2, Function2<T1, T2, Either<L, T3>> ts3, Function3<T1, T2, T3, Either<L, T4>> ts4, Function4<T1, T2, T3, T4, Either<L, T5>> ts5) {
+    public static <L, T1, T2, T3, T4, T5> ForLazy5Either<L, T1, T2, T3, T4, T5> For(Either<L, T1> ts1, Function1<? super T1, Either<L, T2>> ts2, Function2<? super T1, ? super T2, Either<L, T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Either<L, T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, Either<L, T5>> ts5) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         Objects.requireNonNull(ts3, "ts3 is null");
@@ -6771,7 +6771,7 @@ public static <L, T1, T2, T3, T4, T5> ForLazy5Either<L, T1, T2, T3, T4, T5> For(
      * @return a new {@code ForLazy6Either} builder of arity 6
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <L, T1, T2, T3, T4, T5, T6> ForLazy6Either<L, T1, T2, T3, T4, T5, T6> For(Either<L, T1> ts1, Function1<T1, Either<L, T2>> ts2, Function2<T1, T2, Either<L, T3>> ts3, Function3<T1, T2, T3, Either<L, T4>> ts4, Function4<T1, T2, T3, T4, Either<L, T5>> ts5, Function5<T1, T2, T3, T4, T5, Either<L, T6>> ts6) {
+    public static <L, T1, T2, T3, T4, T5, T6> ForLazy6Either<L, T1, T2, T3, T4, T5, T6> For(Either<L, T1> ts1, Function1<? super T1, Either<L, T2>> ts2, Function2<? super T1, ? super T2, Either<L, T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Either<L, T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, Either<L, T5>> ts5, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Either<L, T6>> ts6) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         Objects.requireNonNull(ts3, "ts3 is null");
@@ -6808,7 +6808,7 @@ public static <L, T1, T2, T3, T4, T5, T6> ForLazy6Either<L, T1, T2, T3, T4, T5,
      * @return a new {@code ForLazy7Either} builder of arity 7
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <L, T1, T2, T3, T4, T5, T6, T7> ForLazy7Either<L, T1, T2, T3, T4, T5, T6, T7> For(Either<L, T1> ts1, Function1<T1, Either<L, T2>> ts2, Function2<T1, T2, Either<L, T3>> ts3, Function3<T1, T2, T3, Either<L, T4>> ts4, Function4<T1, T2, T3, T4, Either<L, T5>> ts5, Function5<T1, T2, T3, T4, T5, Either<L, T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, Either<L, T7>> ts7) {
+    public static <L, T1, T2, T3, T4, T5, T6, T7> ForLazy7Either<L, T1, T2, T3, T4, T5, T6, T7> For(Either<L, T1> ts1, Function1<? super T1, Either<L, T2>> ts2, Function2<? super T1, ? super T2, Either<L, T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Either<L, T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, Either<L, T5>> ts5, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Either<L, T6>> ts6, Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, Either<L, T7>> ts7) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         Objects.requireNonNull(ts3, "ts3 is null");
@@ -6848,7 +6848,7 @@ public static <L, T1, T2, T3, T4, T5, T6, T7> ForLazy7Either<L, T1, T2, T3, T4,
      * @return a new {@code ForLazy8Either} builder of arity 8
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <L, T1, T2, T3, T4, T5, T6, T7, T8> ForLazy8Either<L, T1, T2, T3, T4, T5, T6, T7, T8> For(Either<L, T1> ts1, Function1<T1, Either<L, T2>> ts2, Function2<T1, T2, Either<L, T3>> ts3, Function3<T1, T2, T3, Either<L, T4>> ts4, Function4<T1, T2, T3, T4, Either<L, T5>> ts5, Function5<T1, T2, T3, T4, T5, Either<L, T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, Either<L, T7>> ts7, Function7<T1, T2, T3, T4, T5, T6, T7, Either<L, T8>> ts8) {
+    public static <L, T1, T2, T3, T4, T5, T6, T7, T8> ForLazy8Either<L, T1, T2, T3, T4, T5, T6, T7, T8> For(Either<L, T1> ts1, Function1<? super T1, Either<L, T2>> ts2, Function2<? super T1, ? super T2, Either<L, T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Either<L, T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, Either<L, T5>> ts5, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Either<L, T6>> ts6, Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, Either<L, T7>> ts7, Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, Either<L, T8>> ts8) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         Objects.requireNonNull(ts3, "ts3 is null");
@@ -6877,7 +6877,7 @@ public static <L, T1, T2, T3, T4, T5, T6, T7, T8> ForLazy8Either<L, T1, T2, T3,
      * @return a new {@code ForLazy2Validation} builder of arity 2
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <L, T1, T2> ForLazy2Validation<L, T1, T2> For(Validation<L, T1> ts1, Function1<T1, Validation<L, T2>> ts2) {
+    public static <L, T1, T2> ForLazy2Validation<L, T1, T2> For(Validation<L, T1> ts1, Function1<? super T1, Validation<L, T2>> ts2) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         return new ForLazy2Validation<>(ts1, ts2);
@@ -6902,7 +6902,7 @@ public static <L, T1, T2> ForLazy2Validation<L, T1, T2> For(Validation<L, T1> ts
      * @return a new {@code ForLazy3Validation} builder of arity 3
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <L, T1, T2, T3> ForLazy3Validation<L, T1, T2, T3> For(Validation<L, T1> ts1, Function1<T1, Validation<L, T2>> ts2, Function2<T1, T2, Validation<L, T3>> ts3) {
+    public static <L, T1, T2, T3> ForLazy3Validation<L, T1, T2, T3> For(Validation<L, T1> ts1, Function1<? super T1, Validation<L, T2>> ts2, Function2<? super T1, ? super T2, Validation<L, T3>> ts3) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         Objects.requireNonNull(ts3, "ts3 is null");
@@ -6930,7 +6930,7 @@ public static <L, T1, T2, T3> ForLazy3Validation<L, T1, T2, T3> For(Validation<L
      * @return a new {@code ForLazy4Validation} builder of arity 4
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <L, T1, T2, T3, T4> ForLazy4Validation<L, T1, T2, T3, T4> For(Validation<L, T1> ts1, Function1<T1, Validation<L, T2>> ts2, Function2<T1, T2, Validation<L, T3>> ts3, Function3<T1, T2, T3, Validation<L, T4>> ts4) {
+    public static <L, T1, T2, T3, T4> ForLazy4Validation<L, T1, T2, T3, T4> For(Validation<L, T1> ts1, Function1<? super T1, Validation<L, T2>> ts2, Function2<? super T1, ? super T2, Validation<L, T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Validation<L, T4>> ts4) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         Objects.requireNonNull(ts3, "ts3 is null");
@@ -6961,7 +6961,7 @@ public static <L, T1, T2, T3, T4> ForLazy4Validation<L, T1, T2, T3, T4> For(Vali
      * @return a new {@code ForLazy5Validation} builder of arity 5
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <L, T1, T2, T3, T4, T5> ForLazy5Validation<L, T1, T2, T3, T4, T5> For(Validation<L, T1> ts1, Function1<T1, Validation<L, T2>> ts2, Function2<T1, T2, Validation<L, T3>> ts3, Function3<T1, T2, T3, Validation<L, T4>> ts4, Function4<T1, T2, T3, T4, Validation<L, T5>> ts5) {
+    public static <L, T1, T2, T3, T4, T5> ForLazy5Validation<L, T1, T2, T3, T4, T5> For(Validation<L, T1> ts1, Function1<? super T1, Validation<L, T2>> ts2, Function2<? super T1, ? super T2, Validation<L, T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Validation<L, T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, Validation<L, T5>> ts5) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         Objects.requireNonNull(ts3, "ts3 is null");
@@ -6995,7 +6995,7 @@ public static <L, T1, T2, T3, T4, T5> ForLazy5Validation<L, T1, T2, T3, T4, T5>
      * @return a new {@code ForLazy6Validation} builder of arity 6
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <L, T1, T2, T3, T4, T5, T6> ForLazy6Validation<L, T1, T2, T3, T4, T5, T6> For(Validation<L, T1> ts1, Function1<T1, Validation<L, T2>> ts2, Function2<T1, T2, Validation<L, T3>> ts3, Function3<T1, T2, T3, Validation<L, T4>> ts4, Function4<T1, T2, T3, T4, Validation<L, T5>> ts5, Function5<T1, T2, T3, T4, T5, Validation<L, T6>> ts6) {
+    public static <L, T1, T2, T3, T4, T5, T6> ForLazy6Validation<L, T1, T2, T3, T4, T5, T6> For(Validation<L, T1> ts1, Function1<? super T1, Validation<L, T2>> ts2, Function2<? super T1, ? super T2, Validation<L, T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Validation<L, T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, Validation<L, T5>> ts5, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Validation<L, T6>> ts6) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         Objects.requireNonNull(ts3, "ts3 is null");
@@ -7032,7 +7032,7 @@ public static <L, T1, T2, T3, T4, T5, T6> ForLazy6Validation<L, T1, T2, T3, T4,
      * @return a new {@code ForLazy7Validation} builder of arity 7
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <L, T1, T2, T3, T4, T5, T6, T7> ForLazy7Validation<L, T1, T2, T3, T4, T5, T6, T7> For(Validation<L, T1> ts1, Function1<T1, Validation<L, T2>> ts2, Function2<T1, T2, Validation<L, T3>> ts3, Function3<T1, T2, T3, Validation<L, T4>> ts4, Function4<T1, T2, T3, T4, Validation<L, T5>> ts5, Function5<T1, T2, T3, T4, T5, Validation<L, T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, Validation<L, T7>> ts7) {
+    public static <L, T1, T2, T3, T4, T5, T6, T7> ForLazy7Validation<L, T1, T2, T3, T4, T5, T6, T7> For(Validation<L, T1> ts1, Function1<? super T1, Validation<L, T2>> ts2, Function2<? super T1, ? super T2, Validation<L, T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Validation<L, T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, Validation<L, T5>> ts5, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Validation<L, T6>> ts6, Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, Validation<L, T7>> ts7) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         Objects.requireNonNull(ts3, "ts3 is null");
@@ -7072,7 +7072,7 @@ public static <L, T1, T2, T3, T4, T5, T6, T7> ForLazy7Validation<L, T1, T2, T3,
      * @return a new {@code ForLazy8Validation} builder of arity 8
      * @throws NullPointerException if any argument is {@code null}
      */
-    public static <L, T1, T2, T3, T4, T5, T6, T7, T8> ForLazy8Validation<L, T1, T2, T3, T4, T5, T6, T7, T8> For(Validation<L, T1> ts1, Function1<T1, Validation<L, T2>> ts2, Function2<T1, T2, Validation<L, T3>> ts3, Function3<T1, T2, T3, Validation<L, T4>> ts4, Function4<T1, T2, T3, T4, Validation<L, T5>> ts5, Function5<T1, T2, T3, T4, T5, Validation<L, T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, Validation<L, T7>> ts7, Function7<T1, T2, T3, T4, T5, T6, T7, Validation<L, T8>> ts8) {
+    public static <L, T1, T2, T3, T4, T5, T6, T7, T8> ForLazy8Validation<L, T1, T2, T3, T4, T5, T6, T7, T8> For(Validation<L, T1> ts1, Function1<? super T1, Validation<L, T2>> ts2, Function2<? super T1, ? super T2, Validation<L, T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Validation<L, T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, Validation<L, T5>> ts5, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Validation<L, T6>> ts6, Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, Validation<L, T7>> ts7, Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, Validation<L, T8>> ts8) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         Objects.requireNonNull(ts3, "ts3 is null");
@@ -7098,9 +7098,9 @@ public static <L, T1, T2, T3, T4, T5, T6, T7, T8> ForLazy8Validation<L, T1, T2,
     public static class ForLazy2Option<T1, T2> {
 
         private final Option<T1> ts1;
-        private final Function1<T1, Option<T2>> ts2;
+        private final Function1<? super T1, Option<T2>> ts2;
 
-        private ForLazy2Option(Option<T1> ts1, Function1<T1, Option<T2>> ts2) {
+        private ForLazy2Option(Option<T1> ts1, Function1<? super T1, Option<T2>> ts2) {
             this.ts1 = ts1;
             this.ts2 = ts2;
         }
@@ -7139,10 +7139,10 @@ public <R> Option<R> yield(BiFunction<? super T1, ? super T2, ? extends R> f) {
     public static class ForLazy3Option<T1, T2, T3> {
 
         private final Option<T1> ts1;
-        private final Function1<T1, Option<T2>> ts2;
-        private final Function2<T1, T2, Option<T3>> ts3;
+        private final Function1<? super T1, Option<T2>> ts2;
+        private final Function2<? super T1, ? super T2, Option<T3>> ts3;
 
-        private ForLazy3Option(Option<T1> ts1, Function1<T1, Option<T2>> ts2, Function2<T1, T2, Option<T3>> ts3) {
+        private ForLazy3Option(Option<T1> ts1, Function1<? super T1, Option<T2>> ts2, Function2<? super T1, ? super T2, Option<T3>> ts3) {
             this.ts1 = ts1;
             this.ts2 = ts2;
             this.ts3 = ts3;
@@ -7185,11 +7185,11 @@ public <R> Option<R> yield(Function3<? super T1, ? super T2, ? super T3, ? exten
     public static class ForLazy4Option<T1, T2, T3, T4> {
 
         private final Option<T1> ts1;
-        private final Function1<T1, Option<T2>> ts2;
-        private final Function2<T1, T2, Option<T3>> ts3;
-        private final Function3<T1, T2, T3, Option<T4>> ts4;
+        private final Function1<? super T1, Option<T2>> ts2;
+        private final Function2<? super T1, ? super T2, Option<T3>> ts3;
+        private final Function3<? super T1, ? super T2, ? super T3, Option<T4>> ts4;
 
-        private ForLazy4Option(Option<T1> ts1, Function1<T1, Option<T2>> ts2, Function2<T1, T2, Option<T3>> ts3, Function3<T1, T2, T3, Option<T4>> ts4) {
+        private ForLazy4Option(Option<T1> ts1, Function1<? super T1, Option<T2>> ts2, Function2<? super T1, ? super T2, Option<T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Option<T4>> ts4) {
             this.ts1 = ts1;
             this.ts2 = ts2;
             this.ts3 = ts3;
@@ -7236,12 +7236,12 @@ public <R> Option<R> yield(Function4<? super T1, ? super T2, ? super T3, ? super
     public static class ForLazy5Option<T1, T2, T3, T4, T5> {
 
         private final Option<T1> ts1;
-        private final Function1<T1, Option<T2>> ts2;
-        private final Function2<T1, T2, Option<T3>> ts3;
-        private final Function3<T1, T2, T3, Option<T4>> ts4;
-        private final Function4<T1, T2, T3, T4, Option<T5>> ts5;
+        private final Function1<? super T1, Option<T2>> ts2;
+        private final Function2<? super T1, ? super T2, Option<T3>> ts3;
+        private final Function3<? super T1, ? super T2, ? super T3, Option<T4>> ts4;
+        private final Function4<? super T1, ? super T2, ? super T3, ? super T4, Option<T5>> ts5;
 
-        private ForLazy5Option(Option<T1> ts1, Function1<T1, Option<T2>> ts2, Function2<T1, T2, Option<T3>> ts3, Function3<T1, T2, T3, Option<T4>> ts4, Function4<T1, T2, T3, T4, Option<T5>> ts5) {
+        private ForLazy5Option(Option<T1> ts1, Function1<? super T1, Option<T2>> ts2, Function2<? super T1, ? super T2, Option<T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Option<T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, Option<T5>> ts5) {
             this.ts1 = ts1;
             this.ts2 = ts2;
             this.ts3 = ts3;
@@ -7292,13 +7292,13 @@ public <R> Option<R> yield(Function5<? super T1, ? super T2, ? super T3, ? super
     public static class ForLazy6Option<T1, T2, T3, T4, T5, T6> {
 
         private final Option<T1> ts1;
-        private final Function1<T1, Option<T2>> ts2;
-        private final Function2<T1, T2, Option<T3>> ts3;
-        private final Function3<T1, T2, T3, Option<T4>> ts4;
-        private final Function4<T1, T2, T3, T4, Option<T5>> ts5;
-        private final Function5<T1, T2, T3, T4, T5, Option<T6>> ts6;
+        private final Function1<? super T1, Option<T2>> ts2;
+        private final Function2<? super T1, ? super T2, Option<T3>> ts3;
+        private final Function3<? super T1, ? super T2, ? super T3, Option<T4>> ts4;
+        private final Function4<? super T1, ? super T2, ? super T3, ? super T4, Option<T5>> ts5;
+        private final Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Option<T6>> ts6;
 
-        private ForLazy6Option(Option<T1> ts1, Function1<T1, Option<T2>> ts2, Function2<T1, T2, Option<T3>> ts3, Function3<T1, T2, T3, Option<T4>> ts4, Function4<T1, T2, T3, T4, Option<T5>> ts5, Function5<T1, T2, T3, T4, T5, Option<T6>> ts6) {
+        private ForLazy6Option(Option<T1> ts1, Function1<? super T1, Option<T2>> ts2, Function2<? super T1, ? super T2, Option<T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Option<T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, Option<T5>> ts5, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Option<T6>> ts6) {
             this.ts1 = ts1;
             this.ts2 = ts2;
             this.ts3 = ts3;
@@ -7353,14 +7353,14 @@ public <R> Option<R> yield(Function6<? super T1, ? super T2, ? super T3, ? super
     public static class ForLazy7Option<T1, T2, T3, T4, T5, T6, T7> {
 
         private final Option<T1> ts1;
-        private final Function1<T1, Option<T2>> ts2;
-        private final Function2<T1, T2, Option<T3>> ts3;
-        private final Function3<T1, T2, T3, Option<T4>> ts4;
-        private final Function4<T1, T2, T3, T4, Option<T5>> ts5;
-        private final Function5<T1, T2, T3, T4, T5, Option<T6>> ts6;
-        private final Function6<T1, T2, T3, T4, T5, T6, Option<T7>> ts7;
-
-        private ForLazy7Option(Option<T1> ts1, Function1<T1, Option<T2>> ts2, Function2<T1, T2, Option<T3>> ts3, Function3<T1, T2, T3, Option<T4>> ts4, Function4<T1, T2, T3, T4, Option<T5>> ts5, Function5<T1, T2, T3, T4, T5, Option<T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, Option<T7>> ts7) {
+        private final Function1<? super T1, Option<T2>> ts2;
+        private final Function2<? super T1, ? super T2, Option<T3>> ts3;
+        private final Function3<? super T1, ? super T2, ? super T3, Option<T4>> ts4;
+        private final Function4<? super T1, ? super T2, ? super T3, ? super T4, Option<T5>> ts5;
+        private final Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Option<T6>> ts6;
+        private final Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, Option<T7>> ts7;
+
+        private ForLazy7Option(Option<T1> ts1, Function1<? super T1, Option<T2>> ts2, Function2<? super T1, ? super T2, Option<T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Option<T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, Option<T5>> ts5, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Option<T6>> ts6, Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, Option<T7>> ts7) {
             this.ts1 = ts1;
             this.ts2 = ts2;
             this.ts3 = ts3;
@@ -7419,15 +7419,15 @@ public <R> Option<R> yield(Function7<? super T1, ? super T2, ? super T3, ? super
     public static class ForLazy8Option<T1, T2, T3, T4, T5, T6, T7, T8> {
 
         private final Option<T1> ts1;
-        private final Function1<T1, Option<T2>> ts2;
-        private final Function2<T1, T2, Option<T3>> ts3;
-        private final Function3<T1, T2, T3, Option<T4>> ts4;
-        private final Function4<T1, T2, T3, T4, Option<T5>> ts5;
-        private final Function5<T1, T2, T3, T4, T5, Option<T6>> ts6;
-        private final Function6<T1, T2, T3, T4, T5, T6, Option<T7>> ts7;
-        private final Function7<T1, T2, T3, T4, T5, T6, T7, Option<T8>> ts8;
-
-        private ForLazy8Option(Option<T1> ts1, Function1<T1, Option<T2>> ts2, Function2<T1, T2, Option<T3>> ts3, Function3<T1, T2, T3, Option<T4>> ts4, Function4<T1, T2, T3, T4, Option<T5>> ts5, Function5<T1, T2, T3, T4, T5, Option<T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, Option<T7>> ts7, Function7<T1, T2, T3, T4, T5, T6, T7, Option<T8>> ts8) {
+        private final Function1<? super T1, Option<T2>> ts2;
+        private final Function2<? super T1, ? super T2, Option<T3>> ts3;
+        private final Function3<? super T1, ? super T2, ? super T3, Option<T4>> ts4;
+        private final Function4<? super T1, ? super T2, ? super T3, ? super T4, Option<T5>> ts5;
+        private final Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Option<T6>> ts6;
+        private final Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, Option<T7>> ts7;
+        private final Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, Option<T8>> ts8;
+
+        private ForLazy8Option(Option<T1> ts1, Function1<? super T1, Option<T2>> ts2, Function2<? super T1, ? super T2, Option<T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Option<T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, Option<T5>> ts5, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Option<T6>> ts6, Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, Option<T7>> ts7, Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, Option<T8>> ts8) {
             this.ts1 = ts1;
             this.ts2 = ts2;
             this.ts3 = ts3;
@@ -7483,9 +7483,9 @@ public <R> Option<R> yield(Function8<? super T1, ? super T2, ? super T3, ? super
     public static class ForLazy2Future<T1, T2> {
 
         private final Future<T1> ts1;
-        private final Function1<T1, Future<T2>> ts2;
+        private final Function1<? super T1, Future<T2>> ts2;
 
-        private ForLazy2Future(Future<T1> ts1, Function1<T1, Future<T2>> ts2) {
+        private ForLazy2Future(Future<T1> ts1, Function1<? super T1, Future<T2>> ts2) {
             this.ts1 = ts1;
             this.ts2 = ts2;
         }
@@ -7524,10 +7524,10 @@ public <R> Future<R> yield(BiFunction<? super T1, ? super T2, ? extends R> f) {
     public static class ForLazy3Future<T1, T2, T3> {
 
         private final Future<T1> ts1;
-        private final Function1<T1, Future<T2>> ts2;
-        private final Function2<T1, T2, Future<T3>> ts3;
+        private final Function1<? super T1, Future<T2>> ts2;
+        private final Function2<? super T1, ? super T2, Future<T3>> ts3;
 
-        private ForLazy3Future(Future<T1> ts1, Function1<T1, Future<T2>> ts2, Function2<T1, T2, Future<T3>> ts3) {
+        private ForLazy3Future(Future<T1> ts1, Function1<? super T1, Future<T2>> ts2, Function2<? super T1, ? super T2, Future<T3>> ts3) {
             this.ts1 = ts1;
             this.ts2 = ts2;
             this.ts3 = ts3;
@@ -7570,11 +7570,11 @@ public <R> Future<R> yield(Function3<? super T1, ? super T2, ? super T3, ? exten
     public static class ForLazy4Future<T1, T2, T3, T4> {
 
         private final Future<T1> ts1;
-        private final Function1<T1, Future<T2>> ts2;
-        private final Function2<T1, T2, Future<T3>> ts3;
-        private final Function3<T1, T2, T3, Future<T4>> ts4;
+        private final Function1<? super T1, Future<T2>> ts2;
+        private final Function2<? super T1, ? super T2, Future<T3>> ts3;
+        private final Function3<? super T1, ? super T2, ? super T3, Future<T4>> ts4;
 
-        private ForLazy4Future(Future<T1> ts1, Function1<T1, Future<T2>> ts2, Function2<T1, T2, Future<T3>> ts3, Function3<T1, T2, T3, Future<T4>> ts4) {
+        private ForLazy4Future(Future<T1> ts1, Function1<? super T1, Future<T2>> ts2, Function2<? super T1, ? super T2, Future<T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Future<T4>> ts4) {
             this.ts1 = ts1;
             this.ts2 = ts2;
             this.ts3 = ts3;
@@ -7621,12 +7621,12 @@ public <R> Future<R> yield(Function4<? super T1, ? super T2, ? super T3, ? super
     public static class ForLazy5Future<T1, T2, T3, T4, T5> {
 
         private final Future<T1> ts1;
-        private final Function1<T1, Future<T2>> ts2;
-        private final Function2<T1, T2, Future<T3>> ts3;
-        private final Function3<T1, T2, T3, Future<T4>> ts4;
-        private final Function4<T1, T2, T3, T4, Future<T5>> ts5;
+        private final Function1<? super T1, Future<T2>> ts2;
+        private final Function2<? super T1, ? super T2, Future<T3>> ts3;
+        private final Function3<? super T1, ? super T2, ? super T3, Future<T4>> ts4;
+        private final Function4<? super T1, ? super T2, ? super T3, ? super T4, Future<T5>> ts5;
 
-        private ForLazy5Future(Future<T1> ts1, Function1<T1, Future<T2>> ts2, Function2<T1, T2, Future<T3>> ts3, Function3<T1, T2, T3, Future<T4>> ts4, Function4<T1, T2, T3, T4, Future<T5>> ts5) {
+        private ForLazy5Future(Future<T1> ts1, Function1<? super T1, Future<T2>> ts2, Function2<? super T1, ? super T2, Future<T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Future<T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, Future<T5>> ts5) {
             this.ts1 = ts1;
             this.ts2 = ts2;
             this.ts3 = ts3;
@@ -7677,13 +7677,13 @@ public <R> Future<R> yield(Function5<? super T1, ? super T2, ? super T3, ? super
     public static class ForLazy6Future<T1, T2, T3, T4, T5, T6> {
 
         private final Future<T1> ts1;
-        private final Function1<T1, Future<T2>> ts2;
-        private final Function2<T1, T2, Future<T3>> ts3;
-        private final Function3<T1, T2, T3, Future<T4>> ts4;
-        private final Function4<T1, T2, T3, T4, Future<T5>> ts5;
-        private final Function5<T1, T2, T3, T4, T5, Future<T6>> ts6;
+        private final Function1<? super T1, Future<T2>> ts2;
+        private final Function2<? super T1, ? super T2, Future<T3>> ts3;
+        private final Function3<? super T1, ? super T2, ? super T3, Future<T4>> ts4;
+        private final Function4<? super T1, ? super T2, ? super T3, ? super T4, Future<T5>> ts5;
+        private final Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Future<T6>> ts6;
 
-        private ForLazy6Future(Future<T1> ts1, Function1<T1, Future<T2>> ts2, Function2<T1, T2, Future<T3>> ts3, Function3<T1, T2, T3, Future<T4>> ts4, Function4<T1, T2, T3, T4, Future<T5>> ts5, Function5<T1, T2, T3, T4, T5, Future<T6>> ts6) {
+        private ForLazy6Future(Future<T1> ts1, Function1<? super T1, Future<T2>> ts2, Function2<? super T1, ? super T2, Future<T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Future<T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, Future<T5>> ts5, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Future<T6>> ts6) {
             this.ts1 = ts1;
             this.ts2 = ts2;
             this.ts3 = ts3;
@@ -7738,14 +7738,14 @@ public <R> Future<R> yield(Function6<? super T1, ? super T2, ? super T3, ? super
     public static class ForLazy7Future<T1, T2, T3, T4, T5, T6, T7> {
 
         private final Future<T1> ts1;
-        private final Function1<T1, Future<T2>> ts2;
-        private final Function2<T1, T2, Future<T3>> ts3;
-        private final Function3<T1, T2, T3, Future<T4>> ts4;
-        private final Function4<T1, T2, T3, T4, Future<T5>> ts5;
-        private final Function5<T1, T2, T3, T4, T5, Future<T6>> ts6;
-        private final Function6<T1, T2, T3, T4, T5, T6, Future<T7>> ts7;
-
-        private ForLazy7Future(Future<T1> ts1, Function1<T1, Future<T2>> ts2, Function2<T1, T2, Future<T3>> ts3, Function3<T1, T2, T3, Future<T4>> ts4, Function4<T1, T2, T3, T4, Future<T5>> ts5, Function5<T1, T2, T3, T4, T5, Future<T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, Future<T7>> ts7) {
+        private final Function1<? super T1, Future<T2>> ts2;
+        private final Function2<? super T1, ? super T2, Future<T3>> ts3;
+        private final Function3<? super T1, ? super T2, ? super T3, Future<T4>> ts4;
+        private final Function4<? super T1, ? super T2, ? super T3, ? super T4, Future<T5>> ts5;
+        private final Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Future<T6>> ts6;
+        private final Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, Future<T7>> ts7;
+
+        private ForLazy7Future(Future<T1> ts1, Function1<? super T1, Future<T2>> ts2, Function2<? super T1, ? super T2, Future<T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Future<T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, Future<T5>> ts5, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Future<T6>> ts6, Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, Future<T7>> ts7) {
             this.ts1 = ts1;
             this.ts2 = ts2;
             this.ts3 = ts3;
@@ -7804,15 +7804,15 @@ public <R> Future<R> yield(Function7<? super T1, ? super T2, ? super T3, ? super
     public static class ForLazy8Future<T1, T2, T3, T4, T5, T6, T7, T8> {
 
         private final Future<T1> ts1;
-        private final Function1<T1, Future<T2>> ts2;
-        private final Function2<T1, T2, Future<T3>> ts3;
-        private final Function3<T1, T2, T3, Future<T4>> ts4;
-        private final Function4<T1, T2, T3, T4, Future<T5>> ts5;
-        private final Function5<T1, T2, T3, T4, T5, Future<T6>> ts6;
-        private final Function6<T1, T2, T3, T4, T5, T6, Future<T7>> ts7;
-        private final Function7<T1, T2, T3, T4, T5, T6, T7, Future<T8>> ts8;
-
-        private ForLazy8Future(Future<T1> ts1, Function1<T1, Future<T2>> ts2, Function2<T1, T2, Future<T3>> ts3, Function3<T1, T2, T3, Future<T4>> ts4, Function4<T1, T2, T3, T4, Future<T5>> ts5, Function5<T1, T2, T3, T4, T5, Future<T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, Future<T7>> ts7, Function7<T1, T2, T3, T4, T5, T6, T7, Future<T8>> ts8) {
+        private final Function1<? super T1, Future<T2>> ts2;
+        private final Function2<? super T1, ? super T2, Future<T3>> ts3;
+        private final Function3<? super T1, ? super T2, ? super T3, Future<T4>> ts4;
+        private final Function4<? super T1, ? super T2, ? super T3, ? super T4, Future<T5>> ts5;
+        private final Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Future<T6>> ts6;
+        private final Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, Future<T7>> ts7;
+        private final Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, Future<T8>> ts8;
+
+        private ForLazy8Future(Future<T1> ts1, Function1<? super T1, Future<T2>> ts2, Function2<? super T1, ? super T2, Future<T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Future<T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, Future<T5>> ts5, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Future<T6>> ts6, Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, Future<T7>> ts7, Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, Future<T8>> ts8) {
             this.ts1 = ts1;
             this.ts2 = ts2;
             this.ts3 = ts3;
@@ -7868,9 +7868,9 @@ public <R> Future<R> yield(Function8<? super T1, ? super T2, ? super T3, ? super
     public static class ForLazy2Try<T1, T2> {
 
         private final Try<T1> ts1;
-        private final Function1<T1, Try<T2>> ts2;
+        private final Function1<? super T1, Try<T2>> ts2;
 
-        private ForLazy2Try(Try<T1> ts1, Function1<T1, Try<T2>> ts2) {
+        private ForLazy2Try(Try<T1> ts1, Function1<? super T1, Try<T2>> ts2) {
             this.ts1 = ts1;
             this.ts2 = ts2;
         }
@@ -7909,10 +7909,10 @@ public <R> Try<R> yield(BiFunction<? super T1, ? super T2, ? extends R> f) {
     public static class ForLazy3Try<T1, T2, T3> {
 
         private final Try<T1> ts1;
-        private final Function1<T1, Try<T2>> ts2;
-        private final Function2<T1, T2, Try<T3>> ts3;
+        private final Function1<? super T1, Try<T2>> ts2;
+        private final Function2<? super T1, ? super T2, Try<T3>> ts3;
 
-        private ForLazy3Try(Try<T1> ts1, Function1<T1, Try<T2>> ts2, Function2<T1, T2, Try<T3>> ts3) {
+        private ForLazy3Try(Try<T1> ts1, Function1<? super T1, Try<T2>> ts2, Function2<? super T1, ? super T2, Try<T3>> ts3) {
             this.ts1 = ts1;
             this.ts2 = ts2;
             this.ts3 = ts3;
@@ -7955,11 +7955,11 @@ public <R> Try<R> yield(Function3<? super T1, ? super T2, ? super T3, ? extends
     public static class ForLazy4Try<T1, T2, T3, T4> {
 
         private final Try<T1> ts1;
-        private final Function1<T1, Try<T2>> ts2;
-        private final Function2<T1, T2, Try<T3>> ts3;
-        private final Function3<T1, T2, T3, Try<T4>> ts4;
+        private final Function1<? super T1, Try<T2>> ts2;
+        private final Function2<? super T1, ? super T2, Try<T3>> ts3;
+        private final Function3<? super T1, ? super T2, ? super T3, Try<T4>> ts4;
 
-        private ForLazy4Try(Try<T1> ts1, Function1<T1, Try<T2>> ts2, Function2<T1, T2, Try<T3>> ts3, Function3<T1, T2, T3, Try<T4>> ts4) {
+        private ForLazy4Try(Try<T1> ts1, Function1<? super T1, Try<T2>> ts2, Function2<? super T1, ? super T2, Try<T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Try<T4>> ts4) {
             this.ts1 = ts1;
             this.ts2 = ts2;
             this.ts3 = ts3;
@@ -8006,12 +8006,12 @@ public <R> Try<R> yield(Function4<? super T1, ? super T2, ? super T3, ? super T4
     public static class ForLazy5Try<T1, T2, T3, T4, T5> {
 
         private final Try<T1> ts1;
-        private final Function1<T1, Try<T2>> ts2;
-        private final Function2<T1, T2, Try<T3>> ts3;
-        private final Function3<T1, T2, T3, Try<T4>> ts4;
-        private final Function4<T1, T2, T3, T4, Try<T5>> ts5;
+        private final Function1<? super T1, Try<T2>> ts2;
+        private final Function2<? super T1, ? super T2, Try<T3>> ts3;
+        private final Function3<? super T1, ? super T2, ? super T3, Try<T4>> ts4;
+        private final Function4<? super T1, ? super T2, ? super T3, ? super T4, Try<T5>> ts5;
 
-        private ForLazy5Try(Try<T1> ts1, Function1<T1, Try<T2>> ts2, Function2<T1, T2, Try<T3>> ts3, Function3<T1, T2, T3, Try<T4>> ts4, Function4<T1, T2, T3, T4, Try<T5>> ts5) {
+        private ForLazy5Try(Try<T1> ts1, Function1<? super T1, Try<T2>> ts2, Function2<? super T1, ? super T2, Try<T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Try<T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, Try<T5>> ts5) {
             this.ts1 = ts1;
             this.ts2 = ts2;
             this.ts3 = ts3;
@@ -8062,13 +8062,13 @@ public <R> Try<R> yield(Function5<? super T1, ? super T2, ? super T3, ? super T4
     public static class ForLazy6Try<T1, T2, T3, T4, T5, T6> {
 
         private final Try<T1> ts1;
-        private final Function1<T1, Try<T2>> ts2;
-        private final Function2<T1, T2, Try<T3>> ts3;
-        private final Function3<T1, T2, T3, Try<T4>> ts4;
-        private final Function4<T1, T2, T3, T4, Try<T5>> ts5;
-        private final Function5<T1, T2, T3, T4, T5, Try<T6>> ts6;
+        private final Function1<? super T1, Try<T2>> ts2;
+        private final Function2<? super T1, ? super T2, Try<T3>> ts3;
+        private final Function3<? super T1, ? super T2, ? super T3, Try<T4>> ts4;
+        private final Function4<? super T1, ? super T2, ? super T3, ? super T4, Try<T5>> ts5;
+        private final Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Try<T6>> ts6;
 
-        private ForLazy6Try(Try<T1> ts1, Function1<T1, Try<T2>> ts2, Function2<T1, T2, Try<T3>> ts3, Function3<T1, T2, T3, Try<T4>> ts4, Function4<T1, T2, T3, T4, Try<T5>> ts5, Function5<T1, T2, T3, T4, T5, Try<T6>> ts6) {
+        private ForLazy6Try(Try<T1> ts1, Function1<? super T1, Try<T2>> ts2, Function2<? super T1, ? super T2, Try<T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Try<T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, Try<T5>> ts5, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Try<T6>> ts6) {
             this.ts1 = ts1;
             this.ts2 = ts2;
             this.ts3 = ts3;
@@ -8123,14 +8123,14 @@ public <R> Try<R> yield(Function6<? super T1, ? super T2, ? super T3, ? super T4
     public static class ForLazy7Try<T1, T2, T3, T4, T5, T6, T7> {
 
         private final Try<T1> ts1;
-        private final Function1<T1, Try<T2>> ts2;
-        private final Function2<T1, T2, Try<T3>> ts3;
-        private final Function3<T1, T2, T3, Try<T4>> ts4;
-        private final Function4<T1, T2, T3, T4, Try<T5>> ts5;
-        private final Function5<T1, T2, T3, T4, T5, Try<T6>> ts6;
-        private final Function6<T1, T2, T3, T4, T5, T6, Try<T7>> ts7;
-
-        private ForLazy7Try(Try<T1> ts1, Function1<T1, Try<T2>> ts2, Function2<T1, T2, Try<T3>> ts3, Function3<T1, T2, T3, Try<T4>> ts4, Function4<T1, T2, T3, T4, Try<T5>> ts5, Function5<T1, T2, T3, T4, T5, Try<T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, Try<T7>> ts7) {
+        private final Function1<? super T1, Try<T2>> ts2;
+        private final Function2<? super T1, ? super T2, Try<T3>> ts3;
+        private final Function3<? super T1, ? super T2, ? super T3, Try<T4>> ts4;
+        private final Function4<? super T1, ? super T2, ? super T3, ? super T4, Try<T5>> ts5;
+        private final Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Try<T6>> ts6;
+        private final Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, Try<T7>> ts7;
+
+        private ForLazy7Try(Try<T1> ts1, Function1<? super T1, Try<T2>> ts2, Function2<? super T1, ? super T2, Try<T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Try<T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, Try<T5>> ts5, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Try<T6>> ts6, Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, Try<T7>> ts7) {
             this.ts1 = ts1;
             this.ts2 = ts2;
             this.ts3 = ts3;
@@ -8189,15 +8189,15 @@ public <R> Try<R> yield(Function7<? super T1, ? super T2, ? super T3, ? super T4
     public static class ForLazy8Try<T1, T2, T3, T4, T5, T6, T7, T8> {
 
         private final Try<T1> ts1;
-        private final Function1<T1, Try<T2>> ts2;
-        private final Function2<T1, T2, Try<T3>> ts3;
-        private final Function3<T1, T2, T3, Try<T4>> ts4;
-        private final Function4<T1, T2, T3, T4, Try<T5>> ts5;
-        private final Function5<T1, T2, T3, T4, T5, Try<T6>> ts6;
-        private final Function6<T1, T2, T3, T4, T5, T6, Try<T7>> ts7;
-        private final Function7<T1, T2, T3, T4, T5, T6, T7, Try<T8>> ts8;
-
-        private ForLazy8Try(Try<T1> ts1, Function1<T1, Try<T2>> ts2, Function2<T1, T2, Try<T3>> ts3, Function3<T1, T2, T3, Try<T4>> ts4, Function4<T1, T2, T3, T4, Try<T5>> ts5, Function5<T1, T2, T3, T4, T5, Try<T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, Try<T7>> ts7, Function7<T1, T2, T3, T4, T5, T6, T7, Try<T8>> ts8) {
+        private final Function1<? super T1, Try<T2>> ts2;
+        private final Function2<? super T1, ? super T2, Try<T3>> ts3;
+        private final Function3<? super T1, ? super T2, ? super T3, Try<T4>> ts4;
+        private final Function4<? super T1, ? super T2, ? super T3, ? super T4, Try<T5>> ts5;
+        private final Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Try<T6>> ts6;
+        private final Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, Try<T7>> ts7;
+        private final Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, Try<T8>> ts8;
+
+        private ForLazy8Try(Try<T1> ts1, Function1<? super T1, Try<T2>> ts2, Function2<? super T1, ? super T2, Try<T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Try<T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, Try<T5>> ts5, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Try<T6>> ts6, Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, Try<T7>> ts7, Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, Try<T8>> ts8) {
             this.ts1 = ts1;
             this.ts2 = ts2;
             this.ts3 = ts3;
@@ -8253,9 +8253,9 @@ public <R> Try<R> yield(Function8<? super T1, ? super T2, ? super T3, ? super T4
     public static class ForLazy2List<T1, T2> {
 
         private final List<T1> ts1;
-        private final Function1<T1, List<T2>> ts2;
+        private final Function1<? super T1, List<T2>> ts2;
 
-        private ForLazy2List(List<T1> ts1, Function1<T1, List<T2>> ts2) {
+        private ForLazy2List(List<T1> ts1, Function1<? super T1, List<T2>> ts2) {
             this.ts1 = ts1;
             this.ts2 = ts2;
         }
@@ -8294,10 +8294,10 @@ public <R> List<R> yield(BiFunction<? super T1, ? super T2, ? extends R> f) {
     public static class ForLazy3List<T1, T2, T3> {
 
         private final List<T1> ts1;
-        private final Function1<T1, List<T2>> ts2;
-        private final Function2<T1, T2, List<T3>> ts3;
+        private final Function1<? super T1, List<T2>> ts2;
+        private final Function2<? super T1, ? super T2, List<T3>> ts3;
 
-        private ForLazy3List(List<T1> ts1, Function1<T1, List<T2>> ts2, Function2<T1, T2, List<T3>> ts3) {
+        private ForLazy3List(List<T1> ts1, Function1<? super T1, List<T2>> ts2, Function2<? super T1, ? super T2, List<T3>> ts3) {
             this.ts1 = ts1;
             this.ts2 = ts2;
             this.ts3 = ts3;
@@ -8340,11 +8340,11 @@ public <R> List<R> yield(Function3<? super T1, ? super T2, ? super T3, ? extends
     public static class ForLazy4List<T1, T2, T3, T4> {
 
         private final List<T1> ts1;
-        private final Function1<T1, List<T2>> ts2;
-        private final Function2<T1, T2, List<T3>> ts3;
-        private final Function3<T1, T2, T3, List<T4>> ts4;
+        private final Function1<? super T1, List<T2>> ts2;
+        private final Function2<? super T1, ? super T2, List<T3>> ts3;
+        private final Function3<? super T1, ? super T2, ? super T3, List<T4>> ts4;
 
-        private ForLazy4List(List<T1> ts1, Function1<T1, List<T2>> ts2, Function2<T1, T2, List<T3>> ts3, Function3<T1, T2, T3, List<T4>> ts4) {
+        private ForLazy4List(List<T1> ts1, Function1<? super T1, List<T2>> ts2, Function2<? super T1, ? super T2, List<T3>> ts3, Function3<? super T1, ? super T2, ? super T3, List<T4>> ts4) {
             this.ts1 = ts1;
             this.ts2 = ts2;
             this.ts3 = ts3;
@@ -8391,12 +8391,12 @@ public <R> List<R> yield(Function4<? super T1, ? super T2, ? super T3, ? super T
     public static class ForLazy5List<T1, T2, T3, T4, T5> {
 
         private final List<T1> ts1;
-        private final Function1<T1, List<T2>> ts2;
-        private final Function2<T1, T2, List<T3>> ts3;
-        private final Function3<T1, T2, T3, List<T4>> ts4;
-        private final Function4<T1, T2, T3, T4, List<T5>> ts5;
+        private final Function1<? super T1, List<T2>> ts2;
+        private final Function2<? super T1, ? super T2, List<T3>> ts3;
+        private final Function3<? super T1, ? super T2, ? super T3, List<T4>> ts4;
+        private final Function4<? super T1, ? super T2, ? super T3, ? super T4, List<T5>> ts5;
 
-        private ForLazy5List(List<T1> ts1, Function1<T1, List<T2>> ts2, Function2<T1, T2, List<T3>> ts3, Function3<T1, T2, T3, List<T4>> ts4, Function4<T1, T2, T3, T4, List<T5>> ts5) {
+        private ForLazy5List(List<T1> ts1, Function1<? super T1, List<T2>> ts2, Function2<? super T1, ? super T2, List<T3>> ts3, Function3<? super T1, ? super T2, ? super T3, List<T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, List<T5>> ts5) {
             this.ts1 = ts1;
             this.ts2 = ts2;
             this.ts3 = ts3;
@@ -8447,13 +8447,13 @@ public <R> List<R> yield(Function5<? super T1, ? super T2, ? super T3, ? super T
     public static class ForLazy6List<T1, T2, T3, T4, T5, T6> {
 
         private final List<T1> ts1;
-        private final Function1<T1, List<T2>> ts2;
-        private final Function2<T1, T2, List<T3>> ts3;
-        private final Function3<T1, T2, T3, List<T4>> ts4;
-        private final Function4<T1, T2, T3, T4, List<T5>> ts5;
-        private final Function5<T1, T2, T3, T4, T5, List<T6>> ts6;
+        private final Function1<? super T1, List<T2>> ts2;
+        private final Function2<? super T1, ? super T2, List<T3>> ts3;
+        private final Function3<? super T1, ? super T2, ? super T3, List<T4>> ts4;
+        private final Function4<? super T1, ? super T2, ? super T3, ? super T4, List<T5>> ts5;
+        private final Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, List<T6>> ts6;
 
-        private ForLazy6List(List<T1> ts1, Function1<T1, List<T2>> ts2, Function2<T1, T2, List<T3>> ts3, Function3<T1, T2, T3, List<T4>> ts4, Function4<T1, T2, T3, T4, List<T5>> ts5, Function5<T1, T2, T3, T4, T5, List<T6>> ts6) {
+        private ForLazy6List(List<T1> ts1, Function1<? super T1, List<T2>> ts2, Function2<? super T1, ? super T2, List<T3>> ts3, Function3<? super T1, ? super T2, ? super T3, List<T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, List<T5>> ts5, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, List<T6>> ts6) {
             this.ts1 = ts1;
             this.ts2 = ts2;
             this.ts3 = ts3;
@@ -8508,14 +8508,14 @@ public <R> List<R> yield(Function6<? super T1, ? super T2, ? super T3, ? super T
     public static class ForLazy7List<T1, T2, T3, T4, T5, T6, T7> {
 
         private final List<T1> ts1;
-        private final Function1<T1, List<T2>> ts2;
-        private final Function2<T1, T2, List<T3>> ts3;
-        private final Function3<T1, T2, T3, List<T4>> ts4;
-        private final Function4<T1, T2, T3, T4, List<T5>> ts5;
-        private final Function5<T1, T2, T3, T4, T5, List<T6>> ts6;
-        private final Function6<T1, T2, T3, T4, T5, T6, List<T7>> ts7;
-
-        private ForLazy7List(List<T1> ts1, Function1<T1, List<T2>> ts2, Function2<T1, T2, List<T3>> ts3, Function3<T1, T2, T3, List<T4>> ts4, Function4<T1, T2, T3, T4, List<T5>> ts5, Function5<T1, T2, T3, T4, T5, List<T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, List<T7>> ts7) {
+        private final Function1<? super T1, List<T2>> ts2;
+        private final Function2<? super T1, ? super T2, List<T3>> ts3;
+        private final Function3<? super T1, ? super T2, ? super T3, List<T4>> ts4;
+        private final Function4<? super T1, ? super T2, ? super T3, ? super T4, List<T5>> ts5;
+        private final Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, List<T6>> ts6;
+        private final Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, List<T7>> ts7;
+
+        private ForLazy7List(List<T1> ts1, Function1<? super T1, List<T2>> ts2, Function2<? super T1, ? super T2, List<T3>> ts3, Function3<? super T1, ? super T2, ? super T3, List<T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, List<T5>> ts5, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, List<T6>> ts6, Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, List<T7>> ts7) {
             this.ts1 = ts1;
             this.ts2 = ts2;
             this.ts3 = ts3;
@@ -8574,15 +8574,15 @@ public <R> List<R> yield(Function7<? super T1, ? super T2, ? super T3, ? super T
     public static class ForLazy8List<T1, T2, T3, T4, T5, T6, T7, T8> {
 
         private final List<T1> ts1;
-        private final Function1<T1, List<T2>> ts2;
-        private final Function2<T1, T2, List<T3>> ts3;
-        private final Function3<T1, T2, T3, List<T4>> ts4;
-        private final Function4<T1, T2, T3, T4, List<T5>> ts5;
-        private final Function5<T1, T2, T3, T4, T5, List<T6>> ts6;
-        private final Function6<T1, T2, T3, T4, T5, T6, List<T7>> ts7;
-        private final Function7<T1, T2, T3, T4, T5, T6, T7, List<T8>> ts8;
-
-        private ForLazy8List(List<T1> ts1, Function1<T1, List<T2>> ts2, Function2<T1, T2, List<T3>> ts3, Function3<T1, T2, T3, List<T4>> ts4, Function4<T1, T2, T3, T4, List<T5>> ts5, Function5<T1, T2, T3, T4, T5, List<T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, List<T7>> ts7, Function7<T1, T2, T3, T4, T5, T6, T7, List<T8>> ts8) {
+        private final Function1<? super T1, List<T2>> ts2;
+        private final Function2<? super T1, ? super T2, List<T3>> ts3;
+        private final Function3<? super T1, ? super T2, ? super T3, List<T4>> ts4;
+        private final Function4<? super T1, ? super T2, ? super T3, ? super T4, List<T5>> ts5;
+        private final Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, List<T6>> ts6;
+        private final Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, List<T7>> ts7;
+        private final Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, List<T8>> ts8;
+
+        private ForLazy8List(List<T1> ts1, Function1<? super T1, List<T2>> ts2, Function2<? super T1, ? super T2, List<T3>> ts3, Function3<? super T1, ? super T2, ? super T3, List<T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, List<T5>> ts5, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, List<T6>> ts6, Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, List<T7>> ts7, Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, List<T8>> ts8) {
             this.ts1 = ts1;
             this.ts2 = ts2;
             this.ts3 = ts3;
@@ -8638,9 +8638,9 @@ public <R> List<R> yield(Function8<? super T1, ? super T2, ? super T3, ? super T
     public static class ForLazy2Either<L, T1, T2> {
 
         private final Either<L, T1> ts1;
-        private final Function1<T1, Either<L, T2>> ts2;
+        private final Function1<? super T1, Either<L, T2>> ts2;
 
-        private ForLazy2Either(Either<L, T1> ts1, Function1<T1, Either<L, T2>> ts2) {
+        private ForLazy2Either(Either<L, T1> ts1, Function1<? super T1, Either<L, T2>> ts2) {
             this.ts1 = ts1;
             this.ts2 = ts2;
         }
@@ -8679,10 +8679,10 @@ public <R> Either<L, R> yield(BiFunction<? super T1, ? super T2, ? extends R> f)
     public static class ForLazy3Either<L, T1, T2, T3> {
 
         private final Either<L, T1> ts1;
-        private final Function1<T1, Either<L, T2>> ts2;
-        private final Function2<T1, T2, Either<L, T3>> ts3;
+        private final Function1<? super T1, Either<L, T2>> ts2;
+        private final Function2<? super T1, ? super T2, Either<L, T3>> ts3;
 
-        private ForLazy3Either(Either<L, T1> ts1, Function1<T1, Either<L, T2>> ts2, Function2<T1, T2, Either<L, T3>> ts3) {
+        private ForLazy3Either(Either<L, T1> ts1, Function1<? super T1, Either<L, T2>> ts2, Function2<? super T1, ? super T2, Either<L, T3>> ts3) {
             this.ts1 = ts1;
             this.ts2 = ts2;
             this.ts3 = ts3;
@@ -8725,11 +8725,11 @@ public <R> Either<L, R> yield(Function3<? super T1, ? super T2, ? super T3, ? ex
     public static class ForLazy4Either<L, T1, T2, T3, T4> {
 
         private final Either<L, T1> ts1;
-        private final Function1<T1, Either<L, T2>> ts2;
-        private final Function2<T1, T2, Either<L, T3>> ts3;
-        private final Function3<T1, T2, T3, Either<L, T4>> ts4;
+        private final Function1<? super T1, Either<L, T2>> ts2;
+        private final Function2<? super T1, ? super T2, Either<L, T3>> ts3;
+        private final Function3<? super T1, ? super T2, ? super T3, Either<L, T4>> ts4;
 
-        private ForLazy4Either(Either<L, T1> ts1, Function1<T1, Either<L, T2>> ts2, Function2<T1, T2, Either<L, T3>> ts3, Function3<T1, T2, T3, Either<L, T4>> ts4) {
+        private ForLazy4Either(Either<L, T1> ts1, Function1<? super T1, Either<L, T2>> ts2, Function2<? super T1, ? super T2, Either<L, T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Either<L, T4>> ts4) {
             this.ts1 = ts1;
             this.ts2 = ts2;
             this.ts3 = ts3;
@@ -8776,12 +8776,12 @@ public <R> Either<L, R> yield(Function4<? super T1, ? super T2, ? super T3, ? su
     public static class ForLazy5Either<L, T1, T2, T3, T4, T5> {
 
         private final Either<L, T1> ts1;
-        private final Function1<T1, Either<L, T2>> ts2;
-        private final Function2<T1, T2, Either<L, T3>> ts3;
-        private final Function3<T1, T2, T3, Either<L, T4>> ts4;
-        private final Function4<T1, T2, T3, T4, Either<L, T5>> ts5;
+        private final Function1<? super T1, Either<L, T2>> ts2;
+        private final Function2<? super T1, ? super T2, Either<L, T3>> ts3;
+        private final Function3<? super T1, ? super T2, ? super T3, Either<L, T4>> ts4;
+        private final Function4<? super T1, ? super T2, ? super T3, ? super T4, Either<L, T5>> ts5;
 
-        private ForLazy5Either(Either<L, T1> ts1, Function1<T1, Either<L, T2>> ts2, Function2<T1, T2, Either<L, T3>> ts3, Function3<T1, T2, T3, Either<L, T4>> ts4, Function4<T1, T2, T3, T4, Either<L, T5>> ts5) {
+        private ForLazy5Either(Either<L, T1> ts1, Function1<? super T1, Either<L, T2>> ts2, Function2<? super T1, ? super T2, Either<L, T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Either<L, T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, Either<L, T5>> ts5) {
             this.ts1 = ts1;
             this.ts2 = ts2;
             this.ts3 = ts3;
@@ -8832,13 +8832,13 @@ public <R> Either<L, R> yield(Function5<? super T1, ? super T2, ? super T3, ? su
     public static class ForLazy6Either<L, T1, T2, T3, T4, T5, T6> {
 
         private final Either<L, T1> ts1;
-        private final Function1<T1, Either<L, T2>> ts2;
-        private final Function2<T1, T2, Either<L, T3>> ts3;
-        private final Function3<T1, T2, T3, Either<L, T4>> ts4;
-        private final Function4<T1, T2, T3, T4, Either<L, T5>> ts5;
-        private final Function5<T1, T2, T3, T4, T5, Either<L, T6>> ts6;
+        private final Function1<? super T1, Either<L, T2>> ts2;
+        private final Function2<? super T1, ? super T2, Either<L, T3>> ts3;
+        private final Function3<? super T1, ? super T2, ? super T3, Either<L, T4>> ts4;
+        private final Function4<? super T1, ? super T2, ? super T3, ? super T4, Either<L, T5>> ts5;
+        private final Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Either<L, T6>> ts6;
 
-        private ForLazy6Either(Either<L, T1> ts1, Function1<T1, Either<L, T2>> ts2, Function2<T1, T2, Either<L, T3>> ts3, Function3<T1, T2, T3, Either<L, T4>> ts4, Function4<T1, T2, T3, T4, Either<L, T5>> ts5, Function5<T1, T2, T3, T4, T5, Either<L, T6>> ts6) {
+        private ForLazy6Either(Either<L, T1> ts1, Function1<? super T1, Either<L, T2>> ts2, Function2<? super T1, ? super T2, Either<L, T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Either<L, T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, Either<L, T5>> ts5, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Either<L, T6>> ts6) {
             this.ts1 = ts1;
             this.ts2 = ts2;
             this.ts3 = ts3;
@@ -8893,14 +8893,14 @@ public <R> Either<L, R> yield(Function6<? super T1, ? super T2, ? super T3, ? su
     public static class ForLazy7Either<L, T1, T2, T3, T4, T5, T6, T7> {
 
         private final Either<L, T1> ts1;
-        private final Function1<T1, Either<L, T2>> ts2;
-        private final Function2<T1, T2, Either<L, T3>> ts3;
-        private final Function3<T1, T2, T3, Either<L, T4>> ts4;
-        private final Function4<T1, T2, T3, T4, Either<L, T5>> ts5;
-        private final Function5<T1, T2, T3, T4, T5, Either<L, T6>> ts6;
-        private final Function6<T1, T2, T3, T4, T5, T6, Either<L, T7>> ts7;
-
-        private ForLazy7Either(Either<L, T1> ts1, Function1<T1, Either<L, T2>> ts2, Function2<T1, T2, Either<L, T3>> ts3, Function3<T1, T2, T3, Either<L, T4>> ts4, Function4<T1, T2, T3, T4, Either<L, T5>> ts5, Function5<T1, T2, T3, T4, T5, Either<L, T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, Either<L, T7>> ts7) {
+        private final Function1<? super T1, Either<L, T2>> ts2;
+        private final Function2<? super T1, ? super T2, Either<L, T3>> ts3;
+        private final Function3<? super T1, ? super T2, ? super T3, Either<L, T4>> ts4;
+        private final Function4<? super T1, ? super T2, ? super T3, ? super T4, Either<L, T5>> ts5;
+        private final Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Either<L, T6>> ts6;
+        private final Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, Either<L, T7>> ts7;
+
+        private ForLazy7Either(Either<L, T1> ts1, Function1<? super T1, Either<L, T2>> ts2, Function2<? super T1, ? super T2, Either<L, T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Either<L, T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, Either<L, T5>> ts5, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Either<L, T6>> ts6, Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, Either<L, T7>> ts7) {
             this.ts1 = ts1;
             this.ts2 = ts2;
             this.ts3 = ts3;
@@ -8959,15 +8959,15 @@ public <R> Either<L, R> yield(Function7<? super T1, ? super T2, ? super T3, ? su
     public static class ForLazy8Either<L, T1, T2, T3, T4, T5, T6, T7, T8> {
 
         private final Either<L, T1> ts1;
-        private final Function1<T1, Either<L, T2>> ts2;
-        private final Function2<T1, T2, Either<L, T3>> ts3;
-        private final Function3<T1, T2, T3, Either<L, T4>> ts4;
-        private final Function4<T1, T2, T3, T4, Either<L, T5>> ts5;
-        private final Function5<T1, T2, T3, T4, T5, Either<L, T6>> ts6;
-        private final Function6<T1, T2, T3, T4, T5, T6, Either<L, T7>> ts7;
-        private final Function7<T1, T2, T3, T4, T5, T6, T7, Either<L, T8>> ts8;
-
-        private ForLazy8Either(Either<L, T1> ts1, Function1<T1, Either<L, T2>> ts2, Function2<T1, T2, Either<L, T3>> ts3, Function3<T1, T2, T3, Either<L, T4>> ts4, Function4<T1, T2, T3, T4, Either<L, T5>> ts5, Function5<T1, T2, T3, T4, T5, Either<L, T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, Either<L, T7>> ts7, Function7<T1, T2, T3, T4, T5, T6, T7, Either<L, T8>> ts8) {
+        private final Function1<? super T1, Either<L, T2>> ts2;
+        private final Function2<? super T1, ? super T2, Either<L, T3>> ts3;
+        private final Function3<? super T1, ? super T2, ? super T3, Either<L, T4>> ts4;
+        private final Function4<? super T1, ? super T2, ? super T3, ? super T4, Either<L, T5>> ts5;
+        private final Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Either<L, T6>> ts6;
+        private final Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, Either<L, T7>> ts7;
+        private final Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, Either<L, T8>> ts8;
+
+        private ForLazy8Either(Either<L, T1> ts1, Function1<? super T1, Either<L, T2>> ts2, Function2<? super T1, ? super T2, Either<L, T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Either<L, T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, Either<L, T5>> ts5, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Either<L, T6>> ts6, Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, Either<L, T7>> ts7, Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, Either<L, T8>> ts8) {
             this.ts1 = ts1;
             this.ts2 = ts2;
             this.ts3 = ts3;
@@ -9023,9 +9023,9 @@ public <R> Either<L, R> yield(Function8<? super T1, ? super T2, ? super T3, ? su
     public static class ForLazy2Validation<L, T1, T2> {
 
         private final Validation<L, T1> ts1;
-        private final Function1<T1, Validation<L, T2>> ts2;
+        private final Function1<? super T1, Validation<L, T2>> ts2;
 
-        private ForLazy2Validation(Validation<L, T1> ts1, Function1<T1, Validation<L, T2>> ts2) {
+        private ForLazy2Validation(Validation<L, T1> ts1, Function1<? super T1, Validation<L, T2>> ts2) {
             this.ts1 = ts1;
             this.ts2 = ts2;
         }
@@ -9064,10 +9064,10 @@ public <R> Validation<L, R> yield(BiFunction<? super T1, ? super T2, ? extends R
     public static class ForLazy3Validation<L, T1, T2, T3> {
 
         private final Validation<L, T1> ts1;
-        private final Function1<T1, Validation<L, T2>> ts2;
-        private final Function2<T1, T2, Validation<L, T3>> ts3;
+        private final Function1<? super T1, Validation<L, T2>> ts2;
+        private final Function2<? super T1, ? super T2, Validation<L, T3>> ts3;
 
-        private ForLazy3Validation(Validation<L, T1> ts1, Function1<T1, Validation<L, T2>> ts2, Function2<T1, T2, Validation<L, T3>> ts3) {
+        private ForLazy3Validation(Validation<L, T1> ts1, Function1<? super T1, Validation<L, T2>> ts2, Function2<? super T1, ? super T2, Validation<L, T3>> ts3) {
             this.ts1 = ts1;
             this.ts2 = ts2;
             this.ts3 = ts3;
@@ -9110,11 +9110,11 @@ public <R> Validation<L, R> yield(Function3<? super T1, ? super T2, ? super T3,
     public static class ForLazy4Validation<L, T1, T2, T3, T4> {
 
         private final Validation<L, T1> ts1;
-        private final Function1<T1, Validation<L, T2>> ts2;
-        private final Function2<T1, T2, Validation<L, T3>> ts3;
-        private final Function3<T1, T2, T3, Validation<L, T4>> ts4;
+        private final Function1<? super T1, Validation<L, T2>> ts2;
+        private final Function2<? super T1, ? super T2, Validation<L, T3>> ts3;
+        private final Function3<? super T1, ? super T2, ? super T3, Validation<L, T4>> ts4;
 
-        private ForLazy4Validation(Validation<L, T1> ts1, Function1<T1, Validation<L, T2>> ts2, Function2<T1, T2, Validation<L, T3>> ts3, Function3<T1, T2, T3, Validation<L, T4>> ts4) {
+        private ForLazy4Validation(Validation<L, T1> ts1, Function1<? super T1, Validation<L, T2>> ts2, Function2<? super T1, ? super T2, Validation<L, T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Validation<L, T4>> ts4) {
             this.ts1 = ts1;
             this.ts2 = ts2;
             this.ts3 = ts3;
@@ -9161,12 +9161,12 @@ public <R> Validation<L, R> yield(Function4<? super T1, ? super T2, ? super T3,
     public static class ForLazy5Validation<L, T1, T2, T3, T4, T5> {
 
         private final Validation<L, T1> ts1;
-        private final Function1<T1, Validation<L, T2>> ts2;
-        private final Function2<T1, T2, Validation<L, T3>> ts3;
-        private final Function3<T1, T2, T3, Validation<L, T4>> ts4;
-        private final Function4<T1, T2, T3, T4, Validation<L, T5>> ts5;
+        private final Function1<? super T1, Validation<L, T2>> ts2;
+        private final Function2<? super T1, ? super T2, Validation<L, T3>> ts3;
+        private final Function3<? super T1, ? super T2, ? super T3, Validation<L, T4>> ts4;
+        private final Function4<? super T1, ? super T2, ? super T3, ? super T4, Validation<L, T5>> ts5;
 
-        private ForLazy5Validation(Validation<L, T1> ts1, Function1<T1, Validation<L, T2>> ts2, Function2<T1, T2, Validation<L, T3>> ts3, Function3<T1, T2, T3, Validation<L, T4>> ts4, Function4<T1, T2, T3, T4, Validation<L, T5>> ts5) {
+        private ForLazy5Validation(Validation<L, T1> ts1, Function1<? super T1, Validation<L, T2>> ts2, Function2<? super T1, ? super T2, Validation<L, T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Validation<L, T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, Validation<L, T5>> ts5) {
             this.ts1 = ts1;
             this.ts2 = ts2;
             this.ts3 = ts3;
@@ -9217,13 +9217,13 @@ public <R> Validation<L, R> yield(Function5<? super T1, ? super T2, ? super T3,
     public static class ForLazy6Validation<L, T1, T2, T3, T4, T5, T6> {
 
         private final Validation<L, T1> ts1;
-        private final Function1<T1, Validation<L, T2>> ts2;
-        private final Function2<T1, T2, Validation<L, T3>> ts3;
-        private final Function3<T1, T2, T3, Validation<L, T4>> ts4;
-        private final Function4<T1, T2, T3, T4, Validation<L, T5>> ts5;
-        private final Function5<T1, T2, T3, T4, T5, Validation<L, T6>> ts6;
+        private final Function1<? super T1, Validation<L, T2>> ts2;
+        private final Function2<? super T1, ? super T2, Validation<L, T3>> ts3;
+        private final Function3<? super T1, ? super T2, ? super T3, Validation<L, T4>> ts4;
+        private final Function4<? super T1, ? super T2, ? super T3, ? super T4, Validation<L, T5>> ts5;
+        private final Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Validation<L, T6>> ts6;
 
-        private ForLazy6Validation(Validation<L, T1> ts1, Function1<T1, Validation<L, T2>> ts2, Function2<T1, T2, Validation<L, T3>> ts3, Function3<T1, T2, T3, Validation<L, T4>> ts4, Function4<T1, T2, T3, T4, Validation<L, T5>> ts5, Function5<T1, T2, T3, T4, T5, Validation<L, T6>> ts6) {
+        private ForLazy6Validation(Validation<L, T1> ts1, Function1<? super T1, Validation<L, T2>> ts2, Function2<? super T1, ? super T2, Validation<L, T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Validation<L, T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, Validation<L, T5>> ts5, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Validation<L, T6>> ts6) {
             this.ts1 = ts1;
             this.ts2 = ts2;
             this.ts3 = ts3;
@@ -9278,14 +9278,14 @@ public <R> Validation<L, R> yield(Function6<? super T1, ? super T2, ? super T3,
     public static class ForLazy7Validation<L, T1, T2, T3, T4, T5, T6, T7> {
 
         private final Validation<L, T1> ts1;
-        private final Function1<T1, Validation<L, T2>> ts2;
-        private final Function2<T1, T2, Validation<L, T3>> ts3;
-        private final Function3<T1, T2, T3, Validation<L, T4>> ts4;
-        private final Function4<T1, T2, T3, T4, Validation<L, T5>> ts5;
-        private final Function5<T1, T2, T3, T4, T5, Validation<L, T6>> ts6;
-        private final Function6<T1, T2, T3, T4, T5, T6, Validation<L, T7>> ts7;
-
-        private ForLazy7Validation(Validation<L, T1> ts1, Function1<T1, Validation<L, T2>> ts2, Function2<T1, T2, Validation<L, T3>> ts3, Function3<T1, T2, T3, Validation<L, T4>> ts4, Function4<T1, T2, T3, T4, Validation<L, T5>> ts5, Function5<T1, T2, T3, T4, T5, Validation<L, T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, Validation<L, T7>> ts7) {
+        private final Function1<? super T1, Validation<L, T2>> ts2;
+        private final Function2<? super T1, ? super T2, Validation<L, T3>> ts3;
+        private final Function3<? super T1, ? super T2, ? super T3, Validation<L, T4>> ts4;
+        private final Function4<? super T1, ? super T2, ? super T3, ? super T4, Validation<L, T5>> ts5;
+        private final Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Validation<L, T6>> ts6;
+        private final Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, Validation<L, T7>> ts7;
+
+        private ForLazy7Validation(Validation<L, T1> ts1, Function1<? super T1, Validation<L, T2>> ts2, Function2<? super T1, ? super T2, Validation<L, T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Validation<L, T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, Validation<L, T5>> ts5, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Validation<L, T6>> ts6, Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, Validation<L, T7>> ts7) {
             this.ts1 = ts1;
             this.ts2 = ts2;
             this.ts3 = ts3;
@@ -9344,15 +9344,15 @@ public <R> Validation<L, R> yield(Function7<? super T1, ? super T2, ? super T3,
     public static class ForLazy8Validation<L, T1, T2, T3, T4, T5, T6, T7, T8> {
 
         private final Validation<L, T1> ts1;
-        private final Function1<T1, Validation<L, T2>> ts2;
-        private final Function2<T1, T2, Validation<L, T3>> ts3;
-        private final Function3<T1, T2, T3, Validation<L, T4>> ts4;
-        private final Function4<T1, T2, T3, T4, Validation<L, T5>> ts5;
-        private final Function5<T1, T2, T3, T4, T5, Validation<L, T6>> ts6;
-        private final Function6<T1, T2, T3, T4, T5, T6, Validation<L, T7>> ts7;
-        private final Function7<T1, T2, T3, T4, T5, T6, T7, Validation<L, T8>> ts8;
-
-        private ForLazy8Validation(Validation<L, T1> ts1, Function1<T1, Validation<L, T2>> ts2, Function2<T1, T2, Validation<L, T3>> ts3, Function3<T1, T2, T3, Validation<L, T4>> ts4, Function4<T1, T2, T3, T4, Validation<L, T5>> ts5, Function5<T1, T2, T3, T4, T5, Validation<L, T6>> ts6, Function6<T1, T2, T3, T4, T5, T6, Validation<L, T7>> ts7, Function7<T1, T2, T3, T4, T5, T6, T7, Validation<L, T8>> ts8) {
+        private final Function1<? super T1, Validation<L, T2>> ts2;
+        private final Function2<? super T1, ? super T2, Validation<L, T3>> ts3;
+        private final Function3<? super T1, ? super T2, ? super T3, Validation<L, T4>> ts4;
+        private final Function4<? super T1, ? super T2, ? super T3, ? super T4, Validation<L, T5>> ts5;
+        private final Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Validation<L, T6>> ts6;
+        private final Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, Validation<L, T7>> ts7;
+        private final Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, Validation<L, T8>> ts8;
+
+        private ForLazy8Validation(Validation<L, T1> ts1, Function1<? super T1, Validation<L, T2>> ts2, Function2<? super T1, ? super T2, Validation<L, T3>> ts3, Function3<? super T1, ? super T2, ? super T3, Validation<L, T4>> ts4, Function4<? super T1, ? super T2, ? super T3, ? super T4, Validation<L, T5>> ts5, Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, Validation<L, T6>> ts6, Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, Validation<L, T7>> ts7, Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, Validation<L, T8>> ts8) {
             this.ts1 = ts1;
             this.ts2 = ts2;
             this.ts3 = ts3;

From 6a6baf8a4587c0afd6626ae2de33c08afc944d87 Mon Sep 17 00:00:00 2001
From: Grzegorz Piwowarek <gpiwowarek@gmail.com>
Date: Wed, 5 Nov 2025 12:51:30 +0100
Subject: [PATCH 3/8] preserve ? extends R in yield() to improve type inference
 for nested lambdas

---
 vavr/generator/Generator.scala | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/vavr/generator/Generator.scala b/vavr/generator/Generator.scala
index 3ac6981820..fca524e2b4 100644
--- a/vavr/generator/Generator.scala
+++ b/vavr/generator/Generator.scala
@@ -796,10 +796,6 @@ def generateMainClasses(): Unit = {
               val forClassName = s"ForLazy$i$mtype"
               val parameterInset = if (monadicTypesThatNeedParameter.contains(mtype)) "L, " else ""
               val generics = parameterInset + (1 to i).gen(j => s"T$j")(", ")
-              val functionType = i match {
-                case 2 => BiFunctionType
-                case _ => s"Function$i"
-              }
               val args = (1 to i).gen(j => s"? super T$j")(", ")
 
               val fields = (1 to i).gen { j =>
@@ -875,7 +871,12 @@ def generateMainClasses(): Unit = {
                        * @return an {@code $rtype} containing mapped results
                        * @throws NullPointerException if {@code f} is {@code null}
                        */
-                      public <R> $rtype<${parameterInset}R> yield($functionType<$args, ? extends R> f) {
+                      public <R> $rtype<${parameterInset}R> yield(${
+                if (i == 2)
+                  s"BiFunction<? super T1, ? super T2, ? extends R>"
+                else
+                  s"Function$i<${(1 to i).map(j => s"? super T$j").mkString(", ")}, ? extends R>"
+              } f) {
                           $Objects.requireNonNull(f, "f is null");
                           return $yieldBody;
                       }

From 532964cefe1685c4528c1d371d4f77c96089c1f2 Mon Sep 17 00:00:00 2001
From: Grzegorz Piwowarek <gpiwowarek@gmail.com>
Date: Wed, 5 Nov 2025 17:14:34 +0100
Subject: [PATCH 4/8] docs

---
 vavr/generator/Generator.scala          |  14 +-
 vavr/src-gen/main/java/io/vavr/API.java | 546 +++++++++++++-----------
 2 files changed, 301 insertions(+), 259 deletions(-)

diff --git a/vavr/generator/Generator.scala b/vavr/generator/Generator.scala
index fca524e2b4..df7332d1b3 100644
--- a/vavr/generator/Generator.scala
+++ b/vavr/generator/Generator.scala
@@ -771,8 +771,9 @@ def generateMainClasses(): Unit = {
                      *
                      * <p>The first argument ({@code ts1}) is the initial ${mtype}. Each subsequent
                      * argument ({@code ts2} .. {@code ts$i}) is a function that receives all values
-                     * bound so far and returns the next ${mtype}. This only builds the lazy
-                     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+                     * bound so far and returns the next ${mtype}. This method only constructs the
+                     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+                     * is invoked.</p>
                      *
                      ${(0 to i).gen(j => if (j == 0) "*" else s"* @param ts$j the ${j.ordinal} ${mtype}")("\n")}
                      ${if (isComplex) s"* @param <L> the common left-hand type of all ${mtype}s\n" else ""}
@@ -796,7 +797,6 @@ def generateMainClasses(): Unit = {
               val forClassName = s"ForLazy$i$mtype"
               val parameterInset = if (monadicTypesThatNeedParameter.contains(mtype)) "L, " else ""
               val generics = parameterInset + (1 to i).gen(j => s"T$j")(", ")
-              val args = (1 to i).gen(j => s"? super T$j")(", ")
 
               val fields = (1 to i).gen { j =>
                 if (j == 1)
@@ -846,8 +846,8 @@ def generateMainClasses(): Unit = {
                    * A lazily evaluated {@code For}-comprehension with ${i.numerus(mtype)}.
                    *
                    * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-                   * Construction is side-effect free; underlying ${i.plural(mtype)} are only
-                   * traversed when {@code yield(...)} is invoked.</p>
+                   * Construction is side-effect free; underlying ${i.plural(mtype)} are traversed
+                   * only when {@code yield(...)} is invoked.</p>
                    *
                    ${if (monadicTypesThatNeedParameter.contains(mtype)) s"* @param <L> the common left-hand type of all ${mtype}s\n" else ""}
                    ${(1 to i).gen(j => s"* @param <T$j> the component type of the ${j.ordinal} ${mtype}")("\n")}
@@ -864,9 +864,9 @@ def generateMainClasses(): Unit = {
                        * Produces results by mapping the Cartesian product of all bound values.
                        *
                        * <p>Evaluation is lazy and delegated to the underlying ${i.plural(mtype)} by
-                       * composing flatMap/map chains.</p>
+                       * composing {@code flatMap} and {@code map} chains.</p>
                        *
-                       * @param f a function that maps a tuple of bound values to a result
+                       * @param f a function mapping a tuple of bound values to a result
                        * @param <R> the element type of the resulting {@code $rtype}
                        * @return an {@code $rtype} containing mapped results
                        * @throws NullPointerException if {@code f} is {@code null}
diff --git a/vavr/src-gen/main/java/io/vavr/API.java b/vavr/src-gen/main/java/io/vavr/API.java
index 50ee6d9a7e..4668ae4607 100644
--- a/vavr/src-gen/main/java/io/vavr/API.java
+++ b/vavr/src-gen/main/java/io/vavr/API.java
@@ -5745,8 +5745,9 @@ public <R> Validation<L, R> yield(Function8<? super T1, ? super T2, ? super T3,
      *
      * <p>The first argument ({@code ts1}) is the initial Option. Each subsequent
      * argument ({@code ts2} .. {@code ts2}) is a function that receives all values
-     * bound so far and returns the next Option. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next Option. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st Option
@@ -5768,8 +5769,9 @@ public static <T1, T2> ForLazy2Option<T1, T2> For(Option<T1> ts1, Function1<? su
      *
      * <p>The first argument ({@code ts1}) is the initial Option. Each subsequent
      * argument ({@code ts2} .. {@code ts3}) is a function that receives all values
-     * bound so far and returns the next Option. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next Option. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st Option
@@ -5794,8 +5796,9 @@ public static <T1, T2, T3> ForLazy3Option<T1, T2, T3> For(Option<T1> ts1, Functi
      *
      * <p>The first argument ({@code ts1}) is the initial Option. Each subsequent
      * argument ({@code ts2} .. {@code ts4}) is a function that receives all values
-     * bound so far and returns the next Option. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next Option. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st Option
@@ -5823,8 +5826,9 @@ public static <T1, T2, T3, T4> ForLazy4Option<T1, T2, T3, T4> For(Option<T1> ts1
      *
      * <p>The first argument ({@code ts1}) is the initial Option. Each subsequent
      * argument ({@code ts2} .. {@code ts5}) is a function that receives all values
-     * bound so far and returns the next Option. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next Option. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st Option
@@ -5855,8 +5859,9 @@ public static <T1, T2, T3, T4, T5> ForLazy5Option<T1, T2, T3, T4, T5> For(Option
      *
      * <p>The first argument ({@code ts1}) is the initial Option. Each subsequent
      * argument ({@code ts2} .. {@code ts6}) is a function that receives all values
-     * bound so far and returns the next Option. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next Option. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st Option
@@ -5890,8 +5895,9 @@ public static <T1, T2, T3, T4, T5, T6> ForLazy6Option<T1, T2, T3, T4, T5, T6> Fo
      *
      * <p>The first argument ({@code ts1}) is the initial Option. Each subsequent
      * argument ({@code ts2} .. {@code ts7}) is a function that receives all values
-     * bound so far and returns the next Option. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next Option. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st Option
@@ -5928,8 +5934,9 @@ public static <T1, T2, T3, T4, T5, T6, T7> ForLazy7Option<T1, T2, T3, T4, T5, T6
      *
      * <p>The first argument ({@code ts1}) is the initial Option. Each subsequent
      * argument ({@code ts2} .. {@code ts8}) is a function that receives all values
-     * bound so far and returns the next Option. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next Option. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st Option
@@ -5969,8 +5976,9 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8> ForLazy8Option<T1, T2, T3, T4, T5
      *
      * <p>The first argument ({@code ts1}) is the initial Future. Each subsequent
      * argument ({@code ts2} .. {@code ts2}) is a function that receives all values
-     * bound so far and returns the next Future. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next Future. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st Future
@@ -5992,8 +6000,9 @@ public static <T1, T2> ForLazy2Future<T1, T2> For(Future<T1> ts1, Function1<? su
      *
      * <p>The first argument ({@code ts1}) is the initial Future. Each subsequent
      * argument ({@code ts2} .. {@code ts3}) is a function that receives all values
-     * bound so far and returns the next Future. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next Future. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st Future
@@ -6018,8 +6027,9 @@ public static <T1, T2, T3> ForLazy3Future<T1, T2, T3> For(Future<T1> ts1, Functi
      *
      * <p>The first argument ({@code ts1}) is the initial Future. Each subsequent
      * argument ({@code ts2} .. {@code ts4}) is a function that receives all values
-     * bound so far and returns the next Future. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next Future. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st Future
@@ -6047,8 +6057,9 @@ public static <T1, T2, T3, T4> ForLazy4Future<T1, T2, T3, T4> For(Future<T1> ts1
      *
      * <p>The first argument ({@code ts1}) is the initial Future. Each subsequent
      * argument ({@code ts2} .. {@code ts5}) is a function that receives all values
-     * bound so far and returns the next Future. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next Future. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st Future
@@ -6079,8 +6090,9 @@ public static <T1, T2, T3, T4, T5> ForLazy5Future<T1, T2, T3, T4, T5> For(Future
      *
      * <p>The first argument ({@code ts1}) is the initial Future. Each subsequent
      * argument ({@code ts2} .. {@code ts6}) is a function that receives all values
-     * bound so far and returns the next Future. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next Future. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st Future
@@ -6114,8 +6126,9 @@ public static <T1, T2, T3, T4, T5, T6> ForLazy6Future<T1, T2, T3, T4, T5, T6> Fo
      *
      * <p>The first argument ({@code ts1}) is the initial Future. Each subsequent
      * argument ({@code ts2} .. {@code ts7}) is a function that receives all values
-     * bound so far and returns the next Future. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next Future. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st Future
@@ -6152,8 +6165,9 @@ public static <T1, T2, T3, T4, T5, T6, T7> ForLazy7Future<T1, T2, T3, T4, T5, T6
      *
      * <p>The first argument ({@code ts1}) is the initial Future. Each subsequent
      * argument ({@code ts2} .. {@code ts8}) is a function that receives all values
-     * bound so far and returns the next Future. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next Future. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st Future
@@ -6193,8 +6207,9 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8> ForLazy8Future<T1, T2, T3, T4, T5
      *
      * <p>The first argument ({@code ts1}) is the initial Try. Each subsequent
      * argument ({@code ts2} .. {@code ts2}) is a function that receives all values
-     * bound so far and returns the next Try. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next Try. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st Try
@@ -6216,8 +6231,9 @@ public static <T1, T2> ForLazy2Try<T1, T2> For(Try<T1> ts1, Function1<? super T1
      *
      * <p>The first argument ({@code ts1}) is the initial Try. Each subsequent
      * argument ({@code ts2} .. {@code ts3}) is a function that receives all values
-     * bound so far and returns the next Try. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next Try. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st Try
@@ -6242,8 +6258,9 @@ public static <T1, T2, T3> ForLazy3Try<T1, T2, T3> For(Try<T1> ts1, Function1<?
      *
      * <p>The first argument ({@code ts1}) is the initial Try. Each subsequent
      * argument ({@code ts2} .. {@code ts4}) is a function that receives all values
-     * bound so far and returns the next Try. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next Try. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st Try
@@ -6271,8 +6288,9 @@ public static <T1, T2, T3, T4> ForLazy4Try<T1, T2, T3, T4> For(Try<T1> ts1, Func
      *
      * <p>The first argument ({@code ts1}) is the initial Try. Each subsequent
      * argument ({@code ts2} .. {@code ts5}) is a function that receives all values
-     * bound so far and returns the next Try. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next Try. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st Try
@@ -6303,8 +6321,9 @@ public static <T1, T2, T3, T4, T5> ForLazy5Try<T1, T2, T3, T4, T5> For(Try<T1> t
      *
      * <p>The first argument ({@code ts1}) is the initial Try. Each subsequent
      * argument ({@code ts2} .. {@code ts6}) is a function that receives all values
-     * bound so far and returns the next Try. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next Try. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st Try
@@ -6338,8 +6357,9 @@ public static <T1, T2, T3, T4, T5, T6> ForLazy6Try<T1, T2, T3, T4, T5, T6> For(T
      *
      * <p>The first argument ({@code ts1}) is the initial Try. Each subsequent
      * argument ({@code ts2} .. {@code ts7}) is a function that receives all values
-     * bound so far and returns the next Try. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next Try. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st Try
@@ -6376,8 +6396,9 @@ public static <T1, T2, T3, T4, T5, T6, T7> ForLazy7Try<T1, T2, T3, T4, T5, T6, T
      *
      * <p>The first argument ({@code ts1}) is the initial Try. Each subsequent
      * argument ({@code ts2} .. {@code ts8}) is a function that receives all values
-     * bound so far and returns the next Try. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next Try. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st Try
@@ -6417,8 +6438,9 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8> ForLazy8Try<T1, T2, T3, T4, T5, T
      *
      * <p>The first argument ({@code ts1}) is the initial List. Each subsequent
      * argument ({@code ts2} .. {@code ts2}) is a function that receives all values
-     * bound so far and returns the next List. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next List. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st List
@@ -6440,8 +6462,9 @@ public static <T1, T2> ForLazy2List<T1, T2> For(List<T1> ts1, Function1<? super
      *
      * <p>The first argument ({@code ts1}) is the initial List. Each subsequent
      * argument ({@code ts2} .. {@code ts3}) is a function that receives all values
-     * bound so far and returns the next List. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next List. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st List
@@ -6466,8 +6489,9 @@ public static <T1, T2, T3> ForLazy3List<T1, T2, T3> For(List<T1> ts1, Function1<
      *
      * <p>The first argument ({@code ts1}) is the initial List. Each subsequent
      * argument ({@code ts2} .. {@code ts4}) is a function that receives all values
-     * bound so far and returns the next List. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next List. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st List
@@ -6495,8 +6519,9 @@ public static <T1, T2, T3, T4> ForLazy4List<T1, T2, T3, T4> For(List<T1> ts1, Fu
      *
      * <p>The first argument ({@code ts1}) is the initial List. Each subsequent
      * argument ({@code ts2} .. {@code ts5}) is a function that receives all values
-     * bound so far and returns the next List. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next List. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st List
@@ -6527,8 +6552,9 @@ public static <T1, T2, T3, T4, T5> ForLazy5List<T1, T2, T3, T4, T5> For(List<T1>
      *
      * <p>The first argument ({@code ts1}) is the initial List. Each subsequent
      * argument ({@code ts2} .. {@code ts6}) is a function that receives all values
-     * bound so far and returns the next List. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next List. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st List
@@ -6562,8 +6588,9 @@ public static <T1, T2, T3, T4, T5, T6> ForLazy6List<T1, T2, T3, T4, T5, T6> For(
      *
      * <p>The first argument ({@code ts1}) is the initial List. Each subsequent
      * argument ({@code ts2} .. {@code ts7}) is a function that receives all values
-     * bound so far and returns the next List. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next List. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st List
@@ -6600,8 +6627,9 @@ public static <T1, T2, T3, T4, T5, T6, T7> ForLazy7List<T1, T2, T3, T4, T5, T6,
      *
      * <p>The first argument ({@code ts1}) is the initial List. Each subsequent
      * argument ({@code ts2} .. {@code ts8}) is a function that receives all values
-     * bound so far and returns the next List. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next List. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st List
@@ -6641,8 +6669,9 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8> ForLazy8List<T1, T2, T3, T4, T5,
      *
      * <p>The first argument ({@code ts1}) is the initial Either. Each subsequent
      * argument ({@code ts2} .. {@code ts2}) is a function that receives all values
-     * bound so far and returns the next Either. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next Either. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st Either
@@ -6664,8 +6693,9 @@ public static <L, T1, T2> ForLazy2Either<L, T1, T2> For(Either<L, T1> ts1, Funct
      *
      * <p>The first argument ({@code ts1}) is the initial Either. Each subsequent
      * argument ({@code ts2} .. {@code ts3}) is a function that receives all values
-     * bound so far and returns the next Either. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next Either. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st Either
@@ -6690,8 +6720,9 @@ public static <L, T1, T2, T3> ForLazy3Either<L, T1, T2, T3> For(Either<L, T1> ts
      *
      * <p>The first argument ({@code ts1}) is the initial Either. Each subsequent
      * argument ({@code ts2} .. {@code ts4}) is a function that receives all values
-     * bound so far and returns the next Either. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next Either. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st Either
@@ -6719,8 +6750,9 @@ public static <L, T1, T2, T3, T4> ForLazy4Either<L, T1, T2, T3, T4> For(Either<L
      *
      * <p>The first argument ({@code ts1}) is the initial Either. Each subsequent
      * argument ({@code ts2} .. {@code ts5}) is a function that receives all values
-     * bound so far and returns the next Either. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next Either. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st Either
@@ -6751,8 +6783,9 @@ public static <L, T1, T2, T3, T4, T5> ForLazy5Either<L, T1, T2, T3, T4, T5> For(
      *
      * <p>The first argument ({@code ts1}) is the initial Either. Each subsequent
      * argument ({@code ts2} .. {@code ts6}) is a function that receives all values
-     * bound so far and returns the next Either. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next Either. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st Either
@@ -6786,8 +6819,9 @@ public static <L, T1, T2, T3, T4, T5, T6> ForLazy6Either<L, T1, T2, T3, T4, T5,
      *
      * <p>The first argument ({@code ts1}) is the initial Either. Each subsequent
      * argument ({@code ts2} .. {@code ts7}) is a function that receives all values
-     * bound so far and returns the next Either. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next Either. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st Either
@@ -6824,8 +6858,9 @@ public static <L, T1, T2, T3, T4, T5, T6, T7> ForLazy7Either<L, T1, T2, T3, T4,
      *
      * <p>The first argument ({@code ts1}) is the initial Either. Each subsequent
      * argument ({@code ts2} .. {@code ts8}) is a function that receives all values
-     * bound so far and returns the next Either. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next Either. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st Either
@@ -6865,8 +6900,9 @@ public static <L, T1, T2, T3, T4, T5, T6, T7, T8> ForLazy8Either<L, T1, T2, T3,
      *
      * <p>The first argument ({@code ts1}) is the initial Validation. Each subsequent
      * argument ({@code ts2} .. {@code ts2}) is a function that receives all values
-     * bound so far and returns the next Validation. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next Validation. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st Validation
@@ -6888,8 +6924,9 @@ public static <L, T1, T2> ForLazy2Validation<L, T1, T2> For(Validation<L, T1> ts
      *
      * <p>The first argument ({@code ts1}) is the initial Validation. Each subsequent
      * argument ({@code ts2} .. {@code ts3}) is a function that receives all values
-     * bound so far and returns the next Validation. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next Validation. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st Validation
@@ -6914,8 +6951,9 @@ public static <L, T1, T2, T3> ForLazy3Validation<L, T1, T2, T3> For(Validation<L
      *
      * <p>The first argument ({@code ts1}) is the initial Validation. Each subsequent
      * argument ({@code ts2} .. {@code ts4}) is a function that receives all values
-     * bound so far and returns the next Validation. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next Validation. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st Validation
@@ -6943,8 +6981,9 @@ public static <L, T1, T2, T3, T4> ForLazy4Validation<L, T1, T2, T3, T4> For(Vali
      *
      * <p>The first argument ({@code ts1}) is the initial Validation. Each subsequent
      * argument ({@code ts2} .. {@code ts5}) is a function that receives all values
-     * bound so far and returns the next Validation. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next Validation. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st Validation
@@ -6975,8 +7014,9 @@ public static <L, T1, T2, T3, T4, T5> ForLazy5Validation<L, T1, T2, T3, T4, T5>
      *
      * <p>The first argument ({@code ts1}) is the initial Validation. Each subsequent
      * argument ({@code ts2} .. {@code ts6}) is a function that receives all values
-     * bound so far and returns the next Validation. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next Validation. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st Validation
@@ -7010,8 +7050,9 @@ public static <L, T1, T2, T3, T4, T5, T6> ForLazy6Validation<L, T1, T2, T3, T4,
      *
      * <p>The first argument ({@code ts1}) is the initial Validation. Each subsequent
      * argument ({@code ts2} .. {@code ts7}) is a function that receives all values
-     * bound so far and returns the next Validation. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next Validation. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st Validation
@@ -7048,8 +7089,9 @@ public static <L, T1, T2, T3, T4, T5, T6, T7> ForLazy7Validation<L, T1, T2, T3,
      *
      * <p>The first argument ({@code ts1}) is the initial Validation. Each subsequent
      * argument ({@code ts2} .. {@code ts8}) is a function that receives all values
-     * bound so far and returns the next Validation. This only builds the lazy
-     * comprehension; effects are evaluated when {@code yield(...)} is called.</p>
+     * bound so far and returns the next Validation. This method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</p>
      *
      *
      * @param ts1 the 1st Validation
@@ -7088,8 +7130,8 @@ public static <L, T1, T2, T3, T4, T5, T6, T7, T8> ForLazy8Validation<L, T1, T2,
      * A lazily evaluated {@code For}-comprehension with two Options.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Options are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Options are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
 
      * @param <T1> the component type of the 1st Option
@@ -7109,9 +7151,9 @@ private ForLazy2Option(Option<T1> ts1, Function1<? super T1, Option<T2>> ts2) {
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Options by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code Option}
          * @return an {@code Option} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}
@@ -7128,8 +7170,8 @@ public <R> Option<R> yield(BiFunction<? super T1, ? super T2, ? extends R> f) {
      * A lazily evaluated {@code For}-comprehension with three Options.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Options are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Options are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
 
      * @param <T1> the component type of the 1st Option
@@ -7152,9 +7194,9 @@ private ForLazy3Option(Option<T1> ts1, Function1<? super T1, Option<T2>> ts2, Fu
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Options by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code Option}
          * @return an {@code Option} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}
@@ -7173,8 +7215,8 @@ public <R> Option<R> yield(Function3<? super T1, ? super T2, ? super T3, ? exten
      * A lazily evaluated {@code For}-comprehension with 4 Options.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Options are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Options are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
 
      * @param <T1> the component type of the 1st Option
@@ -7200,9 +7242,9 @@ private ForLazy4Option(Option<T1> ts1, Function1<? super T1, Option<T2>> ts2, Fu
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Options by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code Option}
          * @return an {@code Option} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}
@@ -7223,8 +7265,8 @@ public <R> Option<R> yield(Function4<? super T1, ? super T2, ? super T3, ? super
      * A lazily evaluated {@code For}-comprehension with 5 Options.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Options are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Options are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
 
      * @param <T1> the component type of the 1st Option
@@ -7253,9 +7295,9 @@ private ForLazy5Option(Option<T1> ts1, Function1<? super T1, Option<T2>> ts2, Fu
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Options by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code Option}
          * @return an {@code Option} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}
@@ -7278,8 +7320,8 @@ public <R> Option<R> yield(Function5<? super T1, ? super T2, ? super T3, ? super
      * A lazily evaluated {@code For}-comprehension with 6 Options.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Options are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Options are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
 
      * @param <T1> the component type of the 1st Option
@@ -7311,9 +7353,9 @@ private ForLazy6Option(Option<T1> ts1, Function1<? super T1, Option<T2>> ts2, Fu
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Options by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code Option}
          * @return an {@code Option} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}
@@ -7338,8 +7380,8 @@ public <R> Option<R> yield(Function6<? super T1, ? super T2, ? super T3, ? super
      * A lazily evaluated {@code For}-comprehension with 7 Options.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Options are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Options are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
 
      * @param <T1> the component type of the 1st Option
@@ -7374,9 +7416,9 @@ private ForLazy7Option(Option<T1> ts1, Function1<? super T1, Option<T2>> ts2, Fu
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Options by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code Option}
          * @return an {@code Option} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}
@@ -7403,8 +7445,8 @@ public <R> Option<R> yield(Function7<? super T1, ? super T2, ? super T3, ? super
      * A lazily evaluated {@code For}-comprehension with 8 Options.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Options are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Options are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
 
      * @param <T1> the component type of the 1st Option
@@ -7442,9 +7484,9 @@ private ForLazy8Option(Option<T1> ts1, Function1<? super T1, Option<T2>> ts2, Fu
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Options by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code Option}
          * @return an {@code Option} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}
@@ -7473,8 +7515,8 @@ public <R> Option<R> yield(Function8<? super T1, ? super T2, ? super T3, ? super
      * A lazily evaluated {@code For}-comprehension with two Futures.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Futures are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Futures are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
 
      * @param <T1> the component type of the 1st Future
@@ -7494,9 +7536,9 @@ private ForLazy2Future(Future<T1> ts1, Function1<? super T1, Future<T2>> ts2) {
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Futures by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code Future}
          * @return an {@code Future} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}
@@ -7513,8 +7555,8 @@ public <R> Future<R> yield(BiFunction<? super T1, ? super T2, ? extends R> f) {
      * A lazily evaluated {@code For}-comprehension with three Futures.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Futures are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Futures are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
 
      * @param <T1> the component type of the 1st Future
@@ -7537,9 +7579,9 @@ private ForLazy3Future(Future<T1> ts1, Function1<? super T1, Future<T2>> ts2, Fu
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Futures by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code Future}
          * @return an {@code Future} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}
@@ -7558,8 +7600,8 @@ public <R> Future<R> yield(Function3<? super T1, ? super T2, ? super T3, ? exten
      * A lazily evaluated {@code For}-comprehension with 4 Futures.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Futures are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Futures are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
 
      * @param <T1> the component type of the 1st Future
@@ -7585,9 +7627,9 @@ private ForLazy4Future(Future<T1> ts1, Function1<? super T1, Future<T2>> ts2, Fu
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Futures by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code Future}
          * @return an {@code Future} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}
@@ -7608,8 +7650,8 @@ public <R> Future<R> yield(Function4<? super T1, ? super T2, ? super T3, ? super
      * A lazily evaluated {@code For}-comprehension with 5 Futures.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Futures are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Futures are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
 
      * @param <T1> the component type of the 1st Future
@@ -7638,9 +7680,9 @@ private ForLazy5Future(Future<T1> ts1, Function1<? super T1, Future<T2>> ts2, Fu
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Futures by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code Future}
          * @return an {@code Future} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}
@@ -7663,8 +7705,8 @@ public <R> Future<R> yield(Function5<? super T1, ? super T2, ? super T3, ? super
      * A lazily evaluated {@code For}-comprehension with 6 Futures.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Futures are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Futures are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
 
      * @param <T1> the component type of the 1st Future
@@ -7696,9 +7738,9 @@ private ForLazy6Future(Future<T1> ts1, Function1<? super T1, Future<T2>> ts2, Fu
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Futures by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code Future}
          * @return an {@code Future} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}
@@ -7723,8 +7765,8 @@ public <R> Future<R> yield(Function6<? super T1, ? super T2, ? super T3, ? super
      * A lazily evaluated {@code For}-comprehension with 7 Futures.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Futures are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Futures are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
 
      * @param <T1> the component type of the 1st Future
@@ -7759,9 +7801,9 @@ private ForLazy7Future(Future<T1> ts1, Function1<? super T1, Future<T2>> ts2, Fu
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Futures by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code Future}
          * @return an {@code Future} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}
@@ -7788,8 +7830,8 @@ public <R> Future<R> yield(Function7<? super T1, ? super T2, ? super T3, ? super
      * A lazily evaluated {@code For}-comprehension with 8 Futures.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Futures are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Futures are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
 
      * @param <T1> the component type of the 1st Future
@@ -7827,9 +7869,9 @@ private ForLazy8Future(Future<T1> ts1, Function1<? super T1, Future<T2>> ts2, Fu
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Futures by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code Future}
          * @return an {@code Future} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}
@@ -7858,8 +7900,8 @@ public <R> Future<R> yield(Function8<? super T1, ? super T2, ? super T3, ? super
      * A lazily evaluated {@code For}-comprehension with two Trys.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Trys are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Trys are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
 
      * @param <T1> the component type of the 1st Try
@@ -7879,9 +7921,9 @@ private ForLazy2Try(Try<T1> ts1, Function1<? super T1, Try<T2>> ts2) {
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Trys by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code Try}
          * @return an {@code Try} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}
@@ -7898,8 +7940,8 @@ public <R> Try<R> yield(BiFunction<? super T1, ? super T2, ? extends R> f) {
      * A lazily evaluated {@code For}-comprehension with three Trys.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Trys are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Trys are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
 
      * @param <T1> the component type of the 1st Try
@@ -7922,9 +7964,9 @@ private ForLazy3Try(Try<T1> ts1, Function1<? super T1, Try<T2>> ts2, Function2<?
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Trys by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code Try}
          * @return an {@code Try} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}
@@ -7943,8 +7985,8 @@ public <R> Try<R> yield(Function3<? super T1, ? super T2, ? super T3, ? extends
      * A lazily evaluated {@code For}-comprehension with 4 Trys.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Trys are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Trys are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
 
      * @param <T1> the component type of the 1st Try
@@ -7970,9 +8012,9 @@ private ForLazy4Try(Try<T1> ts1, Function1<? super T1, Try<T2>> ts2, Function2<?
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Trys by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code Try}
          * @return an {@code Try} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}
@@ -7993,8 +8035,8 @@ public <R> Try<R> yield(Function4<? super T1, ? super T2, ? super T3, ? super T4
      * A lazily evaluated {@code For}-comprehension with 5 Trys.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Trys are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Trys are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
 
      * @param <T1> the component type of the 1st Try
@@ -8023,9 +8065,9 @@ private ForLazy5Try(Try<T1> ts1, Function1<? super T1, Try<T2>> ts2, Function2<?
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Trys by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code Try}
          * @return an {@code Try} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}
@@ -8048,8 +8090,8 @@ public <R> Try<R> yield(Function5<? super T1, ? super T2, ? super T3, ? super T4
      * A lazily evaluated {@code For}-comprehension with 6 Trys.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Trys are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Trys are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
 
      * @param <T1> the component type of the 1st Try
@@ -8081,9 +8123,9 @@ private ForLazy6Try(Try<T1> ts1, Function1<? super T1, Try<T2>> ts2, Function2<?
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Trys by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code Try}
          * @return an {@code Try} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}
@@ -8108,8 +8150,8 @@ public <R> Try<R> yield(Function6<? super T1, ? super T2, ? super T3, ? super T4
      * A lazily evaluated {@code For}-comprehension with 7 Trys.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Trys are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Trys are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
 
      * @param <T1> the component type of the 1st Try
@@ -8144,9 +8186,9 @@ private ForLazy7Try(Try<T1> ts1, Function1<? super T1, Try<T2>> ts2, Function2<?
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Trys by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code Try}
          * @return an {@code Try} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}
@@ -8173,8 +8215,8 @@ public <R> Try<R> yield(Function7<? super T1, ? super T2, ? super T3, ? super T4
      * A lazily evaluated {@code For}-comprehension with 8 Trys.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Trys are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Trys are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
 
      * @param <T1> the component type of the 1st Try
@@ -8212,9 +8254,9 @@ private ForLazy8Try(Try<T1> ts1, Function1<? super T1, Try<T2>> ts2, Function2<?
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Trys by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code Try}
          * @return an {@code Try} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}
@@ -8243,8 +8285,8 @@ public <R> Try<R> yield(Function8<? super T1, ? super T2, ? super T3, ? super T4
      * A lazily evaluated {@code For}-comprehension with two Lists.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Lists are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Lists are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
 
      * @param <T1> the component type of the 1st List
@@ -8264,9 +8306,9 @@ private ForLazy2List(List<T1> ts1, Function1<? super T1, List<T2>> ts2) {
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Lists by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code List}
          * @return an {@code List} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}
@@ -8283,8 +8325,8 @@ public <R> List<R> yield(BiFunction<? super T1, ? super T2, ? extends R> f) {
      * A lazily evaluated {@code For}-comprehension with three Lists.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Lists are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Lists are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
 
      * @param <T1> the component type of the 1st List
@@ -8307,9 +8349,9 @@ private ForLazy3List(List<T1> ts1, Function1<? super T1, List<T2>> ts2, Function
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Lists by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code List}
          * @return an {@code List} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}
@@ -8328,8 +8370,8 @@ public <R> List<R> yield(Function3<? super T1, ? super T2, ? super T3, ? extends
      * A lazily evaluated {@code For}-comprehension with 4 Lists.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Lists are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Lists are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
 
      * @param <T1> the component type of the 1st List
@@ -8355,9 +8397,9 @@ private ForLazy4List(List<T1> ts1, Function1<? super T1, List<T2>> ts2, Function
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Lists by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code List}
          * @return an {@code List} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}
@@ -8378,8 +8420,8 @@ public <R> List<R> yield(Function4<? super T1, ? super T2, ? super T3, ? super T
      * A lazily evaluated {@code For}-comprehension with 5 Lists.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Lists are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Lists are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
 
      * @param <T1> the component type of the 1st List
@@ -8408,9 +8450,9 @@ private ForLazy5List(List<T1> ts1, Function1<? super T1, List<T2>> ts2, Function
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Lists by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code List}
          * @return an {@code List} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}
@@ -8433,8 +8475,8 @@ public <R> List<R> yield(Function5<? super T1, ? super T2, ? super T3, ? super T
      * A lazily evaluated {@code For}-comprehension with 6 Lists.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Lists are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Lists are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
 
      * @param <T1> the component type of the 1st List
@@ -8466,9 +8508,9 @@ private ForLazy6List(List<T1> ts1, Function1<? super T1, List<T2>> ts2, Function
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Lists by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code List}
          * @return an {@code List} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}
@@ -8493,8 +8535,8 @@ public <R> List<R> yield(Function6<? super T1, ? super T2, ? super T3, ? super T
      * A lazily evaluated {@code For}-comprehension with 7 Lists.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Lists are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Lists are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
 
      * @param <T1> the component type of the 1st List
@@ -8529,9 +8571,9 @@ private ForLazy7List(List<T1> ts1, Function1<? super T1, List<T2>> ts2, Function
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Lists by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code List}
          * @return an {@code List} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}
@@ -8558,8 +8600,8 @@ public <R> List<R> yield(Function7<? super T1, ? super T2, ? super T3, ? super T
      * A lazily evaluated {@code For}-comprehension with 8 Lists.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Lists are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Lists are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
 
      * @param <T1> the component type of the 1st List
@@ -8597,9 +8639,9 @@ private ForLazy8List(List<T1> ts1, Function1<? super T1, List<T2>> ts2, Function
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Lists by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code List}
          * @return an {@code List} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}
@@ -8628,8 +8670,8 @@ public <R> List<R> yield(Function8<? super T1, ? super T2, ? super T3, ? super T
      * A lazily evaluated {@code For}-comprehension with two Eithers.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Eithers are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Eithers are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
      * @param <L> the common left-hand type of all Eithers
      * @param <T1> the component type of the 1st Either
@@ -8649,9 +8691,9 @@ private ForLazy2Either(Either<L, T1> ts1, Function1<? super T1, Either<L, T2>> t
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Eithers by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code Either}
          * @return an {@code Either} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}
@@ -8668,8 +8710,8 @@ public <R> Either<L, R> yield(BiFunction<? super T1, ? super T2, ? extends R> f)
      * A lazily evaluated {@code For}-comprehension with three Eithers.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Eithers are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Eithers are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
      * @param <L> the common left-hand type of all Eithers
      * @param <T1> the component type of the 1st Either
@@ -8692,9 +8734,9 @@ private ForLazy3Either(Either<L, T1> ts1, Function1<? super T1, Either<L, T2>> t
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Eithers by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code Either}
          * @return an {@code Either} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}
@@ -8713,8 +8755,8 @@ public <R> Either<L, R> yield(Function3<? super T1, ? super T2, ? super T3, ? ex
      * A lazily evaluated {@code For}-comprehension with 4 Eithers.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Eithers are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Eithers are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
      * @param <L> the common left-hand type of all Eithers
      * @param <T1> the component type of the 1st Either
@@ -8740,9 +8782,9 @@ private ForLazy4Either(Either<L, T1> ts1, Function1<? super T1, Either<L, T2>> t
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Eithers by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code Either}
          * @return an {@code Either} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}
@@ -8763,8 +8805,8 @@ public <R> Either<L, R> yield(Function4<? super T1, ? super T2, ? super T3, ? su
      * A lazily evaluated {@code For}-comprehension with 5 Eithers.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Eithers are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Eithers are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
      * @param <L> the common left-hand type of all Eithers
      * @param <T1> the component type of the 1st Either
@@ -8793,9 +8835,9 @@ private ForLazy5Either(Either<L, T1> ts1, Function1<? super T1, Either<L, T2>> t
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Eithers by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code Either}
          * @return an {@code Either} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}
@@ -8818,8 +8860,8 @@ public <R> Either<L, R> yield(Function5<? super T1, ? super T2, ? super T3, ? su
      * A lazily evaluated {@code For}-comprehension with 6 Eithers.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Eithers are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Eithers are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
      * @param <L> the common left-hand type of all Eithers
      * @param <T1> the component type of the 1st Either
@@ -8851,9 +8893,9 @@ private ForLazy6Either(Either<L, T1> ts1, Function1<? super T1, Either<L, T2>> t
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Eithers by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code Either}
          * @return an {@code Either} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}
@@ -8878,8 +8920,8 @@ public <R> Either<L, R> yield(Function6<? super T1, ? super T2, ? super T3, ? su
      * A lazily evaluated {@code For}-comprehension with 7 Eithers.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Eithers are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Eithers are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
      * @param <L> the common left-hand type of all Eithers
      * @param <T1> the component type of the 1st Either
@@ -8914,9 +8956,9 @@ private ForLazy7Either(Either<L, T1> ts1, Function1<? super T1, Either<L, T2>> t
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Eithers by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code Either}
          * @return an {@code Either} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}
@@ -8943,8 +8985,8 @@ public <R> Either<L, R> yield(Function7<? super T1, ? super T2, ? super T3, ? su
      * A lazily evaluated {@code For}-comprehension with 8 Eithers.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Eithers are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Eithers are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
      * @param <L> the common left-hand type of all Eithers
      * @param <T1> the component type of the 1st Either
@@ -8982,9 +9024,9 @@ private ForLazy8Either(Either<L, T1> ts1, Function1<? super T1, Either<L, T2>> t
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Eithers by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code Either}
          * @return an {@code Either} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}
@@ -9013,8 +9055,8 @@ public <R> Either<L, R> yield(Function8<? super T1, ? super T2, ? super T3, ? su
      * A lazily evaluated {@code For}-comprehension with two Validations.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Validations are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Validations are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
      * @param <L> the common left-hand type of all Validations
      * @param <T1> the component type of the 1st Validation
@@ -9034,9 +9076,9 @@ private ForLazy2Validation(Validation<L, T1> ts1, Function1<? super T1, Validati
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Validations by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code Validation}
          * @return an {@code Validation} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}
@@ -9053,8 +9095,8 @@ public <R> Validation<L, R> yield(BiFunction<? super T1, ? super T2, ? extends R
      * A lazily evaluated {@code For}-comprehension with three Validations.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Validations are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Validations are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
      * @param <L> the common left-hand type of all Validations
      * @param <T1> the component type of the 1st Validation
@@ -9077,9 +9119,9 @@ private ForLazy3Validation(Validation<L, T1> ts1, Function1<? super T1, Validati
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Validations by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code Validation}
          * @return an {@code Validation} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}
@@ -9098,8 +9140,8 @@ public <R> Validation<L, R> yield(Function3<? super T1, ? super T2, ? super T3,
      * A lazily evaluated {@code For}-comprehension with 4 Validations.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Validations are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Validations are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
      * @param <L> the common left-hand type of all Validations
      * @param <T1> the component type of the 1st Validation
@@ -9125,9 +9167,9 @@ private ForLazy4Validation(Validation<L, T1> ts1, Function1<? super T1, Validati
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Validations by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code Validation}
          * @return an {@code Validation} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}
@@ -9148,8 +9190,8 @@ public <R> Validation<L, R> yield(Function4<? super T1, ? super T2, ? super T3,
      * A lazily evaluated {@code For}-comprehension with 5 Validations.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Validations are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Validations are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
      * @param <L> the common left-hand type of all Validations
      * @param <T1> the component type of the 1st Validation
@@ -9178,9 +9220,9 @@ private ForLazy5Validation(Validation<L, T1> ts1, Function1<? super T1, Validati
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Validations by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code Validation}
          * @return an {@code Validation} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}
@@ -9203,8 +9245,8 @@ public <R> Validation<L, R> yield(Function5<? super T1, ? super T2, ? super T3,
      * A lazily evaluated {@code For}-comprehension with 6 Validations.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Validations are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Validations are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
      * @param <L> the common left-hand type of all Validations
      * @param <T1> the component type of the 1st Validation
@@ -9236,9 +9278,9 @@ private ForLazy6Validation(Validation<L, T1> ts1, Function1<? super T1, Validati
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Validations by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code Validation}
          * @return an {@code Validation} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}
@@ -9263,8 +9305,8 @@ public <R> Validation<L, R> yield(Function6<? super T1, ? super T2, ? super T3,
      * A lazily evaluated {@code For}-comprehension with 7 Validations.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Validations are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Validations are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
      * @param <L> the common left-hand type of all Validations
      * @param <T1> the component type of the 1st Validation
@@ -9299,9 +9341,9 @@ private ForLazy7Validation(Validation<L, T1> ts1, Function1<? super T1, Validati
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Validations by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code Validation}
          * @return an {@code Validation} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}
@@ -9328,8 +9370,8 @@ public <R> Validation<L, R> yield(Function7<? super T1, ? super T2, ? super T3,
      * A lazily evaluated {@code For}-comprehension with 8 Validations.
      *
      * <p>Constructed via {@code For(...)} and evaluated by calling {@code yield(...)}.
-     * Construction is side-effect free; underlying Validations are only
-     * traversed when {@code yield(...)} is invoked.</p>
+     * Construction is side-effect free; underlying Validations are traversed
+     * only when {@code yield(...)} is invoked.</p>
      *
      * @param <L> the common left-hand type of all Validations
      * @param <T1> the component type of the 1st Validation
@@ -9367,9 +9409,9 @@ private ForLazy8Validation(Validation<L, T1> ts1, Function1<? super T1, Validati
          * Produces results by mapping the Cartesian product of all bound values.
          *
          * <p>Evaluation is lazy and delegated to the underlying Validations by
-         * composing flatMap/map chains.</p>
+         * composing {@code flatMap} and {@code map} chains.</p>
          *
-         * @param f a function that maps a tuple of bound values to a result
+         * @param f a function mapping a tuple of bound values to a result
          * @param <R> the element type of the resulting {@code Validation}
          * @return an {@code Validation} containing mapped results
          * @throws NullPointerException if {@code f} is {@code null}

From 3804557fa70c66581290662d5c74975754c9f5af Mon Sep 17 00:00:00 2001
From: Grzegorz Piwowarek <gpiwowarek@gmail.com>
Date: Wed, 5 Nov 2025 17:18:45 +0100
Subject: [PATCH 5/8] indent

---
 vavr/generator/Generator.scala          |   2 +-
 vavr/src-gen/main/java/io/vavr/API.java | 420 ++++++++++++------------
 2 files changed, 211 insertions(+), 211 deletions(-)

diff --git a/vavr/generator/Generator.scala b/vavr/generator/Generator.scala
index df7332d1b3..04e8a67d58 100644
--- a/vavr/generator/Generator.scala
+++ b/vavr/generator/Generator.scala
@@ -821,7 +821,7 @@ def generateMainClasses(): Unit = {
               val yieldBody = {
                 def nestedLambda(j: Int): String = {
                   val base = "                       "
-                  val indent = "  " * j
+                  val indent = "  " * (j + 1)
                   if (j == i) {
                     val argsList = (1 to i).map(k => s"t$k").mkString(", ")
                     val inputArgs = (1 until i).map(k => s"t$k").mkString(", ")
diff --git a/vavr/src-gen/main/java/io/vavr/API.java b/vavr/src-gen/main/java/io/vavr/API.java
index 4668ae4607..f1653a5afa 100644
--- a/vavr/src-gen/main/java/io/vavr/API.java
+++ b/vavr/src-gen/main/java/io/vavr/API.java
@@ -7161,8 +7161,8 @@ private ForLazy2Option(Option<T1> ts1, Function1<? super T1, Option<T2>> ts2) {
         public <R> Option<R> yield(BiFunction<? super T1, ? super T2, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).map(t2 -> f.apply(t1, t2));
-          });
+              return ts2.apply(t1).map(t2 -> f.apply(t1, t2));
+            });
         }
     }
 
@@ -7204,10 +7204,10 @@ private ForLazy3Option(Option<T1> ts1, Function1<? super T1, Option<T2>> ts2, Fu
         public <R> Option<R> yield(Function3<? super T1, ? super T2, ? super T3, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).flatMap(t2 -> {
-              return ts3.apply(t1, t2).map(t3 -> f.apply(t1, t2, t3));
+              return ts2.apply(t1).flatMap(t2 -> {
+                return ts3.apply(t1, t2).map(t3 -> f.apply(t1, t2, t3));
+              });
             });
-          });
         }
     }
 
@@ -7252,12 +7252,12 @@ private ForLazy4Option(Option<T1> ts1, Function1<? super T1, Option<T2>> ts2, Fu
         public <R> Option<R> yield(Function4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).flatMap(t2 -> {
-              return ts3.apply(t1, t2).flatMap(t3 -> {
-                return ts4.apply(t1, t2, t3).map(t4 -> f.apply(t1, t2, t3, t4));
+              return ts2.apply(t1).flatMap(t2 -> {
+                return ts3.apply(t1, t2).flatMap(t3 -> {
+                  return ts4.apply(t1, t2, t3).map(t4 -> f.apply(t1, t2, t3, t4));
+                });
               });
             });
-          });
         }
     }
 
@@ -7305,14 +7305,14 @@ private ForLazy5Option(Option<T1> ts1, Function1<? super T1, Option<T2>> ts2, Fu
         public <R> Option<R> yield(Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).flatMap(t2 -> {
-              return ts3.apply(t1, t2).flatMap(t3 -> {
-                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
-                  return ts5.apply(t1, t2, t3, t4).map(t5 -> f.apply(t1, t2, t3, t4, t5));
+              return ts2.apply(t1).flatMap(t2 -> {
+                return ts3.apply(t1, t2).flatMap(t3 -> {
+                  return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                    return ts5.apply(t1, t2, t3, t4).map(t5 -> f.apply(t1, t2, t3, t4, t5));
+                  });
                 });
               });
             });
-          });
         }
     }
 
@@ -7363,16 +7363,16 @@ private ForLazy6Option(Option<T1> ts1, Function1<? super T1, Option<T2>> ts2, Fu
         public <R> Option<R> yield(Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).flatMap(t2 -> {
-              return ts3.apply(t1, t2).flatMap(t3 -> {
-                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
-                  return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
-                    return ts6.apply(t1, t2, t3, t4, t5).map(t6 -> f.apply(t1, t2, t3, t4, t5, t6));
+              return ts2.apply(t1).flatMap(t2 -> {
+                return ts3.apply(t1, t2).flatMap(t3 -> {
+                  return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                    return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
+                      return ts6.apply(t1, t2, t3, t4, t5).map(t6 -> f.apply(t1, t2, t3, t4, t5, t6));
+                    });
                   });
                 });
               });
             });
-          });
         }
     }
 
@@ -7426,18 +7426,18 @@ private ForLazy7Option(Option<T1> ts1, Function1<? super T1, Option<T2>> ts2, Fu
         public <R> Option<R> yield(Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).flatMap(t2 -> {
-              return ts3.apply(t1, t2).flatMap(t3 -> {
-                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
-                  return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
-                    return ts6.apply(t1, t2, t3, t4, t5).flatMap(t6 -> {
-                      return ts7.apply(t1, t2, t3, t4, t5, t6).map(t7 -> f.apply(t1, t2, t3, t4, t5, t6, t7));
+              return ts2.apply(t1).flatMap(t2 -> {
+                return ts3.apply(t1, t2).flatMap(t3 -> {
+                  return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                    return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
+                      return ts6.apply(t1, t2, t3, t4, t5).flatMap(t6 -> {
+                        return ts7.apply(t1, t2, t3, t4, t5, t6).map(t7 -> f.apply(t1, t2, t3, t4, t5, t6, t7));
+                      });
                     });
                   });
                 });
               });
             });
-          });
         }
     }
 
@@ -7494,20 +7494,20 @@ private ForLazy8Option(Option<T1> ts1, Function1<? super T1, Option<T2>> ts2, Fu
         public <R> Option<R> yield(Function8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).flatMap(t2 -> {
-              return ts3.apply(t1, t2).flatMap(t3 -> {
-                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
-                  return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
-                    return ts6.apply(t1, t2, t3, t4, t5).flatMap(t6 -> {
-                      return ts7.apply(t1, t2, t3, t4, t5, t6).flatMap(t7 -> {
-                        return ts8.apply(t1, t2, t3, t4, t5, t6, t7).map(t8 -> f.apply(t1, t2, t3, t4, t5, t6, t7, t8));
+              return ts2.apply(t1).flatMap(t2 -> {
+                return ts3.apply(t1, t2).flatMap(t3 -> {
+                  return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                    return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
+                      return ts6.apply(t1, t2, t3, t4, t5).flatMap(t6 -> {
+                        return ts7.apply(t1, t2, t3, t4, t5, t6).flatMap(t7 -> {
+                          return ts8.apply(t1, t2, t3, t4, t5, t6, t7).map(t8 -> f.apply(t1, t2, t3, t4, t5, t6, t7, t8));
+                        });
                       });
                     });
                   });
                 });
               });
             });
-          });
         }
     }
 
@@ -7546,8 +7546,8 @@ private ForLazy2Future(Future<T1> ts1, Function1<? super T1, Future<T2>> ts2) {
         public <R> Future<R> yield(BiFunction<? super T1, ? super T2, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).map(t2 -> f.apply(t1, t2));
-          });
+              return ts2.apply(t1).map(t2 -> f.apply(t1, t2));
+            });
         }
     }
 
@@ -7589,10 +7589,10 @@ private ForLazy3Future(Future<T1> ts1, Function1<? super T1, Future<T2>> ts2, Fu
         public <R> Future<R> yield(Function3<? super T1, ? super T2, ? super T3, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).flatMap(t2 -> {
-              return ts3.apply(t1, t2).map(t3 -> f.apply(t1, t2, t3));
+              return ts2.apply(t1).flatMap(t2 -> {
+                return ts3.apply(t1, t2).map(t3 -> f.apply(t1, t2, t3));
+              });
             });
-          });
         }
     }
 
@@ -7637,12 +7637,12 @@ private ForLazy4Future(Future<T1> ts1, Function1<? super T1, Future<T2>> ts2, Fu
         public <R> Future<R> yield(Function4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).flatMap(t2 -> {
-              return ts3.apply(t1, t2).flatMap(t3 -> {
-                return ts4.apply(t1, t2, t3).map(t4 -> f.apply(t1, t2, t3, t4));
+              return ts2.apply(t1).flatMap(t2 -> {
+                return ts3.apply(t1, t2).flatMap(t3 -> {
+                  return ts4.apply(t1, t2, t3).map(t4 -> f.apply(t1, t2, t3, t4));
+                });
               });
             });
-          });
         }
     }
 
@@ -7690,14 +7690,14 @@ private ForLazy5Future(Future<T1> ts1, Function1<? super T1, Future<T2>> ts2, Fu
         public <R> Future<R> yield(Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).flatMap(t2 -> {
-              return ts3.apply(t1, t2).flatMap(t3 -> {
-                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
-                  return ts5.apply(t1, t2, t3, t4).map(t5 -> f.apply(t1, t2, t3, t4, t5));
+              return ts2.apply(t1).flatMap(t2 -> {
+                return ts3.apply(t1, t2).flatMap(t3 -> {
+                  return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                    return ts5.apply(t1, t2, t3, t4).map(t5 -> f.apply(t1, t2, t3, t4, t5));
+                  });
                 });
               });
             });
-          });
         }
     }
 
@@ -7748,16 +7748,16 @@ private ForLazy6Future(Future<T1> ts1, Function1<? super T1, Future<T2>> ts2, Fu
         public <R> Future<R> yield(Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).flatMap(t2 -> {
-              return ts3.apply(t1, t2).flatMap(t3 -> {
-                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
-                  return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
-                    return ts6.apply(t1, t2, t3, t4, t5).map(t6 -> f.apply(t1, t2, t3, t4, t5, t6));
+              return ts2.apply(t1).flatMap(t2 -> {
+                return ts3.apply(t1, t2).flatMap(t3 -> {
+                  return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                    return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
+                      return ts6.apply(t1, t2, t3, t4, t5).map(t6 -> f.apply(t1, t2, t3, t4, t5, t6));
+                    });
                   });
                 });
               });
             });
-          });
         }
     }
 
@@ -7811,18 +7811,18 @@ private ForLazy7Future(Future<T1> ts1, Function1<? super T1, Future<T2>> ts2, Fu
         public <R> Future<R> yield(Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).flatMap(t2 -> {
-              return ts3.apply(t1, t2).flatMap(t3 -> {
-                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
-                  return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
-                    return ts6.apply(t1, t2, t3, t4, t5).flatMap(t6 -> {
-                      return ts7.apply(t1, t2, t3, t4, t5, t6).map(t7 -> f.apply(t1, t2, t3, t4, t5, t6, t7));
+              return ts2.apply(t1).flatMap(t2 -> {
+                return ts3.apply(t1, t2).flatMap(t3 -> {
+                  return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                    return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
+                      return ts6.apply(t1, t2, t3, t4, t5).flatMap(t6 -> {
+                        return ts7.apply(t1, t2, t3, t4, t5, t6).map(t7 -> f.apply(t1, t2, t3, t4, t5, t6, t7));
+                      });
                     });
                   });
                 });
               });
             });
-          });
         }
     }
 
@@ -7879,20 +7879,20 @@ private ForLazy8Future(Future<T1> ts1, Function1<? super T1, Future<T2>> ts2, Fu
         public <R> Future<R> yield(Function8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).flatMap(t2 -> {
-              return ts3.apply(t1, t2).flatMap(t3 -> {
-                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
-                  return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
-                    return ts6.apply(t1, t2, t3, t4, t5).flatMap(t6 -> {
-                      return ts7.apply(t1, t2, t3, t4, t5, t6).flatMap(t7 -> {
-                        return ts8.apply(t1, t2, t3, t4, t5, t6, t7).map(t8 -> f.apply(t1, t2, t3, t4, t5, t6, t7, t8));
+              return ts2.apply(t1).flatMap(t2 -> {
+                return ts3.apply(t1, t2).flatMap(t3 -> {
+                  return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                    return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
+                      return ts6.apply(t1, t2, t3, t4, t5).flatMap(t6 -> {
+                        return ts7.apply(t1, t2, t3, t4, t5, t6).flatMap(t7 -> {
+                          return ts8.apply(t1, t2, t3, t4, t5, t6, t7).map(t8 -> f.apply(t1, t2, t3, t4, t5, t6, t7, t8));
+                        });
                       });
                     });
                   });
                 });
               });
             });
-          });
         }
     }
 
@@ -7931,8 +7931,8 @@ private ForLazy2Try(Try<T1> ts1, Function1<? super T1, Try<T2>> ts2) {
         public <R> Try<R> yield(BiFunction<? super T1, ? super T2, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).map(t2 -> f.apply(t1, t2));
-          });
+              return ts2.apply(t1).map(t2 -> f.apply(t1, t2));
+            });
         }
     }
 
@@ -7974,10 +7974,10 @@ private ForLazy3Try(Try<T1> ts1, Function1<? super T1, Try<T2>> ts2, Function2<?
         public <R> Try<R> yield(Function3<? super T1, ? super T2, ? super T3, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).flatMap(t2 -> {
-              return ts3.apply(t1, t2).map(t3 -> f.apply(t1, t2, t3));
+              return ts2.apply(t1).flatMap(t2 -> {
+                return ts3.apply(t1, t2).map(t3 -> f.apply(t1, t2, t3));
+              });
             });
-          });
         }
     }
 
@@ -8022,12 +8022,12 @@ private ForLazy4Try(Try<T1> ts1, Function1<? super T1, Try<T2>> ts2, Function2<?
         public <R> Try<R> yield(Function4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).flatMap(t2 -> {
-              return ts3.apply(t1, t2).flatMap(t3 -> {
-                return ts4.apply(t1, t2, t3).map(t4 -> f.apply(t1, t2, t3, t4));
+              return ts2.apply(t1).flatMap(t2 -> {
+                return ts3.apply(t1, t2).flatMap(t3 -> {
+                  return ts4.apply(t1, t2, t3).map(t4 -> f.apply(t1, t2, t3, t4));
+                });
               });
             });
-          });
         }
     }
 
@@ -8075,14 +8075,14 @@ private ForLazy5Try(Try<T1> ts1, Function1<? super T1, Try<T2>> ts2, Function2<?
         public <R> Try<R> yield(Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).flatMap(t2 -> {
-              return ts3.apply(t1, t2).flatMap(t3 -> {
-                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
-                  return ts5.apply(t1, t2, t3, t4).map(t5 -> f.apply(t1, t2, t3, t4, t5));
+              return ts2.apply(t1).flatMap(t2 -> {
+                return ts3.apply(t1, t2).flatMap(t3 -> {
+                  return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                    return ts5.apply(t1, t2, t3, t4).map(t5 -> f.apply(t1, t2, t3, t4, t5));
+                  });
                 });
               });
             });
-          });
         }
     }
 
@@ -8133,16 +8133,16 @@ private ForLazy6Try(Try<T1> ts1, Function1<? super T1, Try<T2>> ts2, Function2<?
         public <R> Try<R> yield(Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).flatMap(t2 -> {
-              return ts3.apply(t1, t2).flatMap(t3 -> {
-                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
-                  return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
-                    return ts6.apply(t1, t2, t3, t4, t5).map(t6 -> f.apply(t1, t2, t3, t4, t5, t6));
+              return ts2.apply(t1).flatMap(t2 -> {
+                return ts3.apply(t1, t2).flatMap(t3 -> {
+                  return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                    return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
+                      return ts6.apply(t1, t2, t3, t4, t5).map(t6 -> f.apply(t1, t2, t3, t4, t5, t6));
+                    });
                   });
                 });
               });
             });
-          });
         }
     }
 
@@ -8196,18 +8196,18 @@ private ForLazy7Try(Try<T1> ts1, Function1<? super T1, Try<T2>> ts2, Function2<?
         public <R> Try<R> yield(Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).flatMap(t2 -> {
-              return ts3.apply(t1, t2).flatMap(t3 -> {
-                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
-                  return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
-                    return ts6.apply(t1, t2, t3, t4, t5).flatMap(t6 -> {
-                      return ts7.apply(t1, t2, t3, t4, t5, t6).map(t7 -> f.apply(t1, t2, t3, t4, t5, t6, t7));
+              return ts2.apply(t1).flatMap(t2 -> {
+                return ts3.apply(t1, t2).flatMap(t3 -> {
+                  return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                    return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
+                      return ts6.apply(t1, t2, t3, t4, t5).flatMap(t6 -> {
+                        return ts7.apply(t1, t2, t3, t4, t5, t6).map(t7 -> f.apply(t1, t2, t3, t4, t5, t6, t7));
+                      });
                     });
                   });
                 });
               });
             });
-          });
         }
     }
 
@@ -8264,20 +8264,20 @@ private ForLazy8Try(Try<T1> ts1, Function1<? super T1, Try<T2>> ts2, Function2<?
         public <R> Try<R> yield(Function8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).flatMap(t2 -> {
-              return ts3.apply(t1, t2).flatMap(t3 -> {
-                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
-                  return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
-                    return ts6.apply(t1, t2, t3, t4, t5).flatMap(t6 -> {
-                      return ts7.apply(t1, t2, t3, t4, t5, t6).flatMap(t7 -> {
-                        return ts8.apply(t1, t2, t3, t4, t5, t6, t7).map(t8 -> f.apply(t1, t2, t3, t4, t5, t6, t7, t8));
+              return ts2.apply(t1).flatMap(t2 -> {
+                return ts3.apply(t1, t2).flatMap(t3 -> {
+                  return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                    return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
+                      return ts6.apply(t1, t2, t3, t4, t5).flatMap(t6 -> {
+                        return ts7.apply(t1, t2, t3, t4, t5, t6).flatMap(t7 -> {
+                          return ts8.apply(t1, t2, t3, t4, t5, t6, t7).map(t8 -> f.apply(t1, t2, t3, t4, t5, t6, t7, t8));
+                        });
                       });
                     });
                   });
                 });
               });
             });
-          });
         }
     }
 
@@ -8316,8 +8316,8 @@ private ForLazy2List(List<T1> ts1, Function1<? super T1, List<T2>> ts2) {
         public <R> List<R> yield(BiFunction<? super T1, ? super T2, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).map(t2 -> f.apply(t1, t2));
-          });
+              return ts2.apply(t1).map(t2 -> f.apply(t1, t2));
+            });
         }
     }
 
@@ -8359,10 +8359,10 @@ private ForLazy3List(List<T1> ts1, Function1<? super T1, List<T2>> ts2, Function
         public <R> List<R> yield(Function3<? super T1, ? super T2, ? super T3, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).flatMap(t2 -> {
-              return ts3.apply(t1, t2).map(t3 -> f.apply(t1, t2, t3));
+              return ts2.apply(t1).flatMap(t2 -> {
+                return ts3.apply(t1, t2).map(t3 -> f.apply(t1, t2, t3));
+              });
             });
-          });
         }
     }
 
@@ -8407,12 +8407,12 @@ private ForLazy4List(List<T1> ts1, Function1<? super T1, List<T2>> ts2, Function
         public <R> List<R> yield(Function4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).flatMap(t2 -> {
-              return ts3.apply(t1, t2).flatMap(t3 -> {
-                return ts4.apply(t1, t2, t3).map(t4 -> f.apply(t1, t2, t3, t4));
+              return ts2.apply(t1).flatMap(t2 -> {
+                return ts3.apply(t1, t2).flatMap(t3 -> {
+                  return ts4.apply(t1, t2, t3).map(t4 -> f.apply(t1, t2, t3, t4));
+                });
               });
             });
-          });
         }
     }
 
@@ -8460,14 +8460,14 @@ private ForLazy5List(List<T1> ts1, Function1<? super T1, List<T2>> ts2, Function
         public <R> List<R> yield(Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).flatMap(t2 -> {
-              return ts3.apply(t1, t2).flatMap(t3 -> {
-                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
-                  return ts5.apply(t1, t2, t3, t4).map(t5 -> f.apply(t1, t2, t3, t4, t5));
+              return ts2.apply(t1).flatMap(t2 -> {
+                return ts3.apply(t1, t2).flatMap(t3 -> {
+                  return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                    return ts5.apply(t1, t2, t3, t4).map(t5 -> f.apply(t1, t2, t3, t4, t5));
+                  });
                 });
               });
             });
-          });
         }
     }
 
@@ -8518,16 +8518,16 @@ private ForLazy6List(List<T1> ts1, Function1<? super T1, List<T2>> ts2, Function
         public <R> List<R> yield(Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).flatMap(t2 -> {
-              return ts3.apply(t1, t2).flatMap(t3 -> {
-                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
-                  return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
-                    return ts6.apply(t1, t2, t3, t4, t5).map(t6 -> f.apply(t1, t2, t3, t4, t5, t6));
+              return ts2.apply(t1).flatMap(t2 -> {
+                return ts3.apply(t1, t2).flatMap(t3 -> {
+                  return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                    return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
+                      return ts6.apply(t1, t2, t3, t4, t5).map(t6 -> f.apply(t1, t2, t3, t4, t5, t6));
+                    });
                   });
                 });
               });
             });
-          });
         }
     }
 
@@ -8581,18 +8581,18 @@ private ForLazy7List(List<T1> ts1, Function1<? super T1, List<T2>> ts2, Function
         public <R> List<R> yield(Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).flatMap(t2 -> {
-              return ts3.apply(t1, t2).flatMap(t3 -> {
-                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
-                  return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
-                    return ts6.apply(t1, t2, t3, t4, t5).flatMap(t6 -> {
-                      return ts7.apply(t1, t2, t3, t4, t5, t6).map(t7 -> f.apply(t1, t2, t3, t4, t5, t6, t7));
+              return ts2.apply(t1).flatMap(t2 -> {
+                return ts3.apply(t1, t2).flatMap(t3 -> {
+                  return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                    return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
+                      return ts6.apply(t1, t2, t3, t4, t5).flatMap(t6 -> {
+                        return ts7.apply(t1, t2, t3, t4, t5, t6).map(t7 -> f.apply(t1, t2, t3, t4, t5, t6, t7));
+                      });
                     });
                   });
                 });
               });
             });
-          });
         }
     }
 
@@ -8649,20 +8649,20 @@ private ForLazy8List(List<T1> ts1, Function1<? super T1, List<T2>> ts2, Function
         public <R> List<R> yield(Function8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).flatMap(t2 -> {
-              return ts3.apply(t1, t2).flatMap(t3 -> {
-                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
-                  return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
-                    return ts6.apply(t1, t2, t3, t4, t5).flatMap(t6 -> {
-                      return ts7.apply(t1, t2, t3, t4, t5, t6).flatMap(t7 -> {
-                        return ts8.apply(t1, t2, t3, t4, t5, t6, t7).map(t8 -> f.apply(t1, t2, t3, t4, t5, t6, t7, t8));
+              return ts2.apply(t1).flatMap(t2 -> {
+                return ts3.apply(t1, t2).flatMap(t3 -> {
+                  return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                    return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
+                      return ts6.apply(t1, t2, t3, t4, t5).flatMap(t6 -> {
+                        return ts7.apply(t1, t2, t3, t4, t5, t6).flatMap(t7 -> {
+                          return ts8.apply(t1, t2, t3, t4, t5, t6, t7).map(t8 -> f.apply(t1, t2, t3, t4, t5, t6, t7, t8));
+                        });
                       });
                     });
                   });
                 });
               });
             });
-          });
         }
     }
 
@@ -8701,8 +8701,8 @@ private ForLazy2Either(Either<L, T1> ts1, Function1<? super T1, Either<L, T2>> t
         public <R> Either<L, R> yield(BiFunction<? super T1, ? super T2, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).map(t2 -> f.apply(t1, t2));
-          });
+              return ts2.apply(t1).map(t2 -> f.apply(t1, t2));
+            });
         }
     }
 
@@ -8744,10 +8744,10 @@ private ForLazy3Either(Either<L, T1> ts1, Function1<? super T1, Either<L, T2>> t
         public <R> Either<L, R> yield(Function3<? super T1, ? super T2, ? super T3, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).flatMap(t2 -> {
-              return ts3.apply(t1, t2).map(t3 -> f.apply(t1, t2, t3));
+              return ts2.apply(t1).flatMap(t2 -> {
+                return ts3.apply(t1, t2).map(t3 -> f.apply(t1, t2, t3));
+              });
             });
-          });
         }
     }
 
@@ -8792,12 +8792,12 @@ private ForLazy4Either(Either<L, T1> ts1, Function1<? super T1, Either<L, T2>> t
         public <R> Either<L, R> yield(Function4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).flatMap(t2 -> {
-              return ts3.apply(t1, t2).flatMap(t3 -> {
-                return ts4.apply(t1, t2, t3).map(t4 -> f.apply(t1, t2, t3, t4));
+              return ts2.apply(t1).flatMap(t2 -> {
+                return ts3.apply(t1, t2).flatMap(t3 -> {
+                  return ts4.apply(t1, t2, t3).map(t4 -> f.apply(t1, t2, t3, t4));
+                });
               });
             });
-          });
         }
     }
 
@@ -8845,14 +8845,14 @@ private ForLazy5Either(Either<L, T1> ts1, Function1<? super T1, Either<L, T2>> t
         public <R> Either<L, R> yield(Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).flatMap(t2 -> {
-              return ts3.apply(t1, t2).flatMap(t3 -> {
-                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
-                  return ts5.apply(t1, t2, t3, t4).map(t5 -> f.apply(t1, t2, t3, t4, t5));
+              return ts2.apply(t1).flatMap(t2 -> {
+                return ts3.apply(t1, t2).flatMap(t3 -> {
+                  return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                    return ts5.apply(t1, t2, t3, t4).map(t5 -> f.apply(t1, t2, t3, t4, t5));
+                  });
                 });
               });
             });
-          });
         }
     }
 
@@ -8903,16 +8903,16 @@ private ForLazy6Either(Either<L, T1> ts1, Function1<? super T1, Either<L, T2>> t
         public <R> Either<L, R> yield(Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).flatMap(t2 -> {
-              return ts3.apply(t1, t2).flatMap(t3 -> {
-                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
-                  return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
-                    return ts6.apply(t1, t2, t3, t4, t5).map(t6 -> f.apply(t1, t2, t3, t4, t5, t6));
+              return ts2.apply(t1).flatMap(t2 -> {
+                return ts3.apply(t1, t2).flatMap(t3 -> {
+                  return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                    return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
+                      return ts6.apply(t1, t2, t3, t4, t5).map(t6 -> f.apply(t1, t2, t3, t4, t5, t6));
+                    });
                   });
                 });
               });
             });
-          });
         }
     }
 
@@ -8966,18 +8966,18 @@ private ForLazy7Either(Either<L, T1> ts1, Function1<? super T1, Either<L, T2>> t
         public <R> Either<L, R> yield(Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).flatMap(t2 -> {
-              return ts3.apply(t1, t2).flatMap(t3 -> {
-                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
-                  return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
-                    return ts6.apply(t1, t2, t3, t4, t5).flatMap(t6 -> {
-                      return ts7.apply(t1, t2, t3, t4, t5, t6).map(t7 -> f.apply(t1, t2, t3, t4, t5, t6, t7));
+              return ts2.apply(t1).flatMap(t2 -> {
+                return ts3.apply(t1, t2).flatMap(t3 -> {
+                  return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                    return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
+                      return ts6.apply(t1, t2, t3, t4, t5).flatMap(t6 -> {
+                        return ts7.apply(t1, t2, t3, t4, t5, t6).map(t7 -> f.apply(t1, t2, t3, t4, t5, t6, t7));
+                      });
                     });
                   });
                 });
               });
             });
-          });
         }
     }
 
@@ -9034,20 +9034,20 @@ private ForLazy8Either(Either<L, T1> ts1, Function1<? super T1, Either<L, T2>> t
         public <R> Either<L, R> yield(Function8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).flatMap(t2 -> {
-              return ts3.apply(t1, t2).flatMap(t3 -> {
-                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
-                  return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
-                    return ts6.apply(t1, t2, t3, t4, t5).flatMap(t6 -> {
-                      return ts7.apply(t1, t2, t3, t4, t5, t6).flatMap(t7 -> {
-                        return ts8.apply(t1, t2, t3, t4, t5, t6, t7).map(t8 -> f.apply(t1, t2, t3, t4, t5, t6, t7, t8));
+              return ts2.apply(t1).flatMap(t2 -> {
+                return ts3.apply(t1, t2).flatMap(t3 -> {
+                  return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                    return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
+                      return ts6.apply(t1, t2, t3, t4, t5).flatMap(t6 -> {
+                        return ts7.apply(t1, t2, t3, t4, t5, t6).flatMap(t7 -> {
+                          return ts8.apply(t1, t2, t3, t4, t5, t6, t7).map(t8 -> f.apply(t1, t2, t3, t4, t5, t6, t7, t8));
+                        });
                       });
                     });
                   });
                 });
               });
             });
-          });
         }
     }
 
@@ -9086,8 +9086,8 @@ private ForLazy2Validation(Validation<L, T1> ts1, Function1<? super T1, Validati
         public <R> Validation<L, R> yield(BiFunction<? super T1, ? super T2, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).map(t2 -> f.apply(t1, t2));
-          });
+              return ts2.apply(t1).map(t2 -> f.apply(t1, t2));
+            });
         }
     }
 
@@ -9129,10 +9129,10 @@ private ForLazy3Validation(Validation<L, T1> ts1, Function1<? super T1, Validati
         public <R> Validation<L, R> yield(Function3<? super T1, ? super T2, ? super T3, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).flatMap(t2 -> {
-              return ts3.apply(t1, t2).map(t3 -> f.apply(t1, t2, t3));
+              return ts2.apply(t1).flatMap(t2 -> {
+                return ts3.apply(t1, t2).map(t3 -> f.apply(t1, t2, t3));
+              });
             });
-          });
         }
     }
 
@@ -9177,12 +9177,12 @@ private ForLazy4Validation(Validation<L, T1> ts1, Function1<? super T1, Validati
         public <R> Validation<L, R> yield(Function4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).flatMap(t2 -> {
-              return ts3.apply(t1, t2).flatMap(t3 -> {
-                return ts4.apply(t1, t2, t3).map(t4 -> f.apply(t1, t2, t3, t4));
+              return ts2.apply(t1).flatMap(t2 -> {
+                return ts3.apply(t1, t2).flatMap(t3 -> {
+                  return ts4.apply(t1, t2, t3).map(t4 -> f.apply(t1, t2, t3, t4));
+                });
               });
             });
-          });
         }
     }
 
@@ -9230,14 +9230,14 @@ private ForLazy5Validation(Validation<L, T1> ts1, Function1<? super T1, Validati
         public <R> Validation<L, R> yield(Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).flatMap(t2 -> {
-              return ts3.apply(t1, t2).flatMap(t3 -> {
-                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
-                  return ts5.apply(t1, t2, t3, t4).map(t5 -> f.apply(t1, t2, t3, t4, t5));
+              return ts2.apply(t1).flatMap(t2 -> {
+                return ts3.apply(t1, t2).flatMap(t3 -> {
+                  return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                    return ts5.apply(t1, t2, t3, t4).map(t5 -> f.apply(t1, t2, t3, t4, t5));
+                  });
                 });
               });
             });
-          });
         }
     }
 
@@ -9288,16 +9288,16 @@ private ForLazy6Validation(Validation<L, T1> ts1, Function1<? super T1, Validati
         public <R> Validation<L, R> yield(Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).flatMap(t2 -> {
-              return ts3.apply(t1, t2).flatMap(t3 -> {
-                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
-                  return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
-                    return ts6.apply(t1, t2, t3, t4, t5).map(t6 -> f.apply(t1, t2, t3, t4, t5, t6));
+              return ts2.apply(t1).flatMap(t2 -> {
+                return ts3.apply(t1, t2).flatMap(t3 -> {
+                  return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                    return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
+                      return ts6.apply(t1, t2, t3, t4, t5).map(t6 -> f.apply(t1, t2, t3, t4, t5, t6));
+                    });
                   });
                 });
               });
             });
-          });
         }
     }
 
@@ -9351,18 +9351,18 @@ private ForLazy7Validation(Validation<L, T1> ts1, Function1<? super T1, Validati
         public <R> Validation<L, R> yield(Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).flatMap(t2 -> {
-              return ts3.apply(t1, t2).flatMap(t3 -> {
-                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
-                  return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
-                    return ts6.apply(t1, t2, t3, t4, t5).flatMap(t6 -> {
-                      return ts7.apply(t1, t2, t3, t4, t5, t6).map(t7 -> f.apply(t1, t2, t3, t4, t5, t6, t7));
+              return ts2.apply(t1).flatMap(t2 -> {
+                return ts3.apply(t1, t2).flatMap(t3 -> {
+                  return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                    return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
+                      return ts6.apply(t1, t2, t3, t4, t5).flatMap(t6 -> {
+                        return ts7.apply(t1, t2, t3, t4, t5, t6).map(t7 -> f.apply(t1, t2, t3, t4, t5, t6, t7));
+                      });
                     });
                   });
                 });
               });
             });
-          });
         }
     }
 
@@ -9419,20 +9419,20 @@ private ForLazy8Validation(Validation<L, T1> ts1, Function1<? super T1, Validati
         public <R> Validation<L, R> yield(Function8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R> f) {
             Objects.requireNonNull(f, "f is null");
             return ts1.flatMap(t1 -> {
-            return ts2.apply(t1).flatMap(t2 -> {
-              return ts3.apply(t1, t2).flatMap(t3 -> {
-                return ts4.apply(t1, t2, t3).flatMap(t4 -> {
-                  return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
-                    return ts6.apply(t1, t2, t3, t4, t5).flatMap(t6 -> {
-                      return ts7.apply(t1, t2, t3, t4, t5, t6).flatMap(t7 -> {
-                        return ts8.apply(t1, t2, t3, t4, t5, t6, t7).map(t8 -> f.apply(t1, t2, t3, t4, t5, t6, t7, t8));
+              return ts2.apply(t1).flatMap(t2 -> {
+                return ts3.apply(t1, t2).flatMap(t3 -> {
+                  return ts4.apply(t1, t2, t3).flatMap(t4 -> {
+                    return ts5.apply(t1, t2, t3, t4).flatMap(t5 -> {
+                      return ts6.apply(t1, t2, t3, t4, t5).flatMap(t6 -> {
+                        return ts7.apply(t1, t2, t3, t4, t5, t6).flatMap(t7 -> {
+                          return ts8.apply(t1, t2, t3, t4, t5, t6, t7).map(t8 -> f.apply(t1, t2, t3, t4, t5, t6, t7, t8));
+                        });
                       });
                     });
                   });
                 });
               });
             });
-          });
         }
     }
 

From 1919ccbf95ca1096d662c3ba3e7bedad872c3cb1 Mon Sep 17 00:00:00 2001
From: Grzegorz Piwowarek <gpiwowarek@gmail.com>
Date: Wed, 5 Nov 2025 18:35:31 +0100
Subject: [PATCH 6/8] tests

---
 vavr/generator/Generator.scala              |  13 +
 vavr/src-gen/test/java/io/vavr/APITest.java | 276 ++++++++++++++++++++
 2 files changed, 289 insertions(+)

diff --git a/vavr/generator/Generator.scala b/vavr/generator/Generator.scala
index 04e8a67d58..d82f9579f9 100644
--- a/vavr/generator/Generator.scala
+++ b/vavr/generator/Generator.scala
@@ -3122,6 +3122,19 @@ def generateTestClasses(): Unit = {
                       ).yield(${(i > 1).gen("(")}${(1 to i).gen(j => s"i$j")(", ")}${(i > 1).gen(")")} -> ${(1 to i).gen(j => s"i$j")(" + ")});
                       $assertThat(result.get()).isEqualTo(${(1 to i).sum});
                   }
+
+                  @$test
+                  public void shouldIterateLazyFor$mtype$i() {
+                      final $mtype<${parameterInset}Integer> result = For(
+                          ${(1 to i).gen(j => if (j == 1) {
+                              s"$mtype.${builderName}($j)"
+                          } else {
+                              val args = (1 until j).map(k => s"r$k").mkString(", ")
+                              s"($args) -> $mtype.${builderName}($j)"
+                          } )(",\n")}
+                      ).yield(${(i > 1).gen("(")}${(1 to i).gen(j => s"i$j")(", ")}${(i > 1).gen(")")} -> ${(1 to i).gen(j => s"i$j")(" + ")});
+                      $assertThat(result.get()).isEqualTo(${(1 to i).sum});
+                  }
                 """})("\n\n"))("\n\n")}
 
                 ${monadicFunctionTypesFor.gen(mtype => (1 to N).gen(i => { xs"""
diff --git a/vavr/src-gen/test/java/io/vavr/APITest.java b/vavr/src-gen/test/java/io/vavr/APITest.java
index f9e8e13d9f..6fac60cecd 100644
--- a/vavr/src-gen/test/java/io/vavr/APITest.java
+++ b/vavr/src-gen/test/java/io/vavr/APITest.java
@@ -1095,6 +1095,14 @@ public void shouldIterateForOption1() {
             assertThat(result.get()).isEqualTo(1);
         }
 
+        @Test
+        public void shouldIterateLazyForOption1() {
+            final Option<Integer> result = For(
+                Option.of(1)
+            ).yield(i1 -> i1);
+            assertThat(result.get()).isEqualTo(1);
+        }
+
         @Test
         public void shouldIterateForOption2() {
             final Option<Integer> result = For(
@@ -1104,6 +1112,15 @@ public void shouldIterateForOption2() {
             assertThat(result.get()).isEqualTo(3);
         }
 
+        @Test
+        public void shouldIterateLazyForOption2() {
+            final Option<Integer> result = For(
+                Option.of(1),
+                (r1) -> Option.of(2)
+            ).yield((i1, i2) -> i1 + i2);
+            assertThat(result.get()).isEqualTo(3);
+        }
+
         @Test
         public void shouldIterateForOption3() {
             final Option<Integer> result = For(
@@ -1114,6 +1131,16 @@ public void shouldIterateForOption3() {
             assertThat(result.get()).isEqualTo(6);
         }
 
+        @Test
+        public void shouldIterateLazyForOption3() {
+            final Option<Integer> result = For(
+                Option.of(1),
+                (r1) -> Option.of(2),
+                (r1, r2) -> Option.of(3)
+            ).yield((i1, i2, i3) -> i1 + i2 + i3);
+            assertThat(result.get()).isEqualTo(6);
+        }
+
         @Test
         public void shouldIterateForOption4() {
             final Option<Integer> result = For(
@@ -1125,6 +1152,17 @@ public void shouldIterateForOption4() {
             assertThat(result.get()).isEqualTo(10);
         }
 
+        @Test
+        public void shouldIterateLazyForOption4() {
+            final Option<Integer> result = For(
+                Option.of(1),
+                (r1) -> Option.of(2),
+                (r1, r2) -> Option.of(3),
+                (r1, r2, r3) -> Option.of(4)
+            ).yield((i1, i2, i3, i4) -> i1 + i2 + i3 + i4);
+            assertThat(result.get()).isEqualTo(10);
+        }
+
         @Test
         public void shouldIterateForOption5() {
             final Option<Integer> result = For(
@@ -1137,6 +1175,18 @@ public void shouldIterateForOption5() {
             assertThat(result.get()).isEqualTo(15);
         }
 
+        @Test
+        public void shouldIterateLazyForOption5() {
+            final Option<Integer> result = For(
+                Option.of(1),
+                (r1) -> Option.of(2),
+                (r1, r2) -> Option.of(3),
+                (r1, r2, r3) -> Option.of(4),
+                (r1, r2, r3, r4) -> Option.of(5)
+            ).yield((i1, i2, i3, i4, i5) -> i1 + i2 + i3 + i4 + i5);
+            assertThat(result.get()).isEqualTo(15);
+        }
+
         @Test
         public void shouldIterateForOption6() {
             final Option<Integer> result = For(
@@ -1150,6 +1200,19 @@ public void shouldIterateForOption6() {
             assertThat(result.get()).isEqualTo(21);
         }
 
+        @Test
+        public void shouldIterateLazyForOption6() {
+            final Option<Integer> result = For(
+                Option.of(1),
+                (r1) -> Option.of(2),
+                (r1, r2) -> Option.of(3),
+                (r1, r2, r3) -> Option.of(4),
+                (r1, r2, r3, r4) -> Option.of(5),
+                (r1, r2, r3, r4, r5) -> Option.of(6)
+            ).yield((i1, i2, i3, i4, i5, i6) -> i1 + i2 + i3 + i4 + i5 + i6);
+            assertThat(result.get()).isEqualTo(21);
+        }
+
         @Test
         public void shouldIterateForOption7() {
             final Option<Integer> result = For(
@@ -1164,6 +1227,20 @@ public void shouldIterateForOption7() {
             assertThat(result.get()).isEqualTo(28);
         }
 
+        @Test
+        public void shouldIterateLazyForOption7() {
+            final Option<Integer> result = For(
+                Option.of(1),
+                (r1) -> Option.of(2),
+                (r1, r2) -> Option.of(3),
+                (r1, r2, r3) -> Option.of(4),
+                (r1, r2, r3, r4) -> Option.of(5),
+                (r1, r2, r3, r4, r5) -> Option.of(6),
+                (r1, r2, r3, r4, r5, r6) -> Option.of(7)
+            ).yield((i1, i2, i3, i4, i5, i6, i7) -> i1 + i2 + i3 + i4 + i5 + i6 + i7);
+            assertThat(result.get()).isEqualTo(28);
+        }
+
         @Test
         public void shouldIterateForOption8() {
             final Option<Integer> result = For(
@@ -1179,6 +1256,21 @@ public void shouldIterateForOption8() {
             assertThat(result.get()).isEqualTo(36);
         }
 
+        @Test
+        public void shouldIterateLazyForOption8() {
+            final Option<Integer> result = For(
+                Option.of(1),
+                (r1) -> Option.of(2),
+                (r1, r2) -> Option.of(3),
+                (r1, r2, r3) -> Option.of(4),
+                (r1, r2, r3, r4) -> Option.of(5),
+                (r1, r2, r3, r4, r5) -> Option.of(6),
+                (r1, r2, r3, r4, r5, r6) -> Option.of(7),
+                (r1, r2, r3, r4, r5, r6, r7) -> Option.of(8)
+            ).yield((i1, i2, i3, i4, i5, i6, i7, i8) -> i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8);
+            assertThat(result.get()).isEqualTo(36);
+        }
+
         @Test
         public void shouldIterateForEither1() {
             final Either<Object, Integer> result = For(
@@ -1187,6 +1279,14 @@ public void shouldIterateForEither1() {
             assertThat(result.get()).isEqualTo(1);
         }
 
+        @Test
+        public void shouldIterateLazyForEither1() {
+            final Either<Object, Integer> result = For(
+                Either.right(1)
+            ).yield(i1 -> i1);
+            assertThat(result.get()).isEqualTo(1);
+        }
+
         @Test
         public void shouldIterateForEither2() {
             final Either<Object, Integer> result = For(
@@ -1196,6 +1296,15 @@ public void shouldIterateForEither2() {
             assertThat(result.get()).isEqualTo(3);
         }
 
+        @Test
+        public void shouldIterateLazyForEither2() {
+            final Either<Object, Integer> result = For(
+                Either.right(1),
+                (r1) -> Either.right(2)
+            ).yield((i1, i2) -> i1 + i2);
+            assertThat(result.get()).isEqualTo(3);
+        }
+
         @Test
         public void shouldIterateForEither3() {
             final Either<Object, Integer> result = For(
@@ -1206,6 +1315,16 @@ public void shouldIterateForEither3() {
             assertThat(result.get()).isEqualTo(6);
         }
 
+        @Test
+        public void shouldIterateLazyForEither3() {
+            final Either<Object, Integer> result = For(
+                Either.right(1),
+                (r1) -> Either.right(2),
+                (r1, r2) -> Either.right(3)
+            ).yield((i1, i2, i3) -> i1 + i2 + i3);
+            assertThat(result.get()).isEqualTo(6);
+        }
+
         @Test
         public void shouldIterateForEither4() {
             final Either<Object, Integer> result = For(
@@ -1217,6 +1336,17 @@ public void shouldIterateForEither4() {
             assertThat(result.get()).isEqualTo(10);
         }
 
+        @Test
+        public void shouldIterateLazyForEither4() {
+            final Either<Object, Integer> result = For(
+                Either.right(1),
+                (r1) -> Either.right(2),
+                (r1, r2) -> Either.right(3),
+                (r1, r2, r3) -> Either.right(4)
+            ).yield((i1, i2, i3, i4) -> i1 + i2 + i3 + i4);
+            assertThat(result.get()).isEqualTo(10);
+        }
+
         @Test
         public void shouldIterateForEither5() {
             final Either<Object, Integer> result = For(
@@ -1229,6 +1359,18 @@ public void shouldIterateForEither5() {
             assertThat(result.get()).isEqualTo(15);
         }
 
+        @Test
+        public void shouldIterateLazyForEither5() {
+            final Either<Object, Integer> result = For(
+                Either.right(1),
+                (r1) -> Either.right(2),
+                (r1, r2) -> Either.right(3),
+                (r1, r2, r3) -> Either.right(4),
+                (r1, r2, r3, r4) -> Either.right(5)
+            ).yield((i1, i2, i3, i4, i5) -> i1 + i2 + i3 + i4 + i5);
+            assertThat(result.get()).isEqualTo(15);
+        }
+
         @Test
         public void shouldIterateForEither6() {
             final Either<Object, Integer> result = For(
@@ -1242,6 +1384,19 @@ public void shouldIterateForEither6() {
             assertThat(result.get()).isEqualTo(21);
         }
 
+        @Test
+        public void shouldIterateLazyForEither6() {
+            final Either<Object, Integer> result = For(
+                Either.right(1),
+                (r1) -> Either.right(2),
+                (r1, r2) -> Either.right(3),
+                (r1, r2, r3) -> Either.right(4),
+                (r1, r2, r3, r4) -> Either.right(5),
+                (r1, r2, r3, r4, r5) -> Either.right(6)
+            ).yield((i1, i2, i3, i4, i5, i6) -> i1 + i2 + i3 + i4 + i5 + i6);
+            assertThat(result.get()).isEqualTo(21);
+        }
+
         @Test
         public void shouldIterateForEither7() {
             final Either<Object, Integer> result = For(
@@ -1256,6 +1411,20 @@ public void shouldIterateForEither7() {
             assertThat(result.get()).isEqualTo(28);
         }
 
+        @Test
+        public void shouldIterateLazyForEither7() {
+            final Either<Object, Integer> result = For(
+                Either.right(1),
+                (r1) -> Either.right(2),
+                (r1, r2) -> Either.right(3),
+                (r1, r2, r3) -> Either.right(4),
+                (r1, r2, r3, r4) -> Either.right(5),
+                (r1, r2, r3, r4, r5) -> Either.right(6),
+                (r1, r2, r3, r4, r5, r6) -> Either.right(7)
+            ).yield((i1, i2, i3, i4, i5, i6, i7) -> i1 + i2 + i3 + i4 + i5 + i6 + i7);
+            assertThat(result.get()).isEqualTo(28);
+        }
+
         @Test
         public void shouldIterateForEither8() {
             final Either<Object, Integer> result = For(
@@ -1271,6 +1440,21 @@ public void shouldIterateForEither8() {
             assertThat(result.get()).isEqualTo(36);
         }
 
+        @Test
+        public void shouldIterateLazyForEither8() {
+            final Either<Object, Integer> result = For(
+                Either.right(1),
+                (r1) -> Either.right(2),
+                (r1, r2) -> Either.right(3),
+                (r1, r2, r3) -> Either.right(4),
+                (r1, r2, r3, r4) -> Either.right(5),
+                (r1, r2, r3, r4, r5) -> Either.right(6),
+                (r1, r2, r3, r4, r5, r6) -> Either.right(7),
+                (r1, r2, r3, r4, r5, r6, r7) -> Either.right(8)
+            ).yield((i1, i2, i3, i4, i5, i6, i7, i8) -> i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8);
+            assertThat(result.get()).isEqualTo(36);
+        }
+
         @Test
         public void shouldIterateForValidation1() {
             final Validation<Object, Integer> result = For(
@@ -1279,6 +1463,14 @@ public void shouldIterateForValidation1() {
             assertThat(result.get()).isEqualTo(1);
         }
 
+        @Test
+        public void shouldIterateLazyForValidation1() {
+            final Validation<Object, Integer> result = For(
+                Validation.valid(1)
+            ).yield(i1 -> i1);
+            assertThat(result.get()).isEqualTo(1);
+        }
+
         @Test
         public void shouldIterateForValidation2() {
             final Validation<Object, Integer> result = For(
@@ -1288,6 +1480,15 @@ public void shouldIterateForValidation2() {
             assertThat(result.get()).isEqualTo(3);
         }
 
+        @Test
+        public void shouldIterateLazyForValidation2() {
+            final Validation<Object, Integer> result = For(
+                Validation.valid(1),
+                (r1) -> Validation.valid(2)
+            ).yield((i1, i2) -> i1 + i2);
+            assertThat(result.get()).isEqualTo(3);
+        }
+
         @Test
         public void shouldIterateForValidation3() {
             final Validation<Object, Integer> result = For(
@@ -1298,6 +1499,16 @@ public void shouldIterateForValidation3() {
             assertThat(result.get()).isEqualTo(6);
         }
 
+        @Test
+        public void shouldIterateLazyForValidation3() {
+            final Validation<Object, Integer> result = For(
+                Validation.valid(1),
+                (r1) -> Validation.valid(2),
+                (r1, r2) -> Validation.valid(3)
+            ).yield((i1, i2, i3) -> i1 + i2 + i3);
+            assertThat(result.get()).isEqualTo(6);
+        }
+
         @Test
         public void shouldIterateForValidation4() {
             final Validation<Object, Integer> result = For(
@@ -1309,6 +1520,17 @@ public void shouldIterateForValidation4() {
             assertThat(result.get()).isEqualTo(10);
         }
 
+        @Test
+        public void shouldIterateLazyForValidation4() {
+            final Validation<Object, Integer> result = For(
+                Validation.valid(1),
+                (r1) -> Validation.valid(2),
+                (r1, r2) -> Validation.valid(3),
+                (r1, r2, r3) -> Validation.valid(4)
+            ).yield((i1, i2, i3, i4) -> i1 + i2 + i3 + i4);
+            assertThat(result.get()).isEqualTo(10);
+        }
+
         @Test
         public void shouldIterateForValidation5() {
             final Validation<Object, Integer> result = For(
@@ -1321,6 +1543,18 @@ public void shouldIterateForValidation5() {
             assertThat(result.get()).isEqualTo(15);
         }
 
+        @Test
+        public void shouldIterateLazyForValidation5() {
+            final Validation<Object, Integer> result = For(
+                Validation.valid(1),
+                (r1) -> Validation.valid(2),
+                (r1, r2) -> Validation.valid(3),
+                (r1, r2, r3) -> Validation.valid(4),
+                (r1, r2, r3, r4) -> Validation.valid(5)
+            ).yield((i1, i2, i3, i4, i5) -> i1 + i2 + i3 + i4 + i5);
+            assertThat(result.get()).isEqualTo(15);
+        }
+
         @Test
         public void shouldIterateForValidation6() {
             final Validation<Object, Integer> result = For(
@@ -1334,6 +1568,19 @@ public void shouldIterateForValidation6() {
             assertThat(result.get()).isEqualTo(21);
         }
 
+        @Test
+        public void shouldIterateLazyForValidation6() {
+            final Validation<Object, Integer> result = For(
+                Validation.valid(1),
+                (r1) -> Validation.valid(2),
+                (r1, r2) -> Validation.valid(3),
+                (r1, r2, r3) -> Validation.valid(4),
+                (r1, r2, r3, r4) -> Validation.valid(5),
+                (r1, r2, r3, r4, r5) -> Validation.valid(6)
+            ).yield((i1, i2, i3, i4, i5, i6) -> i1 + i2 + i3 + i4 + i5 + i6);
+            assertThat(result.get()).isEqualTo(21);
+        }
+
         @Test
         public void shouldIterateForValidation7() {
             final Validation<Object, Integer> result = For(
@@ -1348,6 +1595,20 @@ public void shouldIterateForValidation7() {
             assertThat(result.get()).isEqualTo(28);
         }
 
+        @Test
+        public void shouldIterateLazyForValidation7() {
+            final Validation<Object, Integer> result = For(
+                Validation.valid(1),
+                (r1) -> Validation.valid(2),
+                (r1, r2) -> Validation.valid(3),
+                (r1, r2, r3) -> Validation.valid(4),
+                (r1, r2, r3, r4) -> Validation.valid(5),
+                (r1, r2, r3, r4, r5) -> Validation.valid(6),
+                (r1, r2, r3, r4, r5, r6) -> Validation.valid(7)
+            ).yield((i1, i2, i3, i4, i5, i6, i7) -> i1 + i2 + i3 + i4 + i5 + i6 + i7);
+            assertThat(result.get()).isEqualTo(28);
+        }
+
         @Test
         public void shouldIterateForValidation8() {
             final Validation<Object, Integer> result = For(
@@ -1363,6 +1624,21 @@ public void shouldIterateForValidation8() {
             assertThat(result.get()).isEqualTo(36);
         }
 
+        @Test
+        public void shouldIterateLazyForValidation8() {
+            final Validation<Object, Integer> result = For(
+                Validation.valid(1),
+                (r1) -> Validation.valid(2),
+                (r1, r2) -> Validation.valid(3),
+                (r1, r2, r3) -> Validation.valid(4),
+                (r1, r2, r3, r4) -> Validation.valid(5),
+                (r1, r2, r3, r4, r5) -> Validation.valid(6),
+                (r1, r2, r3, r4, r5, r6) -> Validation.valid(7),
+                (r1, r2, r3, r4, r5, r6, r7) -> Validation.valid(8)
+            ).yield((i1, i2, i3, i4, i5, i6, i7, i8) -> i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8);
+            assertThat(result.get()).isEqualTo(36);
+        }
+
         @Test
         public void shouldIterateForFuture1() {
             final Future<Integer> result = For(

From 4fea8b507a711a5fec8beaf4e0e08e5bb78e53e2 Mon Sep 17 00:00:00 2001
From: Grzegorz Piwowarek <gpiwowarek@gmail.com>
Date: Wed, 5 Nov 2025 19:01:33 +0100
Subject: [PATCH 7/8] better tests

---
 vavr/generator/Generator.scala              |  10 +-
 vavr/src-gen/test/java/io/vavr/APITest.java | 312 +++++++++++++-------
 2 files changed, 212 insertions(+), 110 deletions(-)

diff --git a/vavr/generator/Generator.scala b/vavr/generator/Generator.scala
index d82f9579f9..99f6206fe1 100644
--- a/vavr/generator/Generator.scala
+++ b/vavr/generator/Generator.scala
@@ -3130,13 +3130,19 @@ def generateTestClasses(): Unit = {
                               s"$mtype.${builderName}($j)"
                           } else {
                               val args = (1 until j).map(k => s"r$k").mkString(", ")
-                              s"($args) -> $mtype.${builderName}($j)"
+                              val argsUsed = (1 until j).map(k => s"r$k").mkString(" + ")
+                              s"($args) -> $mtype.${builderName}(${argsUsed} + $j)"
                           } )(",\n")}
                       ).yield(${(i > 1).gen("(")}${(1 to i).gen(j => s"i$j")(", ")}${(i > 1).gen(")")} -> ${(1 to i).gen(j => s"i$j")(" + ")});
-                      $assertThat(result.get()).isEqualTo(${(1 to i).sum});
+
+                      // Each step builds on the sum of all previous results plus its index
+                      // This forms a sequence rₙ = 2ⁿ - 1, and the yield sums all rᵢ.
+                      // Hence total = Σ(2ⁱ - 1) for i = 1..n = (2ⁿ⁺¹ - 2) - n
+                      assertThat(result.get()).isEqualTo((1 << ($i + 1)) - 2 - $i);
                   }
                 """})("\n\n"))("\n\n")}
 
+
                 ${monadicFunctionTypesFor.gen(mtype => (1 to N).gen(i => { xs"""
                   @$test
                   public void shouldIterateFor$mtype$i() {
diff --git a/vavr/src-gen/test/java/io/vavr/APITest.java b/vavr/src-gen/test/java/io/vavr/APITest.java
index 6fac60cecd..e2aae86fa5 100644
--- a/vavr/src-gen/test/java/io/vavr/APITest.java
+++ b/vavr/src-gen/test/java/io/vavr/APITest.java
@@ -1100,7 +1100,11 @@ public void shouldIterateLazyForOption1() {
             final Option<Integer> result = For(
                 Option.of(1)
             ).yield(i1 -> i1);
-            assertThat(result.get()).isEqualTo(1);
+
+            // Each step builds on the sum of all previous results plus its index
+            // This forms a sequence rₙ = 2ⁿ - 1, and the yield sums all rᵢ.
+            // Hence total = Σ(2ⁱ - 1) for i = 1..n = (2ⁿ⁺¹ - 2) - n
+            assertThat(result.get()).isEqualTo((1 << (1 + 1)) - 2 - 1);
         }
 
         @Test
@@ -1116,9 +1120,13 @@ public void shouldIterateForOption2() {
         public void shouldIterateLazyForOption2() {
             final Option<Integer> result = For(
                 Option.of(1),
-                (r1) -> Option.of(2)
+                (r1) -> Option.of(r1 + 2)
             ).yield((i1, i2) -> i1 + i2);
-            assertThat(result.get()).isEqualTo(3);
+
+            // Each step builds on the sum of all previous results plus its index
+            // This forms a sequence rₙ = 2ⁿ - 1, and the yield sums all rᵢ.
+            // Hence total = Σ(2ⁱ - 1) for i = 1..n = (2ⁿ⁺¹ - 2) - n
+            assertThat(result.get()).isEqualTo((1 << (2 + 1)) - 2 - 2);
         }
 
         @Test
@@ -1135,10 +1143,14 @@ public void shouldIterateForOption3() {
         public void shouldIterateLazyForOption3() {
             final Option<Integer> result = For(
                 Option.of(1),
-                (r1) -> Option.of(2),
-                (r1, r2) -> Option.of(3)
+                (r1) -> Option.of(r1 + 2),
+                (r1, r2) -> Option.of(r1 + r2 + 3)
             ).yield((i1, i2, i3) -> i1 + i2 + i3);
-            assertThat(result.get()).isEqualTo(6);
+
+            // Each step builds on the sum of all previous results plus its index
+            // This forms a sequence rₙ = 2ⁿ - 1, and the yield sums all rᵢ.
+            // Hence total = Σ(2ⁱ - 1) for i = 1..n = (2ⁿ⁺¹ - 2) - n
+            assertThat(result.get()).isEqualTo((1 << (3 + 1)) - 2 - 3);
         }
 
         @Test
@@ -1156,11 +1168,15 @@ public void shouldIterateForOption4() {
         public void shouldIterateLazyForOption4() {
             final Option<Integer> result = For(
                 Option.of(1),
-                (r1) -> Option.of(2),
-                (r1, r2) -> Option.of(3),
-                (r1, r2, r3) -> Option.of(4)
+                (r1) -> Option.of(r1 + 2),
+                (r1, r2) -> Option.of(r1 + r2 + 3),
+                (r1, r2, r3) -> Option.of(r1 + r2 + r3 + 4)
             ).yield((i1, i2, i3, i4) -> i1 + i2 + i3 + i4);
-            assertThat(result.get()).isEqualTo(10);
+
+            // Each step builds on the sum of all previous results plus its index
+            // This forms a sequence rₙ = 2ⁿ - 1, and the yield sums all rᵢ.
+            // Hence total = Σ(2ⁱ - 1) for i = 1..n = (2ⁿ⁺¹ - 2) - n
+            assertThat(result.get()).isEqualTo((1 << (4 + 1)) - 2 - 4);
         }
 
         @Test
@@ -1179,12 +1195,16 @@ public void shouldIterateForOption5() {
         public void shouldIterateLazyForOption5() {
             final Option<Integer> result = For(
                 Option.of(1),
-                (r1) -> Option.of(2),
-                (r1, r2) -> Option.of(3),
-                (r1, r2, r3) -> Option.of(4),
-                (r1, r2, r3, r4) -> Option.of(5)
+                (r1) -> Option.of(r1 + 2),
+                (r1, r2) -> Option.of(r1 + r2 + 3),
+                (r1, r2, r3) -> Option.of(r1 + r2 + r3 + 4),
+                (r1, r2, r3, r4) -> Option.of(r1 + r2 + r3 + r4 + 5)
             ).yield((i1, i2, i3, i4, i5) -> i1 + i2 + i3 + i4 + i5);
-            assertThat(result.get()).isEqualTo(15);
+
+            // Each step builds on the sum of all previous results plus its index
+            // This forms a sequence rₙ = 2ⁿ - 1, and the yield sums all rᵢ.
+            // Hence total = Σ(2ⁱ - 1) for i = 1..n = (2ⁿ⁺¹ - 2) - n
+            assertThat(result.get()).isEqualTo((1 << (5 + 1)) - 2 - 5);
         }
 
         @Test
@@ -1204,13 +1224,17 @@ public void shouldIterateForOption6() {
         public void shouldIterateLazyForOption6() {
             final Option<Integer> result = For(
                 Option.of(1),
-                (r1) -> Option.of(2),
-                (r1, r2) -> Option.of(3),
-                (r1, r2, r3) -> Option.of(4),
-                (r1, r2, r3, r4) -> Option.of(5),
-                (r1, r2, r3, r4, r5) -> Option.of(6)
+                (r1) -> Option.of(r1 + 2),
+                (r1, r2) -> Option.of(r1 + r2 + 3),
+                (r1, r2, r3) -> Option.of(r1 + r2 + r3 + 4),
+                (r1, r2, r3, r4) -> Option.of(r1 + r2 + r3 + r4 + 5),
+                (r1, r2, r3, r4, r5) -> Option.of(r1 + r2 + r3 + r4 + r5 + 6)
             ).yield((i1, i2, i3, i4, i5, i6) -> i1 + i2 + i3 + i4 + i5 + i6);
-            assertThat(result.get()).isEqualTo(21);
+
+            // Each step builds on the sum of all previous results plus its index
+            // This forms a sequence rₙ = 2ⁿ - 1, and the yield sums all rᵢ.
+            // Hence total = Σ(2ⁱ - 1) for i = 1..n = (2ⁿ⁺¹ - 2) - n
+            assertThat(result.get()).isEqualTo((1 << (6 + 1)) - 2 - 6);
         }
 
         @Test
@@ -1231,14 +1255,18 @@ public void shouldIterateForOption7() {
         public void shouldIterateLazyForOption7() {
             final Option<Integer> result = For(
                 Option.of(1),
-                (r1) -> Option.of(2),
-                (r1, r2) -> Option.of(3),
-                (r1, r2, r3) -> Option.of(4),
-                (r1, r2, r3, r4) -> Option.of(5),
-                (r1, r2, r3, r4, r5) -> Option.of(6),
-                (r1, r2, r3, r4, r5, r6) -> Option.of(7)
+                (r1) -> Option.of(r1 + 2),
+                (r1, r2) -> Option.of(r1 + r2 + 3),
+                (r1, r2, r3) -> Option.of(r1 + r2 + r3 + 4),
+                (r1, r2, r3, r4) -> Option.of(r1 + r2 + r3 + r4 + 5),
+                (r1, r2, r3, r4, r5) -> Option.of(r1 + r2 + r3 + r4 + r5 + 6),
+                (r1, r2, r3, r4, r5, r6) -> Option.of(r1 + r2 + r3 + r4 + r5 + r6 + 7)
             ).yield((i1, i2, i3, i4, i5, i6, i7) -> i1 + i2 + i3 + i4 + i5 + i6 + i7);
-            assertThat(result.get()).isEqualTo(28);
+
+            // Each step builds on the sum of all previous results plus its index
+            // This forms a sequence rₙ = 2ⁿ - 1, and the yield sums all rᵢ.
+            // Hence total = Σ(2ⁱ - 1) for i = 1..n = (2ⁿ⁺¹ - 2) - n
+            assertThat(result.get()).isEqualTo((1 << (7 + 1)) - 2 - 7);
         }
 
         @Test
@@ -1260,15 +1288,19 @@ public void shouldIterateForOption8() {
         public void shouldIterateLazyForOption8() {
             final Option<Integer> result = For(
                 Option.of(1),
-                (r1) -> Option.of(2),
-                (r1, r2) -> Option.of(3),
-                (r1, r2, r3) -> Option.of(4),
-                (r1, r2, r3, r4) -> Option.of(5),
-                (r1, r2, r3, r4, r5) -> Option.of(6),
-                (r1, r2, r3, r4, r5, r6) -> Option.of(7),
-                (r1, r2, r3, r4, r5, r6, r7) -> Option.of(8)
+                (r1) -> Option.of(r1 + 2),
+                (r1, r2) -> Option.of(r1 + r2 + 3),
+                (r1, r2, r3) -> Option.of(r1 + r2 + r3 + 4),
+                (r1, r2, r3, r4) -> Option.of(r1 + r2 + r3 + r4 + 5),
+                (r1, r2, r3, r4, r5) -> Option.of(r1 + r2 + r3 + r4 + r5 + 6),
+                (r1, r2, r3, r4, r5, r6) -> Option.of(r1 + r2 + r3 + r4 + r5 + r6 + 7),
+                (r1, r2, r3, r4, r5, r6, r7) -> Option.of(r1 + r2 + r3 + r4 + r5 + r6 + r7 + 8)
             ).yield((i1, i2, i3, i4, i5, i6, i7, i8) -> i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8);
-            assertThat(result.get()).isEqualTo(36);
+
+            // Each step builds on the sum of all previous results plus its index
+            // This forms a sequence rₙ = 2ⁿ - 1, and the yield sums all rᵢ.
+            // Hence total = Σ(2ⁱ - 1) for i = 1..n = (2ⁿ⁺¹ - 2) - n
+            assertThat(result.get()).isEqualTo((1 << (8 + 1)) - 2 - 8);
         }
 
         @Test
@@ -1284,7 +1316,11 @@ public void shouldIterateLazyForEither1() {
             final Either<Object, Integer> result = For(
                 Either.right(1)
             ).yield(i1 -> i1);
-            assertThat(result.get()).isEqualTo(1);
+
+            // Each step builds on the sum of all previous results plus its index
+            // This forms a sequence rₙ = 2ⁿ - 1, and the yield sums all rᵢ.
+            // Hence total = Σ(2ⁱ - 1) for i = 1..n = (2ⁿ⁺¹ - 2) - n
+            assertThat(result.get()).isEqualTo((1 << (1 + 1)) - 2 - 1);
         }
 
         @Test
@@ -1300,9 +1336,13 @@ public void shouldIterateForEither2() {
         public void shouldIterateLazyForEither2() {
             final Either<Object, Integer> result = For(
                 Either.right(1),
-                (r1) -> Either.right(2)
+                (r1) -> Either.right(r1 + 2)
             ).yield((i1, i2) -> i1 + i2);
-            assertThat(result.get()).isEqualTo(3);
+
+            // Each step builds on the sum of all previous results plus its index
+            // This forms a sequence rₙ = 2ⁿ - 1, and the yield sums all rᵢ.
+            // Hence total = Σ(2ⁱ - 1) for i = 1..n = (2ⁿ⁺¹ - 2) - n
+            assertThat(result.get()).isEqualTo((1 << (2 + 1)) - 2 - 2);
         }
 
         @Test
@@ -1319,10 +1359,14 @@ public void shouldIterateForEither3() {
         public void shouldIterateLazyForEither3() {
             final Either<Object, Integer> result = For(
                 Either.right(1),
-                (r1) -> Either.right(2),
-                (r1, r2) -> Either.right(3)
+                (r1) -> Either.right(r1 + 2),
+                (r1, r2) -> Either.right(r1 + r2 + 3)
             ).yield((i1, i2, i3) -> i1 + i2 + i3);
-            assertThat(result.get()).isEqualTo(6);
+
+            // Each step builds on the sum of all previous results plus its index
+            // This forms a sequence rₙ = 2ⁿ - 1, and the yield sums all rᵢ.
+            // Hence total = Σ(2ⁱ - 1) for i = 1..n = (2ⁿ⁺¹ - 2) - n
+            assertThat(result.get()).isEqualTo((1 << (3 + 1)) - 2 - 3);
         }
 
         @Test
@@ -1340,11 +1384,15 @@ public void shouldIterateForEither4() {
         public void shouldIterateLazyForEither4() {
             final Either<Object, Integer> result = For(
                 Either.right(1),
-                (r1) -> Either.right(2),
-                (r1, r2) -> Either.right(3),
-                (r1, r2, r3) -> Either.right(4)
+                (r1) -> Either.right(r1 + 2),
+                (r1, r2) -> Either.right(r1 + r2 + 3),
+                (r1, r2, r3) -> Either.right(r1 + r2 + r3 + 4)
             ).yield((i1, i2, i3, i4) -> i1 + i2 + i3 + i4);
-            assertThat(result.get()).isEqualTo(10);
+
+            // Each step builds on the sum of all previous results plus its index
+            // This forms a sequence rₙ = 2ⁿ - 1, and the yield sums all rᵢ.
+            // Hence total = Σ(2ⁱ - 1) for i = 1..n = (2ⁿ⁺¹ - 2) - n
+            assertThat(result.get()).isEqualTo((1 << (4 + 1)) - 2 - 4);
         }
 
         @Test
@@ -1363,12 +1411,16 @@ public void shouldIterateForEither5() {
         public void shouldIterateLazyForEither5() {
             final Either<Object, Integer> result = For(
                 Either.right(1),
-                (r1) -> Either.right(2),
-                (r1, r2) -> Either.right(3),
-                (r1, r2, r3) -> Either.right(4),
-                (r1, r2, r3, r4) -> Either.right(5)
+                (r1) -> Either.right(r1 + 2),
+                (r1, r2) -> Either.right(r1 + r2 + 3),
+                (r1, r2, r3) -> Either.right(r1 + r2 + r3 + 4),
+                (r1, r2, r3, r4) -> Either.right(r1 + r2 + r3 + r4 + 5)
             ).yield((i1, i2, i3, i4, i5) -> i1 + i2 + i3 + i4 + i5);
-            assertThat(result.get()).isEqualTo(15);
+
+            // Each step builds on the sum of all previous results plus its index
+            // This forms a sequence rₙ = 2ⁿ - 1, and the yield sums all rᵢ.
+            // Hence total = Σ(2ⁱ - 1) for i = 1..n = (2ⁿ⁺¹ - 2) - n
+            assertThat(result.get()).isEqualTo((1 << (5 + 1)) - 2 - 5);
         }
 
         @Test
@@ -1388,13 +1440,17 @@ public void shouldIterateForEither6() {
         public void shouldIterateLazyForEither6() {
             final Either<Object, Integer> result = For(
                 Either.right(1),
-                (r1) -> Either.right(2),
-                (r1, r2) -> Either.right(3),
-                (r1, r2, r3) -> Either.right(4),
-                (r1, r2, r3, r4) -> Either.right(5),
-                (r1, r2, r3, r4, r5) -> Either.right(6)
+                (r1) -> Either.right(r1 + 2),
+                (r1, r2) -> Either.right(r1 + r2 + 3),
+                (r1, r2, r3) -> Either.right(r1 + r2 + r3 + 4),
+                (r1, r2, r3, r4) -> Either.right(r1 + r2 + r3 + r4 + 5),
+                (r1, r2, r3, r4, r5) -> Either.right(r1 + r2 + r3 + r4 + r5 + 6)
             ).yield((i1, i2, i3, i4, i5, i6) -> i1 + i2 + i3 + i4 + i5 + i6);
-            assertThat(result.get()).isEqualTo(21);
+
+            // Each step builds on the sum of all previous results plus its index
+            // This forms a sequence rₙ = 2ⁿ - 1, and the yield sums all rᵢ.
+            // Hence total = Σ(2ⁱ - 1) for i = 1..n = (2ⁿ⁺¹ - 2) - n
+            assertThat(result.get()).isEqualTo((1 << (6 + 1)) - 2 - 6);
         }
 
         @Test
@@ -1415,14 +1471,18 @@ public void shouldIterateForEither7() {
         public void shouldIterateLazyForEither7() {
             final Either<Object, Integer> result = For(
                 Either.right(1),
-                (r1) -> Either.right(2),
-                (r1, r2) -> Either.right(3),
-                (r1, r2, r3) -> Either.right(4),
-                (r1, r2, r3, r4) -> Either.right(5),
-                (r1, r2, r3, r4, r5) -> Either.right(6),
-                (r1, r2, r3, r4, r5, r6) -> Either.right(7)
+                (r1) -> Either.right(r1 + 2),
+                (r1, r2) -> Either.right(r1 + r2 + 3),
+                (r1, r2, r3) -> Either.right(r1 + r2 + r3 + 4),
+                (r1, r2, r3, r4) -> Either.right(r1 + r2 + r3 + r4 + 5),
+                (r1, r2, r3, r4, r5) -> Either.right(r1 + r2 + r3 + r4 + r5 + 6),
+                (r1, r2, r3, r4, r5, r6) -> Either.right(r1 + r2 + r3 + r4 + r5 + r6 + 7)
             ).yield((i1, i2, i3, i4, i5, i6, i7) -> i1 + i2 + i3 + i4 + i5 + i6 + i7);
-            assertThat(result.get()).isEqualTo(28);
+
+            // Each step builds on the sum of all previous results plus its index
+            // This forms a sequence rₙ = 2ⁿ - 1, and the yield sums all rᵢ.
+            // Hence total = Σ(2ⁱ - 1) for i = 1..n = (2ⁿ⁺¹ - 2) - n
+            assertThat(result.get()).isEqualTo((1 << (7 + 1)) - 2 - 7);
         }
 
         @Test
@@ -1444,15 +1504,19 @@ public void shouldIterateForEither8() {
         public void shouldIterateLazyForEither8() {
             final Either<Object, Integer> result = For(
                 Either.right(1),
-                (r1) -> Either.right(2),
-                (r1, r2) -> Either.right(3),
-                (r1, r2, r3) -> Either.right(4),
-                (r1, r2, r3, r4) -> Either.right(5),
-                (r1, r2, r3, r4, r5) -> Either.right(6),
-                (r1, r2, r3, r4, r5, r6) -> Either.right(7),
-                (r1, r2, r3, r4, r5, r6, r7) -> Either.right(8)
+                (r1) -> Either.right(r1 + 2),
+                (r1, r2) -> Either.right(r1 + r2 + 3),
+                (r1, r2, r3) -> Either.right(r1 + r2 + r3 + 4),
+                (r1, r2, r3, r4) -> Either.right(r1 + r2 + r3 + r4 + 5),
+                (r1, r2, r3, r4, r5) -> Either.right(r1 + r2 + r3 + r4 + r5 + 6),
+                (r1, r2, r3, r4, r5, r6) -> Either.right(r1 + r2 + r3 + r4 + r5 + r6 + 7),
+                (r1, r2, r3, r4, r5, r6, r7) -> Either.right(r1 + r2 + r3 + r4 + r5 + r6 + r7 + 8)
             ).yield((i1, i2, i3, i4, i5, i6, i7, i8) -> i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8);
-            assertThat(result.get()).isEqualTo(36);
+
+            // Each step builds on the sum of all previous results plus its index
+            // This forms a sequence rₙ = 2ⁿ - 1, and the yield sums all rᵢ.
+            // Hence total = Σ(2ⁱ - 1) for i = 1..n = (2ⁿ⁺¹ - 2) - n
+            assertThat(result.get()).isEqualTo((1 << (8 + 1)) - 2 - 8);
         }
 
         @Test
@@ -1468,7 +1532,11 @@ public void shouldIterateLazyForValidation1() {
             final Validation<Object, Integer> result = For(
                 Validation.valid(1)
             ).yield(i1 -> i1);
-            assertThat(result.get()).isEqualTo(1);
+
+            // Each step builds on the sum of all previous results plus its index
+            // This forms a sequence rₙ = 2ⁿ - 1, and the yield sums all rᵢ.
+            // Hence total = Σ(2ⁱ - 1) for i = 1..n = (2ⁿ⁺¹ - 2) - n
+            assertThat(result.get()).isEqualTo((1 << (1 + 1)) - 2 - 1);
         }
 
         @Test
@@ -1484,9 +1552,13 @@ public void shouldIterateForValidation2() {
         public void shouldIterateLazyForValidation2() {
             final Validation<Object, Integer> result = For(
                 Validation.valid(1),
-                (r1) -> Validation.valid(2)
+                (r1) -> Validation.valid(r1 + 2)
             ).yield((i1, i2) -> i1 + i2);
-            assertThat(result.get()).isEqualTo(3);
+
+            // Each step builds on the sum of all previous results plus its index
+            // This forms a sequence rₙ = 2ⁿ - 1, and the yield sums all rᵢ.
+            // Hence total = Σ(2ⁱ - 1) for i = 1..n = (2ⁿ⁺¹ - 2) - n
+            assertThat(result.get()).isEqualTo((1 << (2 + 1)) - 2 - 2);
         }
 
         @Test
@@ -1503,10 +1575,14 @@ public void shouldIterateForValidation3() {
         public void shouldIterateLazyForValidation3() {
             final Validation<Object, Integer> result = For(
                 Validation.valid(1),
-                (r1) -> Validation.valid(2),
-                (r1, r2) -> Validation.valid(3)
+                (r1) -> Validation.valid(r1 + 2),
+                (r1, r2) -> Validation.valid(r1 + r2 + 3)
             ).yield((i1, i2, i3) -> i1 + i2 + i3);
-            assertThat(result.get()).isEqualTo(6);
+
+            // Each step builds on the sum of all previous results plus its index
+            // This forms a sequence rₙ = 2ⁿ - 1, and the yield sums all rᵢ.
+            // Hence total = Σ(2ⁱ - 1) for i = 1..n = (2ⁿ⁺¹ - 2) - n
+            assertThat(result.get()).isEqualTo((1 << (3 + 1)) - 2 - 3);
         }
 
         @Test
@@ -1524,11 +1600,15 @@ public void shouldIterateForValidation4() {
         public void shouldIterateLazyForValidation4() {
             final Validation<Object, Integer> result = For(
                 Validation.valid(1),
-                (r1) -> Validation.valid(2),
-                (r1, r2) -> Validation.valid(3),
-                (r1, r2, r3) -> Validation.valid(4)
+                (r1) -> Validation.valid(r1 + 2),
+                (r1, r2) -> Validation.valid(r1 + r2 + 3),
+                (r1, r2, r3) -> Validation.valid(r1 + r2 + r3 + 4)
             ).yield((i1, i2, i3, i4) -> i1 + i2 + i3 + i4);
-            assertThat(result.get()).isEqualTo(10);
+
+            // Each step builds on the sum of all previous results plus its index
+            // This forms a sequence rₙ = 2ⁿ - 1, and the yield sums all rᵢ.
+            // Hence total = Σ(2ⁱ - 1) for i = 1..n = (2ⁿ⁺¹ - 2) - n
+            assertThat(result.get()).isEqualTo((1 << (4 + 1)) - 2 - 4);
         }
 
         @Test
@@ -1547,12 +1627,16 @@ public void shouldIterateForValidation5() {
         public void shouldIterateLazyForValidation5() {
             final Validation<Object, Integer> result = For(
                 Validation.valid(1),
-                (r1) -> Validation.valid(2),
-                (r1, r2) -> Validation.valid(3),
-                (r1, r2, r3) -> Validation.valid(4),
-                (r1, r2, r3, r4) -> Validation.valid(5)
+                (r1) -> Validation.valid(r1 + 2),
+                (r1, r2) -> Validation.valid(r1 + r2 + 3),
+                (r1, r2, r3) -> Validation.valid(r1 + r2 + r3 + 4),
+                (r1, r2, r3, r4) -> Validation.valid(r1 + r2 + r3 + r4 + 5)
             ).yield((i1, i2, i3, i4, i5) -> i1 + i2 + i3 + i4 + i5);
-            assertThat(result.get()).isEqualTo(15);
+
+            // Each step builds on the sum of all previous results plus its index
+            // This forms a sequence rₙ = 2ⁿ - 1, and the yield sums all rᵢ.
+            // Hence total = Σ(2ⁱ - 1) for i = 1..n = (2ⁿ⁺¹ - 2) - n
+            assertThat(result.get()).isEqualTo((1 << (5 + 1)) - 2 - 5);
         }
 
         @Test
@@ -1572,13 +1656,17 @@ public void shouldIterateForValidation6() {
         public void shouldIterateLazyForValidation6() {
             final Validation<Object, Integer> result = For(
                 Validation.valid(1),
-                (r1) -> Validation.valid(2),
-                (r1, r2) -> Validation.valid(3),
-                (r1, r2, r3) -> Validation.valid(4),
-                (r1, r2, r3, r4) -> Validation.valid(5),
-                (r1, r2, r3, r4, r5) -> Validation.valid(6)
+                (r1) -> Validation.valid(r1 + 2),
+                (r1, r2) -> Validation.valid(r1 + r2 + 3),
+                (r1, r2, r3) -> Validation.valid(r1 + r2 + r3 + 4),
+                (r1, r2, r3, r4) -> Validation.valid(r1 + r2 + r3 + r4 + 5),
+                (r1, r2, r3, r4, r5) -> Validation.valid(r1 + r2 + r3 + r4 + r5 + 6)
             ).yield((i1, i2, i3, i4, i5, i6) -> i1 + i2 + i3 + i4 + i5 + i6);
-            assertThat(result.get()).isEqualTo(21);
+
+            // Each step builds on the sum of all previous results plus its index
+            // This forms a sequence rₙ = 2ⁿ - 1, and the yield sums all rᵢ.
+            // Hence total = Σ(2ⁱ - 1) for i = 1..n = (2ⁿ⁺¹ - 2) - n
+            assertThat(result.get()).isEqualTo((1 << (6 + 1)) - 2 - 6);
         }
 
         @Test
@@ -1599,14 +1687,18 @@ public void shouldIterateForValidation7() {
         public void shouldIterateLazyForValidation7() {
             final Validation<Object, Integer> result = For(
                 Validation.valid(1),
-                (r1) -> Validation.valid(2),
-                (r1, r2) -> Validation.valid(3),
-                (r1, r2, r3) -> Validation.valid(4),
-                (r1, r2, r3, r4) -> Validation.valid(5),
-                (r1, r2, r3, r4, r5) -> Validation.valid(6),
-                (r1, r2, r3, r4, r5, r6) -> Validation.valid(7)
+                (r1) -> Validation.valid(r1 + 2),
+                (r1, r2) -> Validation.valid(r1 + r2 + 3),
+                (r1, r2, r3) -> Validation.valid(r1 + r2 + r3 + 4),
+                (r1, r2, r3, r4) -> Validation.valid(r1 + r2 + r3 + r4 + 5),
+                (r1, r2, r3, r4, r5) -> Validation.valid(r1 + r2 + r3 + r4 + r5 + 6),
+                (r1, r2, r3, r4, r5, r6) -> Validation.valid(r1 + r2 + r3 + r4 + r5 + r6 + 7)
             ).yield((i1, i2, i3, i4, i5, i6, i7) -> i1 + i2 + i3 + i4 + i5 + i6 + i7);
-            assertThat(result.get()).isEqualTo(28);
+
+            // Each step builds on the sum of all previous results plus its index
+            // This forms a sequence rₙ = 2ⁿ - 1, and the yield sums all rᵢ.
+            // Hence total = Σ(2ⁱ - 1) for i = 1..n = (2ⁿ⁺¹ - 2) - n
+            assertThat(result.get()).isEqualTo((1 << (7 + 1)) - 2 - 7);
         }
 
         @Test
@@ -1628,15 +1720,19 @@ public void shouldIterateForValidation8() {
         public void shouldIterateLazyForValidation8() {
             final Validation<Object, Integer> result = For(
                 Validation.valid(1),
-                (r1) -> Validation.valid(2),
-                (r1, r2) -> Validation.valid(3),
-                (r1, r2, r3) -> Validation.valid(4),
-                (r1, r2, r3, r4) -> Validation.valid(5),
-                (r1, r2, r3, r4, r5) -> Validation.valid(6),
-                (r1, r2, r3, r4, r5, r6) -> Validation.valid(7),
-                (r1, r2, r3, r4, r5, r6, r7) -> Validation.valid(8)
+                (r1) -> Validation.valid(r1 + 2),
+                (r1, r2) -> Validation.valid(r1 + r2 + 3),
+                (r1, r2, r3) -> Validation.valid(r1 + r2 + r3 + 4),
+                (r1, r2, r3, r4) -> Validation.valid(r1 + r2 + r3 + r4 + 5),
+                (r1, r2, r3, r4, r5) -> Validation.valid(r1 + r2 + r3 + r4 + r5 + 6),
+                (r1, r2, r3, r4, r5, r6) -> Validation.valid(r1 + r2 + r3 + r4 + r5 + r6 + 7),
+                (r1, r2, r3, r4, r5, r6, r7) -> Validation.valid(r1 + r2 + r3 + r4 + r5 + r6 + r7 + 8)
             ).yield((i1, i2, i3, i4, i5, i6, i7, i8) -> i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8);
-            assertThat(result.get()).isEqualTo(36);
+
+            // Each step builds on the sum of all previous results plus its index
+            // This forms a sequence rₙ = 2ⁿ - 1, and the yield sums all rᵢ.
+            // Hence total = Σ(2ⁱ - 1) for i = 1..n = (2ⁿ⁺¹ - 2) - n
+            assertThat(result.get()).isEqualTo((1 << (8 + 1)) - 2 - 8);
         }
 
         @Test

From 9713057d63152368c2bc2ebe3c94e5cd82bb28bc Mon Sep 17 00:00:00 2001
From: Grzegorz Piwowarek <gpiwowarek@gmail.com>
Date: Thu, 6 Nov 2025 08:25:31 +0100
Subject: [PATCH 8/8] better indentation

---
 vavr/generator/Generator.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/vavr/generator/Generator.scala b/vavr/generator/Generator.scala
index 99f6206fe1..2060fdce54 100644
--- a/vavr/generator/Generator.scala
+++ b/vavr/generator/Generator.scala
@@ -820,7 +820,7 @@ def generateMainClasses(): Unit = {
 
               val yieldBody = {
                 def nestedLambda(j: Int): String = {
-                  val base = "                       "
+                  val base = " " * 23
                   val indent = "  " * (j + 1)
                   if (j == i) {
                     val argsList = (1 to i).map(k => s"t$k").mkString(", ")