From 161e1624aab4aa7d1540a106659076a498230927 Mon Sep 17 00:00:00 2001
From: Igor <431522+CauchyPeano@users.noreply.github.com>
Date: Sat, 4 Aug 2018 16:01:10 +0200
Subject: [PATCH] Initial implementation of new For() constructs (#1629)
 (#2281)

---
 .../test/java/io/vavr/idiom/ForBenchmark.java |    4 +-
 vavr/generator/Generator.scala                |   67 +-
 vavr/src-gen/main/java/io/vavr/API.java       | 2161 ++++++++++++++---
 vavr/src-gen/test/java/io/vavr/APITest.java   |  295 ++-
 4 files changed, 2132 insertions(+), 395 deletions(-)

diff --git a/vavr-benchmark/src/test/java/io/vavr/idiom/ForBenchmark.java b/vavr-benchmark/src/test/java/io/vavr/idiom/ForBenchmark.java
index 71f711c1ea..21845abb08 100644
--- a/vavr-benchmark/src/test/java/io/vavr/idiom/ForBenchmark.java
+++ b/vavr-benchmark/src/test/java/io/vavr/idiom/ForBenchmark.java
@@ -59,13 +59,13 @@ public static void main(String... args) {
     public static class Base {
         int CONTAINER_SIZE = 1000;
         int AGGREGATE;
-        List<Integer> ELEMENTS;
+        io.vavr.collection.List<Integer> ELEMENTS;
 
         final BiFunction<Integer, Integer, Integer> AGGREGATOR = (i, j) -> i ^ j;
 
         @Setup
         public void setup() {
-            ELEMENTS = Arrays.asList(getRandomValues(CONTAINER_SIZE, 0, true));
+            ELEMENTS = io.vavr.collection.List.ofAll(Arrays.stream(getRandomValues(CONTAINER_SIZE, 0, true)));
 
             AGGREGATE = 0;
             for (Integer i : ELEMENTS) {
diff --git a/vavr/generator/Generator.scala b/vavr/generator/Generator.scala
index 47713c28b7..0a0ebe608d 100644
--- a/vavr/generator/Generator.scala
+++ b/vavr/generator/Generator.scala
@@ -100,6 +100,8 @@ def generateMainClasses(): Unit = {
       val PredicateType = im.getType("java.util.function.Predicate")
       val SupplierType = im.getType("java.util.function.Supplier")
 
+      val monadicTypesFor = List(OptionType, FutureType, TryType, ListType)
+
       def genTraversableAliases(traversableType: String, returnType: String, name: String) = xs"""
         // -- $name
 
@@ -709,24 +711,24 @@ def generateMainClasses(): Unit = {
               return $IteratorType.ofAll(ts).flatMap(f);
           }
 
-          ${(1 to N).gen(i => {
+          ${monadicTypesFor.gen(mtype => (1 to N).gen(i => {
             val generics = (1 to i).gen(j => s"T$j")(", ")
-            val params = (1 to i).gen(j => s"Iterable<T$j> ts$j")(", ")
+            val params = (1 to i).gen(j => s"$mtype<T$j> ts$j")(", ")
             xs"""
               /$javadoc
-               * Creates a {@code For}-comprehension of ${i.numerus("Iterable")}.
-               ${(0 to i).gen(j => if (j == 0) "*" else s"* @param ts$j the ${j.ordinal} Iterable")("\n")}
-               ${(1 to i).gen(j => s"* @param <T$j> component type of the ${j.ordinal} Iterable")("\n")}
+               * Creates a {@code For}-comprehension of ${i.numerus(mtype)}.
+               ${(0 to i).gen(j => if (j == 0) "*" else s"* @param ts$j the ${j.ordinal} $mtype")("\n")}
+               ${(1 to i).gen(j => s"* @param <T$j> component type of the ${j.ordinal} $mtype")("\n")}
                * @return a new {@code For}-comprehension of arity $i
                */
-              public static <$generics> For$i<$generics> For($params) {
+              public static <$generics> For$i$mtype<$generics> For($params) {
                   ${(1 to i).gen(j => xs"""$Objects.requireNonNull(ts$j, "ts$j is null");""")("\n")}
-                  return new For$i<>(${(1 to i).gen(j => s"ts$j")(", ")});
+                  return new For$i$mtype<>(${(1 to i).gen(j => s"ts$j")(", ")});
               }
             """
-          })("\n\n")}
+          })("\n\n"))("\n\n")}
 
-          ${(1 to N).gen(i => {
+           ${monadicTypesFor.gen(mtype => (1 to N).gen(i => {
             val generics = (1 to i).gen(j => s"T$j")(", ")
             val functionType = i match {
               case 1 => FunctionType
@@ -736,13 +738,13 @@ def generateMainClasses(): Unit = {
             val args = (1 to i).gen(j => s"? super T$j")(", ")
             xs"""
               /$javadoc
-               * For-comprehension with ${i.numerus("Iterable")}.
+               * For-comprehension with ${i.numerus(IteratorType)}.
                */
-              public static class For$i<$generics> {
+              public static class For$i$mtype<$generics> {
 
-                  ${(1 to i).gen(j => xs"""private final Iterable<T$j> ts$j;""")("\n")}
+                  ${(1 to i).gen(j => xs"""private final $mtype<T$j> ts$j;""")("\n")}
 
-                  private For$i(${(1 to i).gen(j => s"Iterable<T$j> ts$j")(", ")}) {
+                  private For$i$mtype(${(1 to i).gen(j => s"$mtype<T$j> ts$j")(", ")}) {
                       ${(1 to i).gen(j => xs"""this.ts$j = ts$j;""")("\n")}
                   }
 
@@ -753,14 +755,14 @@ def generateMainClasses(): Unit = {
                    * @param <R> type of the resulting {@code Iterator} elements
                    * @return an {@code Iterator} of mapped results
                    */
-                  public <R> $IteratorType<R> yield($functionType<$args, ? extends R> f) {
+                  public <R> $mtype<R> yield($functionType<$args, ? extends R> f) {
                       $Objects.requireNonNull(f, "f is null");
                       ${if (i == 1) xs"""
-                        return $IteratorType.ofAll(ts1).map(f);
+                        return ts1.map(f);
                       """ else xs"""
                         return
-                            ${(1 until i).gen(j => s"$IteratorType.ofAll(ts$j).flatMap(t$j ->")("\n")}
-                            $IteratorType.ofAll(ts$i).map(t$i -> f.apply(${(1 to i).gen(j => s"t$j")(", ")}))${")" * (i - 1)};
+                            ${(1 until i).gen(j => s"ts$j.flatMap(t$j ->")("\n")}
+                            ts$i.map(t$i -> f.apply(${(1 to i).gen(j => s"t$j")(", ")}))${")" * (i - 1)};
                       """}
                   }
 
@@ -770,13 +772,13 @@ def generateMainClasses(): Unit = {
                      *
                      * @return an {@code Iterator} of mapped results
                      */
-                    public $IteratorType<T1> yield() {
+                    public $mtype<T1> yield() {
                         return yield(Function.identity());
                     }
                   """)}
               }
             """
-          })("\n\n")}
+          })("\n\n"))("\n\n")}
         """
       }
 
@@ -2382,6 +2384,9 @@ def generateTestClasses(): Unit = {
       val TryType = im.getType("io.vavr.control.Try")
       val JavaComparatorType = im.getType("java.util.Comparator")
 
+      val monadicTypesFor = List(OptionType)
+      val monadicFunctionTypesFor = List(FutureType, TryType)
+
       val d = "$"
 
       im.getStatic("io.vavr.API.*")
@@ -2662,7 +2667,7 @@ def generateTestClasses(): Unit = {
 
             ${(1 to N).gen(i => xs"""
               @$test
-              public void shouldIterateFor$i() {
+              public void shouldIterateFor$ListType$i() {
                   final $ListType<Integer> result = For(
                       ${(1 to i).gen(j => s"$ListType.of(1, 2, 3)")(",\n")}
                   ).yield(${(i > 1).gen("(")}${(1 to i).gen(j => s"i$j")(", ")}${(i > 1).gen(")")} -> ${(1 to i).gen(j => s"i$j")(" + ")}).toList();
@@ -2672,11 +2677,31 @@ def generateTestClasses(): Unit = {
               }
             """)("\n\n")}
 
+            ${monadicTypesFor.gen(mtype => (1 to N).gen(i => { xs"""
+              @$test
+              public void shouldIterateFor$mtype$i() {
+                  final $mtype<Integer> result = For(
+                      ${(1 to i).gen(j => s"$mtype.of($j)")(",\n")}
+                  ).yield(${(i > 1).gen("(")}${(1 to i).gen(j => s"i$j")(", ")}${(i > 1).gen(")")} -> ${(1 to i).gen(j => s"i$j")(" + ")});
+                  $assertThat(result.get()).isEqualTo(${(1 to i).sum});
+              }
+            """})("\n\n"))("\n\n")}
+
+            ${monadicFunctionTypesFor.gen(mtype => (1 to N).gen(i => { xs"""
+              @$test
+              public void shouldIterateFor$mtype$i() {
+                  final $mtype<Integer> result = For(
+                      ${(1 to i).gen(j => s"$mtype.of(() -> $j)")(",\n")}
+                  ).yield(${(i > 1).gen("(")}${(1 to i).gen(j => s"i$j")(", ")}${(i > 1).gen(")")} -> ${(1 to i).gen(j => s"i$j")(" + ")});
+                  $assertThat(result.get()).isEqualTo(${(1 to i).sum});
+              }
+            """})("\n\n"))("\n\n")}
+
             @$test
             public void shouldIterateNestedFor() {
                 final $ListType<String> result =
                         For(${im.getType("java.util.Arrays")}.asList(1, 2), i ->
-                                For(${im.getType("io.vavr.collection.CharSeq")}.of('a', 'b')).yield(c -> i + ":" + c)).toList();
+                                For(${im.getType("io.vavr.collection.List")}.of('a', 'b')).yield(c -> i + ":" + c)).toList();
                 assertThat(result).isEqualTo($ListType.of("1:a", "1:b", "2:a", "2:b"));
             }
 
diff --git a/vavr/src-gen/main/java/io/vavr/API.java b/vavr/src-gen/main/java/io/vavr/API.java
index bb1eb1971f..3ebc25aac4 100644
--- a/vavr/src-gen/main/java/io/vavr/API.java
+++ b/vavr/src-gen/main/java/io/vavr/API.java
@@ -2254,142 +2254,142 @@ public static <T, U> Iterator<U> For(Iterable<T> ts, Function<? super T, ? exten
     }
 
     /**
-     * Creates a {@code For}-comprehension of one Iterable.
+     * Creates a {@code For}-comprehension of one Option.
      *
-     * @param ts1 the 1st Iterable
-     * @param <T1> component type of the 1st Iterable
+     * @param ts1 the 1st Option
+     * @param <T1> component type of the 1st Option
      * @return a new {@code For}-comprehension of arity 1
      */
-    public static <T1> For1<T1> For(Iterable<T1> ts1) {
+    public static <T1> For1Option<T1> For(Option<T1> ts1) {
         Objects.requireNonNull(ts1, "ts1 is null");
-        return new For1<>(ts1);
+        return new For1Option<>(ts1);
     }
 
     /**
-     * Creates a {@code For}-comprehension of two Iterables.
+     * Creates a {@code For}-comprehension of two Options.
      *
-     * @param ts1 the 1st Iterable
-     * @param ts2 the 2nd Iterable
-     * @param <T1> component type of the 1st Iterable
-     * @param <T2> component type of the 2nd Iterable
+     * @param ts1 the 1st Option
+     * @param ts2 the 2nd Option
+     * @param <T1> component type of the 1st Option
+     * @param <T2> component type of the 2nd Option
      * @return a new {@code For}-comprehension of arity 2
      */
-    public static <T1, T2> For2<T1, T2> For(Iterable<T1> ts1, Iterable<T2> ts2) {
+    public static <T1, T2> For2Option<T1, T2> For(Option<T1> ts1, Option<T2> ts2) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
-        return new For2<>(ts1, ts2);
+        return new For2Option<>(ts1, ts2);
     }
 
     /**
-     * Creates a {@code For}-comprehension of three Iterables.
+     * Creates a {@code For}-comprehension of three Options.
      *
-     * @param ts1 the 1st Iterable
-     * @param ts2 the 2nd Iterable
-     * @param ts3 the 3rd Iterable
-     * @param <T1> component type of the 1st Iterable
-     * @param <T2> component type of the 2nd Iterable
-     * @param <T3> component type of the 3rd Iterable
+     * @param ts1 the 1st Option
+     * @param ts2 the 2nd Option
+     * @param ts3 the 3rd Option
+     * @param <T1> component type of the 1st Option
+     * @param <T2> component type of the 2nd Option
+     * @param <T3> component type of the 3rd Option
      * @return a new {@code For}-comprehension of arity 3
      */
-    public static <T1, T2, T3> For3<T1, T2, T3> For(Iterable<T1> ts1, Iterable<T2> ts2, Iterable<T3> ts3) {
+    public static <T1, T2, T3> For3Option<T1, T2, T3> For(Option<T1> ts1, Option<T2> ts2, Option<T3> ts3) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         Objects.requireNonNull(ts3, "ts3 is null");
-        return new For3<>(ts1, ts2, ts3);
+        return new For3Option<>(ts1, ts2, ts3);
     }
 
     /**
-     * Creates a {@code For}-comprehension of 4 Iterables.
+     * Creates a {@code For}-comprehension of 4 Options.
      *
-     * @param ts1 the 1st Iterable
-     * @param ts2 the 2nd Iterable
-     * @param ts3 the 3rd Iterable
-     * @param ts4 the 4th Iterable
-     * @param <T1> component type of the 1st Iterable
-     * @param <T2> component type of the 2nd Iterable
-     * @param <T3> component type of the 3rd Iterable
-     * @param <T4> component type of the 4th Iterable
+     * @param ts1 the 1st Option
+     * @param ts2 the 2nd Option
+     * @param ts3 the 3rd Option
+     * @param ts4 the 4th Option
+     * @param <T1> component type of the 1st Option
+     * @param <T2> component type of the 2nd Option
+     * @param <T3> component type of the 3rd Option
+     * @param <T4> component type of the 4th Option
      * @return a new {@code For}-comprehension of arity 4
      */
-    public static <T1, T2, T3, T4> For4<T1, T2, T3, T4> For(Iterable<T1> ts1, Iterable<T2> ts2, Iterable<T3> ts3, Iterable<T4> ts4) {
+    public static <T1, T2, T3, T4> For4Option<T1, T2, T3, T4> For(Option<T1> ts1, Option<T2> ts2, Option<T3> ts3, 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 For4<>(ts1, ts2, ts3, ts4);
+        return new For4Option<>(ts1, ts2, ts3, ts4);
     }
 
     /**
-     * Creates a {@code For}-comprehension of 5 Iterables.
+     * Creates a {@code For}-comprehension of 5 Options.
      *
-     * @param ts1 the 1st Iterable
-     * @param ts2 the 2nd Iterable
-     * @param ts3 the 3rd Iterable
-     * @param ts4 the 4th Iterable
-     * @param ts5 the 5th Iterable
-     * @param <T1> component type of the 1st Iterable
-     * @param <T2> component type of the 2nd Iterable
-     * @param <T3> component type of the 3rd Iterable
-     * @param <T4> component type of the 4th Iterable
-     * @param <T5> component type of the 5th Iterable
+     * @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> component type of the 1st Option
+     * @param <T2> component type of the 2nd Option
+     * @param <T3> component type of the 3rd Option
+     * @param <T4> component type of the 4th Option
+     * @param <T5> component type of the 5th Option
      * @return a new {@code For}-comprehension of arity 5
      */
-    public static <T1, T2, T3, T4, T5> For5<T1, T2, T3, T4, T5> For(Iterable<T1> ts1, Iterable<T2> ts2, Iterable<T3> ts3, Iterable<T4> ts4, Iterable<T5> ts5) {
+    public static <T1, T2, T3, T4, T5> For5Option<T1, T2, T3, T4, T5> For(Option<T1> ts1, Option<T2> ts2, Option<T3> ts3, Option<T4> ts4, 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 For5<>(ts1, ts2, ts3, ts4, ts5);
+        return new For5Option<>(ts1, ts2, ts3, ts4, ts5);
     }
 
     /**
-     * Creates a {@code For}-comprehension of 6 Iterables.
+     * Creates a {@code For}-comprehension of 6 Options.
      *
-     * @param ts1 the 1st Iterable
-     * @param ts2 the 2nd Iterable
-     * @param ts3 the 3rd Iterable
-     * @param ts4 the 4th Iterable
-     * @param ts5 the 5th Iterable
-     * @param ts6 the 6th Iterable
-     * @param <T1> component type of the 1st Iterable
-     * @param <T2> component type of the 2nd Iterable
-     * @param <T3> component type of the 3rd Iterable
-     * @param <T4> component type of the 4th Iterable
-     * @param <T5> component type of the 5th Iterable
-     * @param <T6> component type of the 6th Iterable
+     * @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> component type of the 1st Option
+     * @param <T2> component type of the 2nd Option
+     * @param <T3> component type of the 3rd Option
+     * @param <T4> component type of the 4th Option
+     * @param <T5> component type of the 5th Option
+     * @param <T6> component type of the 6th Option
      * @return a new {@code For}-comprehension of arity 6
      */
-    public static <T1, T2, T3, T4, T5, T6> For6<T1, T2, T3, T4, T5, T6> For(Iterable<T1> ts1, Iterable<T2> ts2, Iterable<T3> ts3, Iterable<T4> ts4, Iterable<T5> ts5, Iterable<T6> ts6) {
+    public static <T1, T2, T3, T4, T5, T6> For6Option<T1, T2, T3, T4, T5, T6> For(Option<T1> ts1, Option<T2> ts2, Option<T3> ts3, Option<T4> ts4, Option<T5> ts5, 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 For6<>(ts1, ts2, ts3, ts4, ts5, ts6);
-    }
-
-    /**
-     * Creates a {@code For}-comprehension of 7 Iterables.
-     *
-     * @param ts1 the 1st Iterable
-     * @param ts2 the 2nd Iterable
-     * @param ts3 the 3rd Iterable
-     * @param ts4 the 4th Iterable
-     * @param ts5 the 5th Iterable
-     * @param ts6 the 6th Iterable
-     * @param ts7 the 7th Iterable
-     * @param <T1> component type of the 1st Iterable
-     * @param <T2> component type of the 2nd Iterable
-     * @param <T3> component type of the 3rd Iterable
-     * @param <T4> component type of the 4th Iterable
-     * @param <T5> component type of the 5th Iterable
-     * @param <T6> component type of the 6th Iterable
-     * @param <T7> component type of the 7th Iterable
+        return new For6Option<>(ts1, ts2, ts3, ts4, ts5, ts6);
+    }
+
+    /**
+     * Creates a {@code For}-comprehension of 7 Options.
+     *
+     * @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> component type of the 1st Option
+     * @param <T2> component type of the 2nd Option
+     * @param <T3> component type of the 3rd Option
+     * @param <T4> component type of the 4th Option
+     * @param <T5> component type of the 5th Option
+     * @param <T6> component type of the 6th Option
+     * @param <T7> component type of the 7th Option
      * @return a new {@code For}-comprehension of arity 7
      */
-    public static <T1, T2, T3, T4, T5, T6, T7> For7<T1, T2, T3, T4, T5, T6, T7> For(Iterable<T1> ts1, Iterable<T2> ts2, Iterable<T3> ts3, Iterable<T4> ts4, Iterable<T5> ts5, Iterable<T6> ts6, Iterable<T7> ts7) {
+    public static <T1, T2, T3, T4, T5, T6, T7> For7Option<T1, T2, T3, T4, T5, T6, T7> For(Option<T1> ts1, Option<T2> ts2, Option<T3> ts3, Option<T4> ts4, Option<T5> ts5, Option<T6> ts6, Option<T7> ts7) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         Objects.requireNonNull(ts3, "ts3 is null");
@@ -2397,31 +2397,31 @@ public static <T1, T2, T3, T4, T5, T6, T7> For7<T1, T2, T3, T4, T5, T6, T7> For(
         Objects.requireNonNull(ts5, "ts5 is null");
         Objects.requireNonNull(ts6, "ts6 is null");
         Objects.requireNonNull(ts7, "ts7 is null");
-        return new For7<>(ts1, ts2, ts3, ts4, ts5, ts6, ts7);
-    }
-
-    /**
-     * Creates a {@code For}-comprehension of 8 Iterables.
-     *
-     * @param ts1 the 1st Iterable
-     * @param ts2 the 2nd Iterable
-     * @param ts3 the 3rd Iterable
-     * @param ts4 the 4th Iterable
-     * @param ts5 the 5th Iterable
-     * @param ts6 the 6th Iterable
-     * @param ts7 the 7th Iterable
-     * @param ts8 the 8th Iterable
-     * @param <T1> component type of the 1st Iterable
-     * @param <T2> component type of the 2nd Iterable
-     * @param <T3> component type of the 3rd Iterable
-     * @param <T4> component type of the 4th Iterable
-     * @param <T5> component type of the 5th Iterable
-     * @param <T6> component type of the 6th Iterable
-     * @param <T7> component type of the 7th Iterable
-     * @param <T8> component type of the 8th Iterable
+        return new For7Option<>(ts1, ts2, ts3, ts4, ts5, ts6, ts7);
+    }
+
+    /**
+     * Creates a {@code For}-comprehension of 8 Options.
+     *
+     * @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> component type of the 1st Option
+     * @param <T2> component type of the 2nd Option
+     * @param <T3> component type of the 3rd Option
+     * @param <T4> component type of the 4th Option
+     * @param <T5> component type of the 5th Option
+     * @param <T6> component type of the 6th Option
+     * @param <T7> component type of the 7th Option
+     * @param <T8> component type of the 8th Option
      * @return a new {@code For}-comprehension of arity 8
      */
-    public static <T1, T2, T3, T4, T5, T6, T7, T8> For8<T1, T2, T3, T4, T5, T6, T7, T8> For(Iterable<T1> ts1, Iterable<T2> ts2, Iterable<T3> ts3, Iterable<T4> ts4, Iterable<T5> ts5, Iterable<T6> ts6, Iterable<T7> ts7, Iterable<T8> ts8) {
+    public static <T1, T2, T3, T4, T5, T6, T7, T8> For8Option<T1, T2, T3, T4, T5, T6, T7, T8> For(Option<T1> ts1, Option<T2> ts2, Option<T3> ts3, Option<T4> ts4, Option<T5> ts5, Option<T6> ts6, Option<T7> ts7, Option<T8> ts8) {
         Objects.requireNonNull(ts1, "ts1 is null");
         Objects.requireNonNull(ts2, "ts2 is null");
         Objects.requireNonNull(ts3, "ts3 is null");
@@ -2430,308 +2430,1745 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8> For8<T1, T2, T3, T4, T5, T6, T7,
         Objects.requireNonNull(ts6, "ts6 is null");
         Objects.requireNonNull(ts7, "ts7 is null");
         Objects.requireNonNull(ts8, "ts8 is null");
-        return new For8<>(ts1, ts2, ts3, ts4, ts5, ts6, ts7, ts8);
+        return new For8Option<>(ts1, ts2, ts3, ts4, ts5, ts6, ts7, ts8);
     }
 
     /**
-     * For-comprehension with one Iterable.
+     * Creates a {@code For}-comprehension of one Future.
+     *
+     * @param ts1 the 1st Future
+     * @param <T1> component type of the 1st Future
+     * @return a new {@code For}-comprehension of arity 1
      */
-    public static class For1<T1> {
-
-        private final Iterable<T1> ts1;
-
-        private For1(Iterable<T1> ts1) {
-            this.ts1 = ts1;
-        }
-
-        /**
-         * Yields a result for elements of the cross product of the underlying Iterables.
-         *
-         * @param f a function that maps an element of the cross product to a result
-         * @param <R> type of the resulting {@code Iterator} elements
-         * @return an {@code Iterator} of mapped results
-         */
-        public <R> Iterator<R> yield(Function<? super T1, ? extends R> f) {
-            Objects.requireNonNull(f, "f is null");
-            return Iterator.ofAll(ts1).map(f);
-        }
-
-        /**
-         * A shortcut for {@code yield(Function.identity())}.
-         *
-         * @return an {@code Iterator} of mapped results
-         */
-        public Iterator<T1> yield() {
-            return yield(Function.identity());
-        }
+    public static <T1> For1Future<T1> For(Future<T1> ts1) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        return new For1Future<>(ts1);
     }
 
     /**
-     * For-comprehension with two Iterables.
+     * Creates a {@code For}-comprehension of two Futures.
+     *
+     * @param ts1 the 1st Future
+     * @param ts2 the 2nd Future
+     * @param <T1> component type of the 1st Future
+     * @param <T2> component type of the 2nd Future
+     * @return a new {@code For}-comprehension of arity 2
      */
-    public static class For2<T1, T2> {
-
-        private final Iterable<T1> ts1;
-        private final Iterable<T2> ts2;
-
-        private For2(Iterable<T1> ts1, Iterable<T2> ts2) {
-            this.ts1 = ts1;
-            this.ts2 = ts2;
-        }
-
-        /**
-         * Yields a result for elements of the cross product of the underlying Iterables.
-         *
-         * @param f a function that maps an element of the cross product to a result
-         * @param <R> type of the resulting {@code Iterator} elements
-         * @return an {@code Iterator} of mapped results
-         */
-        public <R> Iterator<R> yield(BiFunction<? super T1, ? super T2, ? extends R> f) {
-            Objects.requireNonNull(f, "f is null");
-            return
-                Iterator.ofAll(ts1).flatMap(t1 ->
-                Iterator.ofAll(ts2).map(t2 -> f.apply(t1, t2)));
-        }
-
+    public static <T1, T2> For2Future<T1, T2> For(Future<T1> ts1, Future<T2> ts2) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        return new For2Future<>(ts1, ts2);
     }
 
     /**
-     * For-comprehension with three Iterables.
+     * Creates a {@code For}-comprehension of three Futures.
+     *
+     * @param ts1 the 1st Future
+     * @param ts2 the 2nd Future
+     * @param ts3 the 3rd Future
+     * @param <T1> component type of the 1st Future
+     * @param <T2> component type of the 2nd Future
+     * @param <T3> component type of the 3rd Future
+     * @return a new {@code For}-comprehension of arity 3
      */
-    public static class For3<T1, T2, T3> {
-
-        private final Iterable<T1> ts1;
-        private final Iterable<T2> ts2;
-        private final Iterable<T3> ts3;
-
-        private For3(Iterable<T1> ts1, Iterable<T2> ts2, Iterable<T3> ts3) {
-            this.ts1 = ts1;
-            this.ts2 = ts2;
-            this.ts3 = ts3;
-        }
-
-        /**
-         * Yields a result for elements of the cross product of the underlying Iterables.
-         *
-         * @param f a function that maps an element of the cross product to a result
-         * @param <R> type of the resulting {@code Iterator} elements
-         * @return an {@code Iterator} of mapped results
-         */
-        public <R> Iterator<R> yield(Function3<? super T1, ? super T2, ? super T3, ? extends R> f) {
-            Objects.requireNonNull(f, "f is null");
-            return
-                Iterator.ofAll(ts1).flatMap(t1 ->
-                Iterator.ofAll(ts2).flatMap(t2 ->
-                Iterator.ofAll(ts3).map(t3 -> f.apply(t1, t2, t3))));
-        }
-
+    public static <T1, T2, T3> For3Future<T1, T2, T3> For(Future<T1> ts1, Future<T2> ts2, Future<T3> ts3) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        Objects.requireNonNull(ts3, "ts3 is null");
+        return new For3Future<>(ts1, ts2, ts3);
     }
 
     /**
-     * For-comprehension with 4 Iterables.
+     * Creates a {@code For}-comprehension of 4 Futures.
+     *
+     * @param ts1 the 1st Future
+     * @param ts2 the 2nd Future
+     * @param ts3 the 3rd Future
+     * @param ts4 the 4th Future
+     * @param <T1> component type of the 1st Future
+     * @param <T2> component type of the 2nd Future
+     * @param <T3> component type of the 3rd Future
+     * @param <T4> component type of the 4th Future
+     * @return a new {@code For}-comprehension of arity 4
      */
-    public static class For4<T1, T2, T3, T4> {
-
-        private final Iterable<T1> ts1;
-        private final Iterable<T2> ts2;
-        private final Iterable<T3> ts3;
-        private final Iterable<T4> ts4;
-
-        private For4(Iterable<T1> ts1, Iterable<T2> ts2, Iterable<T3> ts3, Iterable<T4> ts4) {
-            this.ts1 = ts1;
-            this.ts2 = ts2;
-            this.ts3 = ts3;
-            this.ts4 = ts4;
-        }
-
-        /**
-         * Yields a result for elements of the cross product of the underlying Iterables.
-         *
-         * @param f a function that maps an element of the cross product to a result
-         * @param <R> type of the resulting {@code Iterator} elements
-         * @return an {@code Iterator} of mapped results
-         */
-        public <R> Iterator<R> yield(Function4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R> f) {
-            Objects.requireNonNull(f, "f is null");
-            return
-                Iterator.ofAll(ts1).flatMap(t1 ->
-                Iterator.ofAll(ts2).flatMap(t2 ->
-                Iterator.ofAll(ts3).flatMap(t3 ->
-                Iterator.ofAll(ts4).map(t4 -> f.apply(t1, t2, t3, t4)))));
-        }
-
+    public static <T1, T2, T3, T4> For4Future<T1, T2, T3, T4> For(Future<T1> ts1, Future<T2> ts2, Future<T3> ts3, 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 For4Future<>(ts1, ts2, ts3, ts4);
     }
 
     /**
-     * For-comprehension with 5 Iterables.
+     * Creates a {@code For}-comprehension of 5 Futures.
+     *
+     * @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> component type of the 1st Future
+     * @param <T2> component type of the 2nd Future
+     * @param <T3> component type of the 3rd Future
+     * @param <T4> component type of the 4th Future
+     * @param <T5> component type of the 5th Future
+     * @return a new {@code For}-comprehension of arity 5
      */
-    public static class For5<T1, T2, T3, T4, T5> {
-
-        private final Iterable<T1> ts1;
-        private final Iterable<T2> ts2;
-        private final Iterable<T3> ts3;
-        private final Iterable<T4> ts4;
-        private final Iterable<T5> ts5;
-
-        private For5(Iterable<T1> ts1, Iterable<T2> ts2, Iterable<T3> ts3, Iterable<T4> ts4, Iterable<T5> ts5) {
-            this.ts1 = ts1;
-            this.ts2 = ts2;
-            this.ts3 = ts3;
-            this.ts4 = ts4;
-            this.ts5 = ts5;
-        }
-
-        /**
-         * Yields a result for elements of the cross product of the underlying Iterables.
-         *
-         * @param f a function that maps an element of the cross product to a result
-         * @param <R> type of the resulting {@code Iterator} elements
-         * @return an {@code Iterator} of mapped results
-         */
-        public <R> Iterator<R> yield(Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R> f) {
-            Objects.requireNonNull(f, "f is null");
-            return
-                Iterator.ofAll(ts1).flatMap(t1 ->
-                Iterator.ofAll(ts2).flatMap(t2 ->
-                Iterator.ofAll(ts3).flatMap(t3 ->
-                Iterator.ofAll(ts4).flatMap(t4 ->
-                Iterator.ofAll(ts5).map(t5 -> f.apply(t1, t2, t3, t4, t5))))));
-        }
-
+    public static <T1, T2, T3, T4, T5> For5Future<T1, T2, T3, T4, T5> For(Future<T1> ts1, Future<T2> ts2, Future<T3> ts3, Future<T4> ts4, 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 For5Future<>(ts1, ts2, ts3, ts4, ts5);
     }
 
     /**
-     * For-comprehension with 6 Iterables.
+     * Creates a {@code For}-comprehension of 6 Futures.
+     *
+     * @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> component type of the 1st Future
+     * @param <T2> component type of the 2nd Future
+     * @param <T3> component type of the 3rd Future
+     * @param <T4> component type of the 4th Future
+     * @param <T5> component type of the 5th Future
+     * @param <T6> component type of the 6th Future
+     * @return a new {@code For}-comprehension of arity 6
      */
-    public static class For6<T1, T2, T3, T4, T5, T6> {
-
-        private final Iterable<T1> ts1;
-        private final Iterable<T2> ts2;
-        private final Iterable<T3> ts3;
-        private final Iterable<T4> ts4;
-        private final Iterable<T5> ts5;
-        private final Iterable<T6> ts6;
-
-        private For6(Iterable<T1> ts1, Iterable<T2> ts2, Iterable<T3> ts3, Iterable<T4> ts4, Iterable<T5> ts5, Iterable<T6> ts6) {
-            this.ts1 = ts1;
-            this.ts2 = ts2;
-            this.ts3 = ts3;
-            this.ts4 = ts4;
-            this.ts5 = ts5;
-            this.ts6 = ts6;
-        }
-
-        /**
-         * Yields a result for elements of the cross product of the underlying Iterables.
-         *
-         * @param f a function that maps an element of the cross product to a result
-         * @param <R> type of the resulting {@code Iterator} elements
-         * @return an {@code Iterator} of mapped results
-         */
-        public <R> Iterator<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
-                Iterator.ofAll(ts1).flatMap(t1 ->
-                Iterator.ofAll(ts2).flatMap(t2 ->
-                Iterator.ofAll(ts3).flatMap(t3 ->
-                Iterator.ofAll(ts4).flatMap(t4 ->
-                Iterator.ofAll(ts5).flatMap(t5 ->
-                Iterator.ofAll(ts6).map(t6 -> f.apply(t1, t2, t3, t4, t5, t6)))))));
-        }
+    public static <T1, T2, T3, T4, T5, T6> For6Future<T1, T2, T3, T4, T5, T6> For(Future<T1> ts1, Future<T2> ts2, Future<T3> ts3, Future<T4> ts4, Future<T5> ts5, 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 For6Future<>(ts1, ts2, ts3, ts4, ts5, ts6);
+    }
+
+    /**
+     * Creates a {@code For}-comprehension of 7 Futures.
+     *
+     * @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> component type of the 1st Future
+     * @param <T2> component type of the 2nd Future
+     * @param <T3> component type of the 3rd Future
+     * @param <T4> component type of the 4th Future
+     * @param <T5> component type of the 5th Future
+     * @param <T6> component type of the 6th Future
+     * @param <T7> component type of the 7th Future
+     * @return a new {@code For}-comprehension of arity 7
+     */
+    public static <T1, T2, T3, T4, T5, T6, T7> For7Future<T1, T2, T3, T4, T5, T6, T7> For(Future<T1> ts1, Future<T2> ts2, Future<T3> ts3, Future<T4> ts4, Future<T5> ts5, Future<T6> ts6, 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 For7Future<>(ts1, ts2, ts3, ts4, ts5, ts6, ts7);
+    }
+
+    /**
+     * Creates a {@code For}-comprehension of 8 Futures.
+     *
+     * @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> component type of the 1st Future
+     * @param <T2> component type of the 2nd Future
+     * @param <T3> component type of the 3rd Future
+     * @param <T4> component type of the 4th Future
+     * @param <T5> component type of the 5th Future
+     * @param <T6> component type of the 6th Future
+     * @param <T7> component type of the 7th Future
+     * @param <T8> component type of the 8th Future
+     * @return a new {@code For}-comprehension of arity 8
+     */
+    public static <T1, T2, T3, T4, T5, T6, T7, T8> For8Future<T1, T2, T3, T4, T5, T6, T7, T8> For(Future<T1> ts1, Future<T2> ts2, Future<T3> ts3, Future<T4> ts4, Future<T5> ts5, Future<T6> ts6, Future<T7> ts7, 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 For8Future<>(ts1, ts2, ts3, ts4, ts5, ts6, ts7, ts8);
+    }
 
+    /**
+     * Creates a {@code For}-comprehension of one Try.
+     *
+     * @param ts1 the 1st Try
+     * @param <T1> component type of the 1st Try
+     * @return a new {@code For}-comprehension of arity 1
+     */
+    public static <T1> For1Try<T1> For(Try<T1> ts1) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        return new For1Try<>(ts1);
     }
 
     /**
-     * For-comprehension with 7 Iterables.
+     * Creates a {@code For}-comprehension of two Trys.
+     *
+     * @param ts1 the 1st Try
+     * @param ts2 the 2nd Try
+     * @param <T1> component type of the 1st Try
+     * @param <T2> component type of the 2nd Try
+     * @return a new {@code For}-comprehension of arity 2
      */
-    public static class For7<T1, T2, T3, T4, T5, T6, T7> {
+    public static <T1, T2> For2Try<T1, T2> For(Try<T1> ts1, Try<T2> ts2) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        return new For2Try<>(ts1, ts2);
+    }
 
-        private final Iterable<T1> ts1;
-        private final Iterable<T2> ts2;
-        private final Iterable<T3> ts3;
-        private final Iterable<T4> ts4;
-        private final Iterable<T5> ts5;
-        private final Iterable<T6> ts6;
-        private final Iterable<T7> ts7;
+    /**
+     * Creates a {@code For}-comprehension of three Trys.
+     *
+     * @param ts1 the 1st Try
+     * @param ts2 the 2nd Try
+     * @param ts3 the 3rd Try
+     * @param <T1> component type of the 1st Try
+     * @param <T2> component type of the 2nd Try
+     * @param <T3> component type of the 3rd Try
+     * @return a new {@code For}-comprehension of arity 3
+     */
+    public static <T1, T2, T3> For3Try<T1, T2, T3> For(Try<T1> ts1, Try<T2> ts2, Try<T3> ts3) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        Objects.requireNonNull(ts3, "ts3 is null");
+        return new For3Try<>(ts1, ts2, ts3);
+    }
 
-        private For7(Iterable<T1> ts1, Iterable<T2> ts2, Iterable<T3> ts3, Iterable<T4> ts4, Iterable<T5> ts5, Iterable<T6> ts6, Iterable<T7> ts7) {
-            this.ts1 = ts1;
-            this.ts2 = ts2;
-            this.ts3 = ts3;
-            this.ts4 = ts4;
-            this.ts5 = ts5;
-            this.ts6 = ts6;
-            this.ts7 = ts7;
-        }
+    /**
+     * Creates a {@code For}-comprehension of 4 Trys.
+     *
+     * @param ts1 the 1st Try
+     * @param ts2 the 2nd Try
+     * @param ts3 the 3rd Try
+     * @param ts4 the 4th Try
+     * @param <T1> component type of the 1st Try
+     * @param <T2> component type of the 2nd Try
+     * @param <T3> component type of the 3rd Try
+     * @param <T4> component type of the 4th Try
+     * @return a new {@code For}-comprehension of arity 4
+     */
+    public static <T1, T2, T3, T4> For4Try<T1, T2, T3, T4> For(Try<T1> ts1, Try<T2> ts2, Try<T3> ts3, 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 For4Try<>(ts1, ts2, ts3, ts4);
+    }
 
-        /**
-         * Yields a result for elements of the cross product of the underlying Iterables.
-         *
-         * @param f a function that maps an element of the cross product to a result
-         * @param <R> type of the resulting {@code Iterator} elements
-         * @return an {@code Iterator} of mapped results
-         */
-        public <R> Iterator<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
-                Iterator.ofAll(ts1).flatMap(t1 ->
-                Iterator.ofAll(ts2).flatMap(t2 ->
-                Iterator.ofAll(ts3).flatMap(t3 ->
-                Iterator.ofAll(ts4).flatMap(t4 ->
-                Iterator.ofAll(ts5).flatMap(t5 ->
-                Iterator.ofAll(ts6).flatMap(t6 ->
-                Iterator.ofAll(ts7).map(t7 -> f.apply(t1, t2, t3, t4, t5, t6, t7))))))));
-        }
+    /**
+     * Creates a {@code For}-comprehension of 5 Trys.
+     *
+     * @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> component type of the 1st Try
+     * @param <T2> component type of the 2nd Try
+     * @param <T3> component type of the 3rd Try
+     * @param <T4> component type of the 4th Try
+     * @param <T5> component type of the 5th Try
+     * @return a new {@code For}-comprehension of arity 5
+     */
+    public static <T1, T2, T3, T4, T5> For5Try<T1, T2, T3, T4, T5> For(Try<T1> ts1, Try<T2> ts2, Try<T3> ts3, Try<T4> ts4, 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 For5Try<>(ts1, ts2, ts3, ts4, ts5);
+    }
 
+    /**
+     * Creates a {@code For}-comprehension of 6 Trys.
+     *
+     * @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> component type of the 1st Try
+     * @param <T2> component type of the 2nd Try
+     * @param <T3> component type of the 3rd Try
+     * @param <T4> component type of the 4th Try
+     * @param <T5> component type of the 5th Try
+     * @param <T6> component type of the 6th Try
+     * @return a new {@code For}-comprehension of arity 6
+     */
+    public static <T1, T2, T3, T4, T5, T6> For6Try<T1, T2, T3, T4, T5, T6> For(Try<T1> ts1, Try<T2> ts2, Try<T3> ts3, Try<T4> ts4, Try<T5> ts5, 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 For6Try<>(ts1, ts2, ts3, ts4, ts5, ts6);
+    }
+
+    /**
+     * Creates a {@code For}-comprehension of 7 Trys.
+     *
+     * @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> component type of the 1st Try
+     * @param <T2> component type of the 2nd Try
+     * @param <T3> component type of the 3rd Try
+     * @param <T4> component type of the 4th Try
+     * @param <T5> component type of the 5th Try
+     * @param <T6> component type of the 6th Try
+     * @param <T7> component type of the 7th Try
+     * @return a new {@code For}-comprehension of arity 7
+     */
+    public static <T1, T2, T3, T4, T5, T6, T7> For7Try<T1, T2, T3, T4, T5, T6, T7> For(Try<T1> ts1, Try<T2> ts2, Try<T3> ts3, Try<T4> ts4, Try<T5> ts5, Try<T6> ts6, 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 For7Try<>(ts1, ts2, ts3, ts4, ts5, ts6, ts7);
+    }
+
+    /**
+     * Creates a {@code For}-comprehension of 8 Trys.
+     *
+     * @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> component type of the 1st Try
+     * @param <T2> component type of the 2nd Try
+     * @param <T3> component type of the 3rd Try
+     * @param <T4> component type of the 4th Try
+     * @param <T5> component type of the 5th Try
+     * @param <T6> component type of the 6th Try
+     * @param <T7> component type of the 7th Try
+     * @param <T8> component type of the 8th Try
+     * @return a new {@code For}-comprehension of arity 8
+     */
+    public static <T1, T2, T3, T4, T5, T6, T7, T8> For8Try<T1, T2, T3, T4, T5, T6, T7, T8> For(Try<T1> ts1, Try<T2> ts2, Try<T3> ts3, Try<T4> ts4, Try<T5> ts5, Try<T6> ts6, Try<T7> ts7, 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 For8Try<>(ts1, ts2, ts3, ts4, ts5, ts6, ts7, ts8);
     }
 
     /**
-     * For-comprehension with 8 Iterables.
+     * Creates a {@code For}-comprehension of one List.
+     *
+     * @param ts1 the 1st List
+     * @param <T1> component type of the 1st List
+     * @return a new {@code For}-comprehension of arity 1
      */
-    public static class For8<T1, T2, T3, T4, T5, T6, T7, T8> {
+    public static <T1> For1List<T1> For(List<T1> ts1) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        return new For1List<>(ts1);
+    }
 
-        private final Iterable<T1> ts1;
-        private final Iterable<T2> ts2;
-        private final Iterable<T3> ts3;
-        private final Iterable<T4> ts4;
-        private final Iterable<T5> ts5;
-        private final Iterable<T6> ts6;
-        private final Iterable<T7> ts7;
-        private final Iterable<T8> ts8;
+    /**
+     * Creates a {@code For}-comprehension of two Lists.
+     *
+     * @param ts1 the 1st List
+     * @param ts2 the 2nd List
+     * @param <T1> component type of the 1st List
+     * @param <T2> component type of the 2nd List
+     * @return a new {@code For}-comprehension of arity 2
+     */
+    public static <T1, T2> For2List<T1, T2> For(List<T1> ts1, List<T2> ts2) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        return new For2List<>(ts1, ts2);
+    }
 
-        private For8(Iterable<T1> ts1, Iterable<T2> ts2, Iterable<T3> ts3, Iterable<T4> ts4, Iterable<T5> ts5, Iterable<T6> ts6, Iterable<T7> ts7, Iterable<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;
-        }
+    /**
+     * Creates a {@code For}-comprehension of three Lists.
+     *
+     * @param ts1 the 1st List
+     * @param ts2 the 2nd List
+     * @param ts3 the 3rd List
+     * @param <T1> component type of the 1st List
+     * @param <T2> component type of the 2nd List
+     * @param <T3> component type of the 3rd List
+     * @return a new {@code For}-comprehension of arity 3
+     */
+    public static <T1, T2, T3> For3List<T1, T2, T3> For(List<T1> ts1, List<T2> ts2, List<T3> ts3) {
+        Objects.requireNonNull(ts1, "ts1 is null");
+        Objects.requireNonNull(ts2, "ts2 is null");
+        Objects.requireNonNull(ts3, "ts3 is null");
+        return new For3List<>(ts1, ts2, ts3);
+    }
 
-        /**
-         * Yields a result for elements of the cross product of the underlying Iterables.
-         *
-         * @param f a function that maps an element of the cross product to a result
-         * @param <R> type of the resulting {@code Iterator} elements
-         * @return an {@code Iterator} of mapped results
-         */
-        public <R> Iterator<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
-                Iterator.ofAll(ts1).flatMap(t1 ->
-                Iterator.ofAll(ts2).flatMap(t2 ->
-                Iterator.ofAll(ts3).flatMap(t3 ->
-                Iterator.ofAll(ts4).flatMap(t4 ->
-                Iterator.ofAll(ts5).flatMap(t5 ->
-                Iterator.ofAll(ts6).flatMap(t6 ->
-                Iterator.ofAll(ts7).flatMap(t7 ->
-                Iterator.ofAll(ts8).map(t8 -> f.apply(t1, t2, t3, t4, t5, t6, t7, t8)))))))));
-        }
+    /**
+     * Creates a {@code For}-comprehension of 4 Lists.
+     *
+     * @param ts1 the 1st List
+     * @param ts2 the 2nd List
+     * @param ts3 the 3rd List
+     * @param ts4 the 4th List
+     * @param <T1> component type of the 1st List
+     * @param <T2> component type of the 2nd List
+     * @param <T3> component type of the 3rd List
+     * @param <T4> component type of the 4th List
+     * @return a new {@code For}-comprehension of arity 4
+     */
+    public static <T1, T2, T3, T4> For4List<T1, T2, T3, T4> For(List<T1> ts1, List<T2> ts2, List<T3> ts3, 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 For4List<>(ts1, ts2, ts3, ts4);
+    }
 
+    /**
+     * Creates a {@code For}-comprehension of 5 Lists.
+     *
+     * @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> component type of the 1st List
+     * @param <T2> component type of the 2nd List
+     * @param <T3> component type of the 3rd List
+     * @param <T4> component type of the 4th List
+     * @param <T5> component type of the 5th List
+     * @return a new {@code For}-comprehension of arity 5
+     */
+    public static <T1, T2, T3, T4, T5> For5List<T1, T2, T3, T4, T5> For(List<T1> ts1, List<T2> ts2, List<T3> ts3, List<T4> ts4, 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 For5List<>(ts1, ts2, ts3, ts4, ts5);
     }
 
+    /**
+     * Creates a {@code For}-comprehension of 6 Lists.
+     *
+     * @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> component type of the 1st List
+     * @param <T2> component type of the 2nd List
+     * @param <T3> component type of the 3rd List
+     * @param <T4> component type of the 4th List
+     * @param <T5> component type of the 5th List
+     * @param <T6> component type of the 6th List
+     * @return a new {@code For}-comprehension of arity 6
+     */
+    public static <T1, T2, T3, T4, T5, T6> For6List<T1, T2, T3, T4, T5, T6> For(List<T1> ts1, List<T2> ts2, List<T3> ts3, List<T4> ts4, List<T5> ts5, 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 For6List<>(ts1, ts2, ts3, ts4, ts5, ts6);
+    }
+
+    /**
+     * Creates a {@code For}-comprehension of 7 Lists.
+     *
+     * @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> component type of the 1st List
+     * @param <T2> component type of the 2nd List
+     * @param <T3> component type of the 3rd List
+     * @param <T4> component type of the 4th List
+     * @param <T5> component type of the 5th List
+     * @param <T6> component type of the 6th List
+     * @param <T7> component type of the 7th List
+     * @return a new {@code For}-comprehension of arity 7
+     */
+    public static <T1, T2, T3, T4, T5, T6, T7> For7List<T1, T2, T3, T4, T5, T6, T7> For(List<T1> ts1, List<T2> ts2, List<T3> ts3, List<T4> ts4, List<T5> ts5, List<T6> ts6, 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 For7List<>(ts1, ts2, ts3, ts4, ts5, ts6, ts7);
+    }
+
+    /**
+     * Creates a {@code For}-comprehension of 8 Lists.
+     *
+     * @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> component type of the 1st List
+     * @param <T2> component type of the 2nd List
+     * @param <T3> component type of the 3rd List
+     * @param <T4> component type of the 4th List
+     * @param <T5> component type of the 5th List
+     * @param <T6> component type of the 6th List
+     * @param <T7> component type of the 7th List
+     * @param <T8> component type of the 8th List
+     * @return a new {@code For}-comprehension of arity 8
+     */
+    public static <T1, T2, T3, T4, T5, T6, T7, T8> For8List<T1, T2, T3, T4, T5, T6, T7, T8> For(List<T1> ts1, List<T2> ts2, List<T3> ts3, List<T4> ts4, List<T5> ts5, List<T6> ts6, List<T7> ts7, 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 For8List<>(ts1, ts2, ts3, ts4, ts5, ts6, ts7, ts8);
+    }
+
+     /**
+      * For-comprehension with one Iterator.
+      */
+     public static class For1Option<T1> {
+
+         private final Option<T1> ts1;
+
+         private For1Option(Option<T1> ts1) {
+             this.ts1 = ts1;
+         }
+
+         /**
+          * Yields a result for elements of the cross product of the underlying Iterables.
+          *
+          * @param f a function that maps an element of the cross product to a result
+          * @param <R> type of the resulting {@code Iterator} elements
+          * @return an {@code Iterator} of mapped results
+          */
+         public <R> Option<R> yield(Function<? super T1, ? extends R> f) {
+             Objects.requireNonNull(f, "f is null");
+             return ts1.map(f);
+         }
+
+         /**
+          * A shortcut for {@code yield(Function.identity())}.
+          *
+          * @return an {@code Iterator} of mapped results
+          */
+         public Option<T1> yield() {
+             return yield(Function.identity());
+         }
+     }
+
+     /**
+      * For-comprehension with two Iterators.
+      */
+     public static class For2Option<T1, T2> {
+
+         private final Option<T1> ts1;
+         private final Option<T2> ts2;
+
+         private For2Option(Option<T1> ts1, Option<T2> ts2) {
+             this.ts1 = ts1;
+             this.ts2 = ts2;
+         }
+
+         /**
+          * Yields a result for elements of the cross product of the underlying Iterables.
+          *
+          * @param f a function that maps an element of the cross product to a result
+          * @param <R> type of the resulting {@code Iterator} elements
+          * @return an {@code Iterator} of mapped results
+          */
+         public <R> Option<R> yield(BiFunction<? super T1, ? super T2, ? extends R> f) {
+             Objects.requireNonNull(f, "f is null");
+             return
+                 ts1.flatMap(t1 ->
+                 ts2.map(t2 -> f.apply(t1, t2)));
+         }
+
+     }
+
+     /**
+      * For-comprehension with three Iterators.
+      */
+     public static class For3Option<T1, T2, T3> {
+
+         private final Option<T1> ts1;
+         private final Option<T2> ts2;
+         private final Option<T3> ts3;
+
+         private For3Option(Option<T1> ts1, Option<T2> ts2, Option<T3> ts3) {
+             this.ts1 = ts1;
+             this.ts2 = ts2;
+             this.ts3 = ts3;
+         }
+
+         /**
+          * Yields a result for elements of the cross product of the underlying Iterables.
+          *
+          * @param f a function that maps an element of the cross product to a result
+          * @param <R> type of the resulting {@code Iterator} elements
+          * @return an {@code Iterator} of mapped results
+          */
+         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 ->
+                 ts2.flatMap(t2 ->
+                 ts3.map(t3 -> f.apply(t1, t2, t3))));
+         }
+
+     }
+
+     /**
+      * For-comprehension with 4 Iterators.
+      */
+     public static class For4Option<T1, T2, T3, T4> {
+
+         private final Option<T1> ts1;
+         private final Option<T2> ts2;
+         private final Option<T3> ts3;
+         private final Option<T4> ts4;
+
+         private For4Option(Option<T1> ts1, Option<T2> ts2, Option<T3> ts3, Option<T4> ts4) {
+             this.ts1 = ts1;
+             this.ts2 = ts2;
+             this.ts3 = ts3;
+             this.ts4 = ts4;
+         }
+
+         /**
+          * Yields a result for elements of the cross product of the underlying Iterables.
+          *
+          * @param f a function that maps an element of the cross product to a result
+          * @param <R> type of the resulting {@code Iterator} elements
+          * @return an {@code Iterator} of mapped results
+          */
+         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 ->
+                 ts2.flatMap(t2 ->
+                 ts3.flatMap(t3 ->
+                 ts4.map(t4 -> f.apply(t1, t2, t3, t4)))));
+         }
+
+     }
+
+     /**
+      * For-comprehension with 5 Iterators.
+      */
+     public static class For5Option<T1, T2, T3, T4, T5> {
+
+         private final Option<T1> ts1;
+         private final Option<T2> ts2;
+         private final Option<T3> ts3;
+         private final Option<T4> ts4;
+         private final Option<T5> ts5;
+
+         private For5Option(Option<T1> ts1, Option<T2> ts2, Option<T3> ts3, Option<T4> ts4, Option<T5> ts5) {
+             this.ts1 = ts1;
+             this.ts2 = ts2;
+             this.ts3 = ts3;
+             this.ts4 = ts4;
+             this.ts5 = ts5;
+         }
+
+         /**
+          * Yields a result for elements of the cross product of the underlying Iterables.
+          *
+          * @param f a function that maps an element of the cross product to a result
+          * @param <R> type of the resulting {@code Iterator} elements
+          * @return an {@code Iterator} of mapped results
+          */
+         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 ->
+                 ts2.flatMap(t2 ->
+                 ts3.flatMap(t3 ->
+                 ts4.flatMap(t4 ->
+                 ts5.map(t5 -> f.apply(t1, t2, t3, t4, t5))))));
+         }
+
+     }
+
+     /**
+      * For-comprehension with 6 Iterators.
+      */
+     public static class For6Option<T1, T2, T3, T4, T5, T6> {
+
+         private final Option<T1> ts1;
+         private final Option<T2> ts2;
+         private final Option<T3> ts3;
+         private final Option<T4> ts4;
+         private final Option<T5> ts5;
+         private final Option<T6> ts6;
+
+         private For6Option(Option<T1> ts1, Option<T2> ts2, Option<T3> ts3, Option<T4> ts4, Option<T5> ts5, Option<T6> ts6) {
+             this.ts1 = ts1;
+             this.ts2 = ts2;
+             this.ts3 = ts3;
+             this.ts4 = ts4;
+             this.ts5 = ts5;
+             this.ts6 = ts6;
+         }
+
+         /**
+          * Yields a result for elements of the cross product of the underlying Iterables.
+          *
+          * @param f a function that maps an element of the cross product to a result
+          * @param <R> type of the resulting {@code Iterator} elements
+          * @return an {@code Iterator} of mapped results
+          */
+         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 ->
+                 ts2.flatMap(t2 ->
+                 ts3.flatMap(t3 ->
+                 ts4.flatMap(t4 ->
+                 ts5.flatMap(t5 ->
+                 ts6.map(t6 -> f.apply(t1, t2, t3, t4, t5, t6)))))));
+         }
+
+     }
+
+     /**
+      * For-comprehension with 7 Iterators.
+      */
+     public static class For7Option<T1, T2, T3, T4, T5, T6, T7> {
+
+         private final Option<T1> ts1;
+         private final Option<T2> ts2;
+         private final Option<T3> ts3;
+         private final Option<T4> ts4;
+         private final Option<T5> ts5;
+         private final Option<T6> ts6;
+         private final Option<T7> ts7;
+
+         private For7Option(Option<T1> ts1, Option<T2> ts2, Option<T3> ts3, Option<T4> ts4, Option<T5> ts5, Option<T6> ts6, Option<T7> ts7) {
+             this.ts1 = ts1;
+             this.ts2 = ts2;
+             this.ts3 = ts3;
+             this.ts4 = ts4;
+             this.ts5 = ts5;
+             this.ts6 = ts6;
+             this.ts7 = ts7;
+         }
+
+         /**
+          * Yields a result for elements of the cross product of the underlying Iterables.
+          *
+          * @param f a function that maps an element of the cross product to a result
+          * @param <R> type of the resulting {@code Iterator} elements
+          * @return an {@code Iterator} of mapped results
+          */
+         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 ->
+                 ts2.flatMap(t2 ->
+                 ts3.flatMap(t3 ->
+                 ts4.flatMap(t4 ->
+                 ts5.flatMap(t5 ->
+                 ts6.flatMap(t6 ->
+                 ts7.map(t7 -> f.apply(t1, t2, t3, t4, t5, t6, t7))))))));
+         }
+
+     }
+
+     /**
+      * For-comprehension with 8 Iterators.
+      */
+     public static class For8Option<T1, T2, T3, T4, T5, T6, T7, T8> {
+
+         private final Option<T1> ts1;
+         private final Option<T2> ts2;
+         private final Option<T3> ts3;
+         private final Option<T4> ts4;
+         private final Option<T5> ts5;
+         private final Option<T6> ts6;
+         private final Option<T7> ts7;
+         private final Option<T8> ts8;
+
+         private For8Option(Option<T1> ts1, Option<T2> ts2, Option<T3> ts3, Option<T4> ts4, Option<T5> ts5, Option<T6> ts6, Option<T7> ts7, 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;
+         }
+
+         /**
+          * Yields a result for elements of the cross product of the underlying Iterables.
+          *
+          * @param f a function that maps an element of the cross product to a result
+          * @param <R> type of the resulting {@code Iterator} elements
+          * @return an {@code Iterator} of mapped results
+          */
+         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 ->
+                 ts2.flatMap(t2 ->
+                 ts3.flatMap(t3 ->
+                 ts4.flatMap(t4 ->
+                 ts5.flatMap(t5 ->
+                 ts6.flatMap(t6 ->
+                 ts7.flatMap(t7 ->
+                 ts8.map(t8 -> f.apply(t1, t2, t3, t4, t5, t6, t7, t8)))))))));
+         }
+
+     }
+
+     /**
+      * For-comprehension with one Iterator.
+      */
+     public static class For1Future<T1> {
+
+         private final Future<T1> ts1;
+
+         private For1Future(Future<T1> ts1) {
+             this.ts1 = ts1;
+         }
+
+         /**
+          * Yields a result for elements of the cross product of the underlying Iterables.
+          *
+          * @param f a function that maps an element of the cross product to a result
+          * @param <R> type of the resulting {@code Iterator} elements
+          * @return an {@code Iterator} of mapped results
+          */
+         public <R> Future<R> yield(Function<? super T1, ? extends R> f) {
+             Objects.requireNonNull(f, "f is null");
+             return ts1.map(f);
+         }
+
+         /**
+          * A shortcut for {@code yield(Function.identity())}.
+          *
+          * @return an {@code Iterator} of mapped results
+          */
+         public Future<T1> yield() {
+             return yield(Function.identity());
+         }
+     }
+
+     /**
+      * For-comprehension with two Iterators.
+      */
+     public static class For2Future<T1, T2> {
+
+         private final Future<T1> ts1;
+         private final Future<T2> ts2;
+
+         private For2Future(Future<T1> ts1, Future<T2> ts2) {
+             this.ts1 = ts1;
+             this.ts2 = ts2;
+         }
+
+         /**
+          * Yields a result for elements of the cross product of the underlying Iterables.
+          *
+          * @param f a function that maps an element of the cross product to a result
+          * @param <R> type of the resulting {@code Iterator} elements
+          * @return an {@code Iterator} of mapped results
+          */
+         public <R> Future<R> yield(BiFunction<? super T1, ? super T2, ? extends R> f) {
+             Objects.requireNonNull(f, "f is null");
+             return
+                 ts1.flatMap(t1 ->
+                 ts2.map(t2 -> f.apply(t1, t2)));
+         }
+
+     }
+
+     /**
+      * For-comprehension with three Iterators.
+      */
+     public static class For3Future<T1, T2, T3> {
+
+         private final Future<T1> ts1;
+         private final Future<T2> ts2;
+         private final Future<T3> ts3;
+
+         private For3Future(Future<T1> ts1, Future<T2> ts2, Future<T3> ts3) {
+             this.ts1 = ts1;
+             this.ts2 = ts2;
+             this.ts3 = ts3;
+         }
+
+         /**
+          * Yields a result for elements of the cross product of the underlying Iterables.
+          *
+          * @param f a function that maps an element of the cross product to a result
+          * @param <R> type of the resulting {@code Iterator} elements
+          * @return an {@code Iterator} of mapped results
+          */
+         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 ->
+                 ts2.flatMap(t2 ->
+                 ts3.map(t3 -> f.apply(t1, t2, t3))));
+         }
+
+     }
+
+     /**
+      * For-comprehension with 4 Iterators.
+      */
+     public static class For4Future<T1, T2, T3, T4> {
+
+         private final Future<T1> ts1;
+         private final Future<T2> ts2;
+         private final Future<T3> ts3;
+         private final Future<T4> ts4;
+
+         private For4Future(Future<T1> ts1, Future<T2> ts2, Future<T3> ts3, Future<T4> ts4) {
+             this.ts1 = ts1;
+             this.ts2 = ts2;
+             this.ts3 = ts3;
+             this.ts4 = ts4;
+         }
+
+         /**
+          * Yields a result for elements of the cross product of the underlying Iterables.
+          *
+          * @param f a function that maps an element of the cross product to a result
+          * @param <R> type of the resulting {@code Iterator} elements
+          * @return an {@code Iterator} of mapped results
+          */
+         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 ->
+                 ts2.flatMap(t2 ->
+                 ts3.flatMap(t3 ->
+                 ts4.map(t4 -> f.apply(t1, t2, t3, t4)))));
+         }
+
+     }
+
+     /**
+      * For-comprehension with 5 Iterators.
+      */
+     public static class For5Future<T1, T2, T3, T4, T5> {
+
+         private final Future<T1> ts1;
+         private final Future<T2> ts2;
+         private final Future<T3> ts3;
+         private final Future<T4> ts4;
+         private final Future<T5> ts5;
+
+         private For5Future(Future<T1> ts1, Future<T2> ts2, Future<T3> ts3, Future<T4> ts4, Future<T5> ts5) {
+             this.ts1 = ts1;
+             this.ts2 = ts2;
+             this.ts3 = ts3;
+             this.ts4 = ts4;
+             this.ts5 = ts5;
+         }
+
+         /**
+          * Yields a result for elements of the cross product of the underlying Iterables.
+          *
+          * @param f a function that maps an element of the cross product to a result
+          * @param <R> type of the resulting {@code Iterator} elements
+          * @return an {@code Iterator} of mapped results
+          */
+         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 ->
+                 ts2.flatMap(t2 ->
+                 ts3.flatMap(t3 ->
+                 ts4.flatMap(t4 ->
+                 ts5.map(t5 -> f.apply(t1, t2, t3, t4, t5))))));
+         }
+
+     }
+
+     /**
+      * For-comprehension with 6 Iterators.
+      */
+     public static class For6Future<T1, T2, T3, T4, T5, T6> {
+
+         private final Future<T1> ts1;
+         private final Future<T2> ts2;
+         private final Future<T3> ts3;
+         private final Future<T4> ts4;
+         private final Future<T5> ts5;
+         private final Future<T6> ts6;
+
+         private For6Future(Future<T1> ts1, Future<T2> ts2, Future<T3> ts3, Future<T4> ts4, Future<T5> ts5, Future<T6> ts6) {
+             this.ts1 = ts1;
+             this.ts2 = ts2;
+             this.ts3 = ts3;
+             this.ts4 = ts4;
+             this.ts5 = ts5;
+             this.ts6 = ts6;
+         }
+
+         /**
+          * Yields a result for elements of the cross product of the underlying Iterables.
+          *
+          * @param f a function that maps an element of the cross product to a result
+          * @param <R> type of the resulting {@code Iterator} elements
+          * @return an {@code Iterator} of mapped results
+          */
+         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 ->
+                 ts2.flatMap(t2 ->
+                 ts3.flatMap(t3 ->
+                 ts4.flatMap(t4 ->
+                 ts5.flatMap(t5 ->
+                 ts6.map(t6 -> f.apply(t1, t2, t3, t4, t5, t6)))))));
+         }
+
+     }
+
+     /**
+      * For-comprehension with 7 Iterators.
+      */
+     public static class For7Future<T1, T2, T3, T4, T5, T6, T7> {
+
+         private final Future<T1> ts1;
+         private final Future<T2> ts2;
+         private final Future<T3> ts3;
+         private final Future<T4> ts4;
+         private final Future<T5> ts5;
+         private final Future<T6> ts6;
+         private final Future<T7> ts7;
+
+         private For7Future(Future<T1> ts1, Future<T2> ts2, Future<T3> ts3, Future<T4> ts4, Future<T5> ts5, Future<T6> ts6, Future<T7> ts7) {
+             this.ts1 = ts1;
+             this.ts2 = ts2;
+             this.ts3 = ts3;
+             this.ts4 = ts4;
+             this.ts5 = ts5;
+             this.ts6 = ts6;
+             this.ts7 = ts7;
+         }
+
+         /**
+          * Yields a result for elements of the cross product of the underlying Iterables.
+          *
+          * @param f a function that maps an element of the cross product to a result
+          * @param <R> type of the resulting {@code Iterator} elements
+          * @return an {@code Iterator} of mapped results
+          */
+         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 ->
+                 ts2.flatMap(t2 ->
+                 ts3.flatMap(t3 ->
+                 ts4.flatMap(t4 ->
+                 ts5.flatMap(t5 ->
+                 ts6.flatMap(t6 ->
+                 ts7.map(t7 -> f.apply(t1, t2, t3, t4, t5, t6, t7))))))));
+         }
+
+     }
+
+     /**
+      * For-comprehension with 8 Iterators.
+      */
+     public static class For8Future<T1, T2, T3, T4, T5, T6, T7, T8> {
+
+         private final Future<T1> ts1;
+         private final Future<T2> ts2;
+         private final Future<T3> ts3;
+         private final Future<T4> ts4;
+         private final Future<T5> ts5;
+         private final Future<T6> ts6;
+         private final Future<T7> ts7;
+         private final Future<T8> ts8;
+
+         private For8Future(Future<T1> ts1, Future<T2> ts2, Future<T3> ts3, Future<T4> ts4, Future<T5> ts5, Future<T6> ts6, Future<T7> ts7, 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;
+         }
+
+         /**
+          * Yields a result for elements of the cross product of the underlying Iterables.
+          *
+          * @param f a function that maps an element of the cross product to a result
+          * @param <R> type of the resulting {@code Iterator} elements
+          * @return an {@code Iterator} of mapped results
+          */
+         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 ->
+                 ts2.flatMap(t2 ->
+                 ts3.flatMap(t3 ->
+                 ts4.flatMap(t4 ->
+                 ts5.flatMap(t5 ->
+                 ts6.flatMap(t6 ->
+                 ts7.flatMap(t7 ->
+                 ts8.map(t8 -> f.apply(t1, t2, t3, t4, t5, t6, t7, t8)))))))));
+         }
+
+     }
+
+     /**
+      * For-comprehension with one Iterator.
+      */
+     public static class For1Try<T1> {
+
+         private final Try<T1> ts1;
+
+         private For1Try(Try<T1> ts1) {
+             this.ts1 = ts1;
+         }
+
+         /**
+          * Yields a result for elements of the cross product of the underlying Iterables.
+          *
+          * @param f a function that maps an element of the cross product to a result
+          * @param <R> type of the resulting {@code Iterator} elements
+          * @return an {@code Iterator} of mapped results
+          */
+         public <R> Try<R> yield(Function<? super T1, ? extends R> f) {
+             Objects.requireNonNull(f, "f is null");
+             return ts1.map(f);
+         }
+
+         /**
+          * A shortcut for {@code yield(Function.identity())}.
+          *
+          * @return an {@code Iterator} of mapped results
+          */
+         public Try<T1> yield() {
+             return yield(Function.identity());
+         }
+     }
+
+     /**
+      * For-comprehension with two Iterators.
+      */
+     public static class For2Try<T1, T2> {
+
+         private final Try<T1> ts1;
+         private final Try<T2> ts2;
+
+         private For2Try(Try<T1> ts1, Try<T2> ts2) {
+             this.ts1 = ts1;
+             this.ts2 = ts2;
+         }
+
+         /**
+          * Yields a result for elements of the cross product of the underlying Iterables.
+          *
+          * @param f a function that maps an element of the cross product to a result
+          * @param <R> type of the resulting {@code Iterator} elements
+          * @return an {@code Iterator} of mapped results
+          */
+         public <R> Try<R> yield(BiFunction<? super T1, ? super T2, ? extends R> f) {
+             Objects.requireNonNull(f, "f is null");
+             return
+                 ts1.flatMap(t1 ->
+                 ts2.map(t2 -> f.apply(t1, t2)));
+         }
+
+     }
+
+     /**
+      * For-comprehension with three Iterators.
+      */
+     public static class For3Try<T1, T2, T3> {
+
+         private final Try<T1> ts1;
+         private final Try<T2> ts2;
+         private final Try<T3> ts3;
+
+         private For3Try(Try<T1> ts1, Try<T2> ts2, Try<T3> ts3) {
+             this.ts1 = ts1;
+             this.ts2 = ts2;
+             this.ts3 = ts3;
+         }
+
+         /**
+          * Yields a result for elements of the cross product of the underlying Iterables.
+          *
+          * @param f a function that maps an element of the cross product to a result
+          * @param <R> type of the resulting {@code Iterator} elements
+          * @return an {@code Iterator} of mapped results
+          */
+         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 ->
+                 ts2.flatMap(t2 ->
+                 ts3.map(t3 -> f.apply(t1, t2, t3))));
+         }
+
+     }
+
+     /**
+      * For-comprehension with 4 Iterators.
+      */
+     public static class For4Try<T1, T2, T3, T4> {
+
+         private final Try<T1> ts1;
+         private final Try<T2> ts2;
+         private final Try<T3> ts3;
+         private final Try<T4> ts4;
+
+         private For4Try(Try<T1> ts1, Try<T2> ts2, Try<T3> ts3, Try<T4> ts4) {
+             this.ts1 = ts1;
+             this.ts2 = ts2;
+             this.ts3 = ts3;
+             this.ts4 = ts4;
+         }
+
+         /**
+          * Yields a result for elements of the cross product of the underlying Iterables.
+          *
+          * @param f a function that maps an element of the cross product to a result
+          * @param <R> type of the resulting {@code Iterator} elements
+          * @return an {@code Iterator} of mapped results
+          */
+         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 ->
+                 ts2.flatMap(t2 ->
+                 ts3.flatMap(t3 ->
+                 ts4.map(t4 -> f.apply(t1, t2, t3, t4)))));
+         }
+
+     }
+
+     /**
+      * For-comprehension with 5 Iterators.
+      */
+     public static class For5Try<T1, T2, T3, T4, T5> {
+
+         private final Try<T1> ts1;
+         private final Try<T2> ts2;
+         private final Try<T3> ts3;
+         private final Try<T4> ts4;
+         private final Try<T5> ts5;
+
+         private For5Try(Try<T1> ts1, Try<T2> ts2, Try<T3> ts3, Try<T4> ts4, Try<T5> ts5) {
+             this.ts1 = ts1;
+             this.ts2 = ts2;
+             this.ts3 = ts3;
+             this.ts4 = ts4;
+             this.ts5 = ts5;
+         }
+
+         /**
+          * Yields a result for elements of the cross product of the underlying Iterables.
+          *
+          * @param f a function that maps an element of the cross product to a result
+          * @param <R> type of the resulting {@code Iterator} elements
+          * @return an {@code Iterator} of mapped results
+          */
+         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 ->
+                 ts2.flatMap(t2 ->
+                 ts3.flatMap(t3 ->
+                 ts4.flatMap(t4 ->
+                 ts5.map(t5 -> f.apply(t1, t2, t3, t4, t5))))));
+         }
+
+     }
+
+     /**
+      * For-comprehension with 6 Iterators.
+      */
+     public static class For6Try<T1, T2, T3, T4, T5, T6> {
+
+         private final Try<T1> ts1;
+         private final Try<T2> ts2;
+         private final Try<T3> ts3;
+         private final Try<T4> ts4;
+         private final Try<T5> ts5;
+         private final Try<T6> ts6;
+
+         private For6Try(Try<T1> ts1, Try<T2> ts2, Try<T3> ts3, Try<T4> ts4, Try<T5> ts5, Try<T6> ts6) {
+             this.ts1 = ts1;
+             this.ts2 = ts2;
+             this.ts3 = ts3;
+             this.ts4 = ts4;
+             this.ts5 = ts5;
+             this.ts6 = ts6;
+         }
+
+         /**
+          * Yields a result for elements of the cross product of the underlying Iterables.
+          *
+          * @param f a function that maps an element of the cross product to a result
+          * @param <R> type of the resulting {@code Iterator} elements
+          * @return an {@code Iterator} of mapped results
+          */
+         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 ->
+                 ts2.flatMap(t2 ->
+                 ts3.flatMap(t3 ->
+                 ts4.flatMap(t4 ->
+                 ts5.flatMap(t5 ->
+                 ts6.map(t6 -> f.apply(t1, t2, t3, t4, t5, t6)))))));
+         }
+
+     }
+
+     /**
+      * For-comprehension with 7 Iterators.
+      */
+     public static class For7Try<T1, T2, T3, T4, T5, T6, T7> {
+
+         private final Try<T1> ts1;
+         private final Try<T2> ts2;
+         private final Try<T3> ts3;
+         private final Try<T4> ts4;
+         private final Try<T5> ts5;
+         private final Try<T6> ts6;
+         private final Try<T7> ts7;
+
+         private For7Try(Try<T1> ts1, Try<T2> ts2, Try<T3> ts3, Try<T4> ts4, Try<T5> ts5, Try<T6> ts6, Try<T7> ts7) {
+             this.ts1 = ts1;
+             this.ts2 = ts2;
+             this.ts3 = ts3;
+             this.ts4 = ts4;
+             this.ts5 = ts5;
+             this.ts6 = ts6;
+             this.ts7 = ts7;
+         }
+
+         /**
+          * Yields a result for elements of the cross product of the underlying Iterables.
+          *
+          * @param f a function that maps an element of the cross product to a result
+          * @param <R> type of the resulting {@code Iterator} elements
+          * @return an {@code Iterator} of mapped results
+          */
+         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 ->
+                 ts2.flatMap(t2 ->
+                 ts3.flatMap(t3 ->
+                 ts4.flatMap(t4 ->
+                 ts5.flatMap(t5 ->
+                 ts6.flatMap(t6 ->
+                 ts7.map(t7 -> f.apply(t1, t2, t3, t4, t5, t6, t7))))))));
+         }
+
+     }
+
+     /**
+      * For-comprehension with 8 Iterators.
+      */
+     public static class For8Try<T1, T2, T3, T4, T5, T6, T7, T8> {
+
+         private final Try<T1> ts1;
+         private final Try<T2> ts2;
+         private final Try<T3> ts3;
+         private final Try<T4> ts4;
+         private final Try<T5> ts5;
+         private final Try<T6> ts6;
+         private final Try<T7> ts7;
+         private final Try<T8> ts8;
+
+         private For8Try(Try<T1> ts1, Try<T2> ts2, Try<T3> ts3, Try<T4> ts4, Try<T5> ts5, Try<T6> ts6, Try<T7> ts7, 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;
+         }
+
+         /**
+          * Yields a result for elements of the cross product of the underlying Iterables.
+          *
+          * @param f a function that maps an element of the cross product to a result
+          * @param <R> type of the resulting {@code Iterator} elements
+          * @return an {@code Iterator} of mapped results
+          */
+         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 ->
+                 ts2.flatMap(t2 ->
+                 ts3.flatMap(t3 ->
+                 ts4.flatMap(t4 ->
+                 ts5.flatMap(t5 ->
+                 ts6.flatMap(t6 ->
+                 ts7.flatMap(t7 ->
+                 ts8.map(t8 -> f.apply(t1, t2, t3, t4, t5, t6, t7, t8)))))))));
+         }
+
+     }
+
+     /**
+      * For-comprehension with one Iterator.
+      */
+     public static class For1List<T1> {
+
+         private final List<T1> ts1;
+
+         private For1List(List<T1> ts1) {
+             this.ts1 = ts1;
+         }
+
+         /**
+          * Yields a result for elements of the cross product of the underlying Iterables.
+          *
+          * @param f a function that maps an element of the cross product to a result
+          * @param <R> type of the resulting {@code Iterator} elements
+          * @return an {@code Iterator} of mapped results
+          */
+         public <R> List<R> yield(Function<? super T1, ? extends R> f) {
+             Objects.requireNonNull(f, "f is null");
+             return ts1.map(f);
+         }
+
+         /**
+          * A shortcut for {@code yield(Function.identity())}.
+          *
+          * @return an {@code Iterator} of mapped results
+          */
+         public List<T1> yield() {
+             return yield(Function.identity());
+         }
+     }
+
+     /**
+      * For-comprehension with two Iterators.
+      */
+     public static class For2List<T1, T2> {
+
+         private final List<T1> ts1;
+         private final List<T2> ts2;
+
+         private For2List(List<T1> ts1, List<T2> ts2) {
+             this.ts1 = ts1;
+             this.ts2 = ts2;
+         }
+
+         /**
+          * Yields a result for elements of the cross product of the underlying Iterables.
+          *
+          * @param f a function that maps an element of the cross product to a result
+          * @param <R> type of the resulting {@code Iterator} elements
+          * @return an {@code Iterator} of mapped results
+          */
+         public <R> List<R> yield(BiFunction<? super T1, ? super T2, ? extends R> f) {
+             Objects.requireNonNull(f, "f is null");
+             return
+                 ts1.flatMap(t1 ->
+                 ts2.map(t2 -> f.apply(t1, t2)));
+         }
+
+     }
+
+     /**
+      * For-comprehension with three Iterators.
+      */
+     public static class For3List<T1, T2, T3> {
+
+         private final List<T1> ts1;
+         private final List<T2> ts2;
+         private final List<T3> ts3;
+
+         private For3List(List<T1> ts1, List<T2> ts2, List<T3> ts3) {
+             this.ts1 = ts1;
+             this.ts2 = ts2;
+             this.ts3 = ts3;
+         }
+
+         /**
+          * Yields a result for elements of the cross product of the underlying Iterables.
+          *
+          * @param f a function that maps an element of the cross product to a result
+          * @param <R> type of the resulting {@code Iterator} elements
+          * @return an {@code Iterator} of mapped results
+          */
+         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 ->
+                 ts2.flatMap(t2 ->
+                 ts3.map(t3 -> f.apply(t1, t2, t3))));
+         }
+
+     }
+
+     /**
+      * For-comprehension with 4 Iterators.
+      */
+     public static class For4List<T1, T2, T3, T4> {
+
+         private final List<T1> ts1;
+         private final List<T2> ts2;
+         private final List<T3> ts3;
+         private final List<T4> ts4;
+
+         private For4List(List<T1> ts1, List<T2> ts2, List<T3> ts3, List<T4> ts4) {
+             this.ts1 = ts1;
+             this.ts2 = ts2;
+             this.ts3 = ts3;
+             this.ts4 = ts4;
+         }
+
+         /**
+          * Yields a result for elements of the cross product of the underlying Iterables.
+          *
+          * @param f a function that maps an element of the cross product to a result
+          * @param <R> type of the resulting {@code Iterator} elements
+          * @return an {@code Iterator} of mapped results
+          */
+         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 ->
+                 ts2.flatMap(t2 ->
+                 ts3.flatMap(t3 ->
+                 ts4.map(t4 -> f.apply(t1, t2, t3, t4)))));
+         }
+
+     }
+
+     /**
+      * For-comprehension with 5 Iterators.
+      */
+     public static class For5List<T1, T2, T3, T4, T5> {
+
+         private final List<T1> ts1;
+         private final List<T2> ts2;
+         private final List<T3> ts3;
+         private final List<T4> ts4;
+         private final List<T5> ts5;
+
+         private For5List(List<T1> ts1, List<T2> ts2, List<T3> ts3, List<T4> ts4, List<T5> ts5) {
+             this.ts1 = ts1;
+             this.ts2 = ts2;
+             this.ts3 = ts3;
+             this.ts4 = ts4;
+             this.ts5 = ts5;
+         }
+
+         /**
+          * Yields a result for elements of the cross product of the underlying Iterables.
+          *
+          * @param f a function that maps an element of the cross product to a result
+          * @param <R> type of the resulting {@code Iterator} elements
+          * @return an {@code Iterator} of mapped results
+          */
+         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 ->
+                 ts2.flatMap(t2 ->
+                 ts3.flatMap(t3 ->
+                 ts4.flatMap(t4 ->
+                 ts5.map(t5 -> f.apply(t1, t2, t3, t4, t5))))));
+         }
+
+     }
+
+     /**
+      * For-comprehension with 6 Iterators.
+      */
+     public static class For6List<T1, T2, T3, T4, T5, T6> {
+
+         private final List<T1> ts1;
+         private final List<T2> ts2;
+         private final List<T3> ts3;
+         private final List<T4> ts4;
+         private final List<T5> ts5;
+         private final List<T6> ts6;
+
+         private For6List(List<T1> ts1, List<T2> ts2, List<T3> ts3, List<T4> ts4, List<T5> ts5, List<T6> ts6) {
+             this.ts1 = ts1;
+             this.ts2 = ts2;
+             this.ts3 = ts3;
+             this.ts4 = ts4;
+             this.ts5 = ts5;
+             this.ts6 = ts6;
+         }
+
+         /**
+          * Yields a result for elements of the cross product of the underlying Iterables.
+          *
+          * @param f a function that maps an element of the cross product to a result
+          * @param <R> type of the resulting {@code Iterator} elements
+          * @return an {@code Iterator} of mapped results
+          */
+         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 ->
+                 ts2.flatMap(t2 ->
+                 ts3.flatMap(t3 ->
+                 ts4.flatMap(t4 ->
+                 ts5.flatMap(t5 ->
+                 ts6.map(t6 -> f.apply(t1, t2, t3, t4, t5, t6)))))));
+         }
+
+     }
+
+     /**
+      * For-comprehension with 7 Iterators.
+      */
+     public static class For7List<T1, T2, T3, T4, T5, T6, T7> {
+
+         private final List<T1> ts1;
+         private final List<T2> ts2;
+         private final List<T3> ts3;
+         private final List<T4> ts4;
+         private final List<T5> ts5;
+         private final List<T6> ts6;
+         private final List<T7> ts7;
+
+         private For7List(List<T1> ts1, List<T2> ts2, List<T3> ts3, List<T4> ts4, List<T5> ts5, List<T6> ts6, List<T7> ts7) {
+             this.ts1 = ts1;
+             this.ts2 = ts2;
+             this.ts3 = ts3;
+             this.ts4 = ts4;
+             this.ts5 = ts5;
+             this.ts6 = ts6;
+             this.ts7 = ts7;
+         }
+
+         /**
+          * Yields a result for elements of the cross product of the underlying Iterables.
+          *
+          * @param f a function that maps an element of the cross product to a result
+          * @param <R> type of the resulting {@code Iterator} elements
+          * @return an {@code Iterator} of mapped results
+          */
+         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 ->
+                 ts2.flatMap(t2 ->
+                 ts3.flatMap(t3 ->
+                 ts4.flatMap(t4 ->
+                 ts5.flatMap(t5 ->
+                 ts6.flatMap(t6 ->
+                 ts7.map(t7 -> f.apply(t1, t2, t3, t4, t5, t6, t7))))))));
+         }
+
+     }
+
+     /**
+      * For-comprehension with 8 Iterators.
+      */
+     public static class For8List<T1, T2, T3, T4, T5, T6, T7, T8> {
+
+         private final List<T1> ts1;
+         private final List<T2> ts2;
+         private final List<T3> ts3;
+         private final List<T4> ts4;
+         private final List<T5> ts5;
+         private final List<T6> ts6;
+         private final List<T7> ts7;
+         private final List<T8> ts8;
+
+         private For8List(List<T1> ts1, List<T2> ts2, List<T3> ts3, List<T4> ts4, List<T5> ts5, List<T6> ts6, List<T7> ts7, 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;
+         }
+
+         /**
+          * Yields a result for elements of the cross product of the underlying Iterables.
+          *
+          * @param f a function that maps an element of the cross product to a result
+          * @param <R> type of the resulting {@code Iterator} elements
+          * @return an {@code Iterator} of mapped results
+          */
+         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 ->
+                 ts2.flatMap(t2 ->
+                 ts3.flatMap(t3 ->
+                 ts4.flatMap(t4 ->
+                 ts5.flatMap(t5 ->
+                 ts6.flatMap(t6 ->
+                 ts7.flatMap(t7 ->
+                 ts8.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 1afb30e186..2bf37005e4 100644
--- a/vavr/src-gen/test/java/io/vavr/APITest.java
+++ b/vavr/src-gen/test/java/io/vavr/APITest.java
@@ -29,7 +29,6 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.Assert.fail;
 
-import io.vavr.collection.CharSeq;
 import io.vavr.collection.List;
 import io.vavr.collection.Map;
 import io.vavr.concurrent.Future;
@@ -964,7 +963,7 @@ public void shouldIterateFor1UsingSimpleYield() {
     }
 
     @Test
-    public void shouldIterateFor1() {
+    public void shouldIterateForList1() {
         final List<Integer> result = For(
             List.of(1, 2, 3)
         ).yield(i1 -> i1).toList();
@@ -974,7 +973,7 @@ public void shouldIterateFor1() {
     }
 
     @Test
-    public void shouldIterateFor2() {
+    public void shouldIterateForList2() {
         final List<Integer> result = For(
             List.of(1, 2, 3),
             List.of(1, 2, 3)
@@ -985,7 +984,7 @@ public void shouldIterateFor2() {
     }
 
     @Test
-    public void shouldIterateFor3() {
+    public void shouldIterateForList3() {
         final List<Integer> result = For(
             List.of(1, 2, 3),
             List.of(1, 2, 3),
@@ -997,7 +996,7 @@ public void shouldIterateFor3() {
     }
 
     @Test
-    public void shouldIterateFor4() {
+    public void shouldIterateForList4() {
         final List<Integer> result = For(
             List.of(1, 2, 3),
             List.of(1, 2, 3),
@@ -1010,7 +1009,7 @@ public void shouldIterateFor4() {
     }
 
     @Test
-    public void shouldIterateFor5() {
+    public void shouldIterateForList5() {
         final List<Integer> result = For(
             List.of(1, 2, 3),
             List.of(1, 2, 3),
@@ -1024,7 +1023,7 @@ public void shouldIterateFor5() {
     }
 
     @Test
-    public void shouldIterateFor6() {
+    public void shouldIterateForList6() {
         final List<Integer> result = For(
             List.of(1, 2, 3),
             List.of(1, 2, 3),
@@ -1039,7 +1038,7 @@ public void shouldIterateFor6() {
     }
 
     @Test
-    public void shouldIterateFor7() {
+    public void shouldIterateForList7() {
         final List<Integer> result = For(
             List.of(1, 2, 3),
             List.of(1, 2, 3),
@@ -1055,7 +1054,7 @@ public void shouldIterateFor7() {
     }
 
     @Test
-    public void shouldIterateFor8() {
+    public void shouldIterateForList8() {
         final List<Integer> result = For(
             List.of(1, 2, 3),
             List.of(1, 2, 3),
@@ -1071,11 +1070,287 @@ public void shouldIterateFor8() {
         assertThat(result.last()).isEqualTo(3 * 8);
     }
 
+    @Test
+    public void shouldIterateForOption1() {
+        final Option<Integer> result = For(
+            Option.of(1)
+        ).yield(i1 -> i1);
+        assertThat(result.get()).isEqualTo(1);
+    }
+
+    @Test
+    public void shouldIterateForOption2() {
+        final Option<Integer> result = For(
+            Option.of(1),
+            Option.of(2)
+        ).yield((i1, i2) -> i1 + i2);
+        assertThat(result.get()).isEqualTo(3);
+    }
+
+    @Test
+    public void shouldIterateForOption3() {
+        final Option<Integer> result = For(
+            Option.of(1),
+            Option.of(2),
+            Option.of(3)
+        ).yield((i1, i2, i3) -> i1 + i2 + i3);
+        assertThat(result.get()).isEqualTo(6);
+    }
+
+    @Test
+    public void shouldIterateForOption4() {
+        final Option<Integer> result = For(
+            Option.of(1),
+            Option.of(2),
+            Option.of(3),
+            Option.of(4)
+        ).yield((i1, i2, i3, i4) -> i1 + i2 + i3 + i4);
+        assertThat(result.get()).isEqualTo(10);
+    }
+
+    @Test
+    public void shouldIterateForOption5() {
+        final Option<Integer> result = For(
+            Option.of(1),
+            Option.of(2),
+            Option.of(3),
+            Option.of(4),
+            Option.of(5)
+        ).yield((i1, i2, i3, i4, i5) -> i1 + i2 + i3 + i4 + i5);
+        assertThat(result.get()).isEqualTo(15);
+    }
+
+    @Test
+    public void shouldIterateForOption6() {
+        final Option<Integer> result = For(
+            Option.of(1),
+            Option.of(2),
+            Option.of(3),
+            Option.of(4),
+            Option.of(5),
+            Option.of(6)
+        ).yield((i1, i2, i3, i4, i5, i6) -> i1 + i2 + i3 + i4 + i5 + i6);
+        assertThat(result.get()).isEqualTo(21);
+    }
+
+    @Test
+    public void shouldIterateForOption7() {
+        final Option<Integer> result = For(
+            Option.of(1),
+            Option.of(2),
+            Option.of(3),
+            Option.of(4),
+            Option.of(5),
+            Option.of(6),
+            Option.of(7)
+        ).yield((i1, i2, i3, i4, i5, i6, i7) -> i1 + i2 + i3 + i4 + i5 + i6 + i7);
+        assertThat(result.get()).isEqualTo(28);
+    }
+
+    @Test
+    public void shouldIterateForOption8() {
+        final Option<Integer> result = For(
+            Option.of(1),
+            Option.of(2),
+            Option.of(3),
+            Option.of(4),
+            Option.of(5),
+            Option.of(6),
+            Option.of(7),
+            Option.of(8)
+        ).yield((i1, i2, i3, i4, i5, i6, i7, i8) -> i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8);
+        assertThat(result.get()).isEqualTo(36);
+    }
+
+    @Test
+    public void shouldIterateForFuture1() {
+        final Future<Integer> result = For(
+            Future.of(() -> 1)
+        ).yield(i1 -> i1);
+        assertThat(result.get()).isEqualTo(1);
+    }
+
+    @Test
+    public void shouldIterateForFuture2() {
+        final Future<Integer> result = For(
+            Future.of(() -> 1),
+            Future.of(() -> 2)
+        ).yield((i1, i2) -> i1 + i2);
+        assertThat(result.get()).isEqualTo(3);
+    }
+
+    @Test
+    public void shouldIterateForFuture3() {
+        final Future<Integer> result = For(
+            Future.of(() -> 1),
+            Future.of(() -> 2),
+            Future.of(() -> 3)
+        ).yield((i1, i2, i3) -> i1 + i2 + i3);
+        assertThat(result.get()).isEqualTo(6);
+    }
+
+    @Test
+    public void shouldIterateForFuture4() {
+        final Future<Integer> result = For(
+            Future.of(() -> 1),
+            Future.of(() -> 2),
+            Future.of(() -> 3),
+            Future.of(() -> 4)
+        ).yield((i1, i2, i3, i4) -> i1 + i2 + i3 + i4);
+        assertThat(result.get()).isEqualTo(10);
+    }
+
+    @Test
+    public void shouldIterateForFuture5() {
+        final Future<Integer> result = For(
+            Future.of(() -> 1),
+            Future.of(() -> 2),
+            Future.of(() -> 3),
+            Future.of(() -> 4),
+            Future.of(() -> 5)
+        ).yield((i1, i2, i3, i4, i5) -> i1 + i2 + i3 + i4 + i5);
+        assertThat(result.get()).isEqualTo(15);
+    }
+
+    @Test
+    public void shouldIterateForFuture6() {
+        final Future<Integer> result = For(
+            Future.of(() -> 1),
+            Future.of(() -> 2),
+            Future.of(() -> 3),
+            Future.of(() -> 4),
+            Future.of(() -> 5),
+            Future.of(() -> 6)
+        ).yield((i1, i2, i3, i4, i5, i6) -> i1 + i2 + i3 + i4 + i5 + i6);
+        assertThat(result.get()).isEqualTo(21);
+    }
+
+    @Test
+    public void shouldIterateForFuture7() {
+        final Future<Integer> result = For(
+            Future.of(() -> 1),
+            Future.of(() -> 2),
+            Future.of(() -> 3),
+            Future.of(() -> 4),
+            Future.of(() -> 5),
+            Future.of(() -> 6),
+            Future.of(() -> 7)
+        ).yield((i1, i2, i3, i4, i5, i6, i7) -> i1 + i2 + i3 + i4 + i5 + i6 + i7);
+        assertThat(result.get()).isEqualTo(28);
+    }
+
+    @Test
+    public void shouldIterateForFuture8() {
+        final Future<Integer> result = For(
+            Future.of(() -> 1),
+            Future.of(() -> 2),
+            Future.of(() -> 3),
+            Future.of(() -> 4),
+            Future.of(() -> 5),
+            Future.of(() -> 6),
+            Future.of(() -> 7),
+            Future.of(() -> 8)
+        ).yield((i1, i2, i3, i4, i5, i6, i7, i8) -> i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8);
+        assertThat(result.get()).isEqualTo(36);
+    }
+
+    @Test
+    public void shouldIterateForTry1() {
+        final Try<Integer> result = For(
+            Try.of(() -> 1)
+        ).yield(i1 -> i1);
+        assertThat(result.get()).isEqualTo(1);
+    }
+
+    @Test
+    public void shouldIterateForTry2() {
+        final Try<Integer> result = For(
+            Try.of(() -> 1),
+            Try.of(() -> 2)
+        ).yield((i1, i2) -> i1 + i2);
+        assertThat(result.get()).isEqualTo(3);
+    }
+
+    @Test
+    public void shouldIterateForTry3() {
+        final Try<Integer> result = For(
+            Try.of(() -> 1),
+            Try.of(() -> 2),
+            Try.of(() -> 3)
+        ).yield((i1, i2, i3) -> i1 + i2 + i3);
+        assertThat(result.get()).isEqualTo(6);
+    }
+
+    @Test
+    public void shouldIterateForTry4() {
+        final Try<Integer> result = For(
+            Try.of(() -> 1),
+            Try.of(() -> 2),
+            Try.of(() -> 3),
+            Try.of(() -> 4)
+        ).yield((i1, i2, i3, i4) -> i1 + i2 + i3 + i4);
+        assertThat(result.get()).isEqualTo(10);
+    }
+
+    @Test
+    public void shouldIterateForTry5() {
+        final Try<Integer> result = For(
+            Try.of(() -> 1),
+            Try.of(() -> 2),
+            Try.of(() -> 3),
+            Try.of(() -> 4),
+            Try.of(() -> 5)
+        ).yield((i1, i2, i3, i4, i5) -> i1 + i2 + i3 + i4 + i5);
+        assertThat(result.get()).isEqualTo(15);
+    }
+
+    @Test
+    public void shouldIterateForTry6() {
+        final Try<Integer> result = For(
+            Try.of(() -> 1),
+            Try.of(() -> 2),
+            Try.of(() -> 3),
+            Try.of(() -> 4),
+            Try.of(() -> 5),
+            Try.of(() -> 6)
+        ).yield((i1, i2, i3, i4, i5, i6) -> i1 + i2 + i3 + i4 + i5 + i6);
+        assertThat(result.get()).isEqualTo(21);
+    }
+
+    @Test
+    public void shouldIterateForTry7() {
+        final Try<Integer> result = For(
+            Try.of(() -> 1),
+            Try.of(() -> 2),
+            Try.of(() -> 3),
+            Try.of(() -> 4),
+            Try.of(() -> 5),
+            Try.of(() -> 6),
+            Try.of(() -> 7)
+        ).yield((i1, i2, i3, i4, i5, i6, i7) -> i1 + i2 + i3 + i4 + i5 + i6 + i7);
+        assertThat(result.get()).isEqualTo(28);
+    }
+
+    @Test
+    public void shouldIterateForTry8() {
+        final Try<Integer> result = For(
+            Try.of(() -> 1),
+            Try.of(() -> 2),
+            Try.of(() -> 3),
+            Try.of(() -> 4),
+            Try.of(() -> 5),
+            Try.of(() -> 6),
+            Try.of(() -> 7),
+            Try.of(() -> 8)
+        ).yield((i1, i2, i3, i4, i5, i6, i7, i8) -> i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8);
+        assertThat(result.get()).isEqualTo(36);
+    }
+
     @Test
     public void shouldIterateNestedFor() {
         final List<String> result =
                 For(Arrays.asList(1, 2), i ->
-                        For(CharSeq.of('a', 'b')).yield(c -> i + ":" + c)).toList();
+                        For(List.of('a', 'b')).yield(c -> i + ":" + c)).toList();
         assertThat(result).isEqualTo(List.of("1:a", "1:b", "2:a", "2:b"));
     }