diff --git a/vavr/generator/Generator.scala b/vavr/generator/Generator.scala
index 7bf4464945..2060fdce54 100644
--- a/vavr/generator/Generator.scala
+++ b/vavr/generator/Generator.scala
@@ -743,6 +743,151 @@ 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"? super 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 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 ""}
+                     ${(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 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"? super 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"? super 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 = " " * 23
+                  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(", ")
+                    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 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")}
+                   */
+                  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 {@code flatMap} and {@code map} chains.</p>
+                       *
+                       * @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}
+                       */
+                      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;
+                      }
+                  }
+                """
+            })("\n\n"))("\n\n")
+        }
+        """
+      }
+
+
       def genFor(im: ImportManager, packageName: String, className: String): String = {
         xs"""
           //
@@ -1440,6 +1585,8 @@ def generateMainClasses(): Unit = {
 
             ${genFor(im, packageName, className)}
 
+            ${genLazyFor(im, packageName, className)}
+
             ${genMatch(im, packageName, className)}
         }
       """
@@ -2975,8 +3122,27 @@ 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(", ")
+                              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")(" + ")});
+
+                      // 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/main/java/io/vavr/API.java b/vavr/src-gen/main/java/io/vavr/API.java
index 99c8a182b1..f1653a5afa 100644
--- a/vavr/src-gen/main/java/io/vavr/API.java
+++ b/vavr/src-gen/main/java/io/vavr/API.java
@@ -5740,6 +5740,3702 @@ 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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? super 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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? 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");
+        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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? 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");
+        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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? 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");
+        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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? 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");
+        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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? 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");
+        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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? 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");
+        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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? super 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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? 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");
+        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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? 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");
+        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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? 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");
+        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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? 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");
+        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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? 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");
+        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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? 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");
+        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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? super 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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? 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");
+        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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? 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");
+        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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? 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");
+        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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? 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");
+        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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? 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");
+        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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? 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");
+        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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? super 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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? 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");
+        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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? 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");
+        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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? 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");
+        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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? 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");
+        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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? 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");
+        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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? 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");
+        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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? super 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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? 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");
+        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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? 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");
+        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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? 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");
+        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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? 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");
+        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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? 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");
+        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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? 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");
+        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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? super 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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? 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");
+        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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? 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");
+        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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? 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");
+        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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? 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");
+        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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? 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");
+        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 method only constructs the
+     * lazy comprehension; underlying effects are evaluated when {@code yield(...)}
+     * is invoked.</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<? 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");
+        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 traversed
+     * only 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<? super T1, Option<T2>> ts2;
+
+        private ForLazy2Option(Option<T1> ts1, Function1<? super 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 {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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 traversed
+     * only 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<? super T1, Option<T2>> ts2;
+        private final Function2<? super T1, ? super 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;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Options by
+         * composing {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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 traversed
+     * only 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<? 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<? 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;
+            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 {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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 traversed
+     * only 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<? 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<? 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;
+            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 {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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 traversed
+     * only 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<? 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<? 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;
+            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 {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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 traversed
+     * only 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<? 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;
+            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 {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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 traversed
+     * only 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<? 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;
+            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 {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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 traversed
+     * only 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<? super T1, Future<T2>> ts2;
+
+        private ForLazy2Future(Future<T1> ts1, Function1<? super 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 {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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 traversed
+     * only 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<? super T1, Future<T2>> ts2;
+        private final Function2<? super T1, ? super 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;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Futures by
+         * composing {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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 traversed
+     * only 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<? 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<? 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;
+            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 {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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 traversed
+     * only 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<? 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<? 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;
+            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 {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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 traversed
+     * only 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<? 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<? 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;
+            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 {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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 traversed
+     * only 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<? 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;
+            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 {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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 traversed
+     * only 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<? 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;
+            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 {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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 traversed
+     * only 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<? super T1, Try<T2>> ts2;
+
+        private ForLazy2Try(Try<T1> ts1, Function1<? super 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 {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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 traversed
+     * only 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<? super T1, Try<T2>> ts2;
+        private final Function2<? super T1, ? super 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;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Trys by
+         * composing {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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 traversed
+     * only 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<? 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<? 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;
+            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 {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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 traversed
+     * only 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<? 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<? 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;
+            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 {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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 traversed
+     * only 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<? 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<? 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;
+            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 {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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 traversed
+     * only 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<? 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;
+            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 {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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 traversed
+     * only 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<? 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;
+            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 {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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 traversed
+     * only 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<? super T1, List<T2>> ts2;
+
+        private ForLazy2List(List<T1> ts1, Function1<? super 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 {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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 traversed
+     * only 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<? super T1, List<T2>> ts2;
+        private final Function2<? super T1, ? super 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;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Lists by
+         * composing {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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 traversed
+     * only 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<? 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<? 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;
+            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 {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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 traversed
+     * only 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<? 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<? 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;
+            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 {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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 traversed
+     * only 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<? 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<? 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;
+            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 {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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 traversed
+     * only 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<? 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;
+            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 {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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 traversed
+     * only 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<? 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;
+            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 {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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 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
+     * @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<? super T1, Either<L, T2>> ts2;
+
+        private ForLazy2Either(Either<L, T1> ts1, Function1<? super 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 {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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 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
+     * @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<? super T1, Either<L, T2>> ts2;
+        private final Function2<? super T1, ? super 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;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Eithers by
+         * composing {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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 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
+     * @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<? 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<? 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;
+            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 {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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 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
+     * @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<? 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<? 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;
+            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 {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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 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
+     * @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<? 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<? 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;
+            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 {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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 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
+     * @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<? 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;
+            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 {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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 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
+     * @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<? 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;
+            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 {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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 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
+     * @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<? super T1, Validation<L, T2>> ts2;
+
+        private ForLazy2Validation(Validation<L, T1> ts1, Function1<? super 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 {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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 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
+     * @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<? super T1, Validation<L, T2>> ts2;
+        private final Function2<? super T1, ? super 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;
+        }
+
+        /**
+         * Produces results by mapping the Cartesian product of all bound values.
+         *
+         * <p>Evaluation is lazy and delegated to the underlying Validations by
+         * composing {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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 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
+     * @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<? 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<? 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;
+            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 {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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 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
+     * @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<? 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<? 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;
+            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 {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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 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
+     * @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<? 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<? 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;
+            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 {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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 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
+     * @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<? 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;
+            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 {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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 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
+     * @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<? 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;
+            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 {@code flatMap} and {@code map} chains.</p>
+         *
+         * @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}
+         */
+        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
     //
diff --git a/vavr/src-gen/test/java/io/vavr/APITest.java b/vavr/src-gen/test/java/io/vavr/APITest.java
index f9e8e13d9f..e2aae86fa5 100644
--- a/vavr/src-gen/test/java/io/vavr/APITest.java
+++ b/vavr/src-gen/test/java/io/vavr/APITest.java
@@ -1095,6 +1095,18 @@ public void shouldIterateForOption1() {
             assertThat(result.get()).isEqualTo(1);
         }
 
+        @Test
+        public void shouldIterateLazyForOption1() {
+            final Option<Integer> result = For(
+                Option.of(1)
+            ).yield(i1 -> i1);
+
+            // 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
         public void shouldIterateForOption2() {
             final Option<Integer> result = For(
@@ -1104,6 +1116,19 @@ public void shouldIterateForOption2() {
             assertThat(result.get()).isEqualTo(3);
         }
 
+        @Test
+        public void shouldIterateLazyForOption2() {
+            final Option<Integer> result = For(
+                Option.of(1),
+                (r1) -> Option.of(r1 + 2)
+            ).yield((i1, i2) -> i1 + i2);
+
+            // 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
         public void shouldIterateForOption3() {
             final Option<Integer> result = For(
@@ -1114,6 +1139,20 @@ public void shouldIterateForOption3() {
             assertThat(result.get()).isEqualTo(6);
         }
 
+        @Test
+        public void shouldIterateLazyForOption3() {
+            final Option<Integer> result = For(
+                Option.of(1),
+                (r1) -> Option.of(r1 + 2),
+                (r1, r2) -> Option.of(r1 + r2 + 3)
+            ).yield((i1, i2, i3) -> i1 + i2 + i3);
+
+            // 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
         public void shouldIterateForOption4() {
             final Option<Integer> result = For(
@@ -1125,6 +1164,21 @@ public void shouldIterateForOption4() {
             assertThat(result.get()).isEqualTo(10);
         }
 
+        @Test
+        public void shouldIterateLazyForOption4() {
+            final Option<Integer> result = For(
+                Option.of(1),
+                (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);
+
+            // 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
         public void shouldIterateForOption5() {
             final Option<Integer> result = For(
@@ -1137,6 +1191,22 @@ public void shouldIterateForOption5() {
             assertThat(result.get()).isEqualTo(15);
         }
 
+        @Test
+        public void shouldIterateLazyForOption5() {
+            final Option<Integer> result = For(
+                Option.of(1),
+                (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);
+
+            // 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
         public void shouldIterateForOption6() {
             final Option<Integer> result = For(
@@ -1150,6 +1220,23 @@ public void shouldIterateForOption6() {
             assertThat(result.get()).isEqualTo(21);
         }
 
+        @Test
+        public void shouldIterateLazyForOption6() {
+            final Option<Integer> result = For(
+                Option.of(1),
+                (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);
+
+            // 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
         public void shouldIterateForOption7() {
             final Option<Integer> result = For(
@@ -1164,6 +1251,24 @@ public void shouldIterateForOption7() {
             assertThat(result.get()).isEqualTo(28);
         }
 
+        @Test
+        public void shouldIterateLazyForOption7() {
+            final Option<Integer> result = For(
+                Option.of(1),
+                (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);
+
+            // 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
         public void shouldIterateForOption8() {
             final Option<Integer> result = For(
@@ -1179,6 +1284,25 @@ public void shouldIterateForOption8() {
             assertThat(result.get()).isEqualTo(36);
         }
 
+        @Test
+        public void shouldIterateLazyForOption8() {
+            final Option<Integer> result = For(
+                Option.of(1),
+                (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);
+
+            // 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
         public void shouldIterateForEither1() {
             final Either<Object, Integer> result = For(
@@ -1187,6 +1311,18 @@ public void shouldIterateForEither1() {
             assertThat(result.get()).isEqualTo(1);
         }
 
+        @Test
+        public void shouldIterateLazyForEither1() {
+            final Either<Object, Integer> result = For(
+                Either.right(1)
+            ).yield(i1 -> i1);
+
+            // 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
         public void shouldIterateForEither2() {
             final Either<Object, Integer> result = For(
@@ -1196,6 +1332,19 @@ public void shouldIterateForEither2() {
             assertThat(result.get()).isEqualTo(3);
         }
 
+        @Test
+        public void shouldIterateLazyForEither2() {
+            final Either<Object, Integer> result = For(
+                Either.right(1),
+                (r1) -> Either.right(r1 + 2)
+            ).yield((i1, i2) -> i1 + i2);
+
+            // 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
         public void shouldIterateForEither3() {
             final Either<Object, Integer> result = For(
@@ -1206,6 +1355,20 @@ public void shouldIterateForEither3() {
             assertThat(result.get()).isEqualTo(6);
         }
 
+        @Test
+        public void shouldIterateLazyForEither3() {
+            final Either<Object, Integer> result = For(
+                Either.right(1),
+                (r1) -> Either.right(r1 + 2),
+                (r1, r2) -> Either.right(r1 + r2 + 3)
+            ).yield((i1, i2, i3) -> i1 + i2 + i3);
+
+            // 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
         public void shouldIterateForEither4() {
             final Either<Object, Integer> result = For(
@@ -1217,6 +1380,21 @@ public void shouldIterateForEither4() {
             assertThat(result.get()).isEqualTo(10);
         }
 
+        @Test
+        public void shouldIterateLazyForEither4() {
+            final Either<Object, Integer> result = For(
+                Either.right(1),
+                (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);
+
+            // 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
         public void shouldIterateForEither5() {
             final Either<Object, Integer> result = For(
@@ -1229,6 +1407,22 @@ public void shouldIterateForEither5() {
             assertThat(result.get()).isEqualTo(15);
         }
 
+        @Test
+        public void shouldIterateLazyForEither5() {
+            final Either<Object, Integer> result = For(
+                Either.right(1),
+                (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);
+
+            // 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
         public void shouldIterateForEither6() {
             final Either<Object, Integer> result = For(
@@ -1242,6 +1436,23 @@ public void shouldIterateForEither6() {
             assertThat(result.get()).isEqualTo(21);
         }
 
+        @Test
+        public void shouldIterateLazyForEither6() {
+            final Either<Object, Integer> result = For(
+                Either.right(1),
+                (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);
+
+            // 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
         public void shouldIterateForEither7() {
             final Either<Object, Integer> result = For(
@@ -1256,6 +1467,24 @@ public void shouldIterateForEither7() {
             assertThat(result.get()).isEqualTo(28);
         }
 
+        @Test
+        public void shouldIterateLazyForEither7() {
+            final Either<Object, Integer> result = For(
+                Either.right(1),
+                (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);
+
+            // 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
         public void shouldIterateForEither8() {
             final Either<Object, Integer> result = For(
@@ -1271,6 +1500,25 @@ public void shouldIterateForEither8() {
             assertThat(result.get()).isEqualTo(36);
         }
 
+        @Test
+        public void shouldIterateLazyForEither8() {
+            final Either<Object, Integer> result = For(
+                Either.right(1),
+                (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);
+
+            // 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
         public void shouldIterateForValidation1() {
             final Validation<Object, Integer> result = For(
@@ -1279,6 +1527,18 @@ public void shouldIterateForValidation1() {
             assertThat(result.get()).isEqualTo(1);
         }
 
+        @Test
+        public void shouldIterateLazyForValidation1() {
+            final Validation<Object, Integer> result = For(
+                Validation.valid(1)
+            ).yield(i1 -> i1);
+
+            // 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
         public void shouldIterateForValidation2() {
             final Validation<Object, Integer> result = For(
@@ -1288,6 +1548,19 @@ public void shouldIterateForValidation2() {
             assertThat(result.get()).isEqualTo(3);
         }
 
+        @Test
+        public void shouldIterateLazyForValidation2() {
+            final Validation<Object, Integer> result = For(
+                Validation.valid(1),
+                (r1) -> Validation.valid(r1 + 2)
+            ).yield((i1, i2) -> i1 + i2);
+
+            // 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
         public void shouldIterateForValidation3() {
             final Validation<Object, Integer> result = For(
@@ -1298,6 +1571,20 @@ public void shouldIterateForValidation3() {
             assertThat(result.get()).isEqualTo(6);
         }
 
+        @Test
+        public void shouldIterateLazyForValidation3() {
+            final Validation<Object, Integer> result = For(
+                Validation.valid(1),
+                (r1) -> Validation.valid(r1 + 2),
+                (r1, r2) -> Validation.valid(r1 + r2 + 3)
+            ).yield((i1, i2, i3) -> i1 + i2 + i3);
+
+            // 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
         public void shouldIterateForValidation4() {
             final Validation<Object, Integer> result = For(
@@ -1309,6 +1596,21 @@ public void shouldIterateForValidation4() {
             assertThat(result.get()).isEqualTo(10);
         }
 
+        @Test
+        public void shouldIterateLazyForValidation4() {
+            final Validation<Object, Integer> result = For(
+                Validation.valid(1),
+                (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);
+
+            // 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
         public void shouldIterateForValidation5() {
             final Validation<Object, Integer> result = For(
@@ -1321,6 +1623,22 @@ public void shouldIterateForValidation5() {
             assertThat(result.get()).isEqualTo(15);
         }
 
+        @Test
+        public void shouldIterateLazyForValidation5() {
+            final Validation<Object, Integer> result = For(
+                Validation.valid(1),
+                (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);
+
+            // 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
         public void shouldIterateForValidation6() {
             final Validation<Object, Integer> result = For(
@@ -1334,6 +1652,23 @@ public void shouldIterateForValidation6() {
             assertThat(result.get()).isEqualTo(21);
         }
 
+        @Test
+        public void shouldIterateLazyForValidation6() {
+            final Validation<Object, Integer> result = For(
+                Validation.valid(1),
+                (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);
+
+            // 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
         public void shouldIterateForValidation7() {
             final Validation<Object, Integer> result = For(
@@ -1348,6 +1683,24 @@ public void shouldIterateForValidation7() {
             assertThat(result.get()).isEqualTo(28);
         }
 
+        @Test
+        public void shouldIterateLazyForValidation7() {
+            final Validation<Object, Integer> result = For(
+                Validation.valid(1),
+                (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);
+
+            // 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
         public void shouldIterateForValidation8() {
             final Validation<Object, Integer> result = For(
@@ -1363,6 +1716,25 @@ public void shouldIterateForValidation8() {
             assertThat(result.get()).isEqualTo(36);
         }
 
+        @Test
+        public void shouldIterateLazyForValidation8() {
+            final Validation<Object, Integer> result = For(
+                Validation.valid(1),
+                (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);
+
+            // 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
         public void shouldIterateForFuture1() {
             final Future<Integer> result = For(