diff --git a/MoreLinq.Test/PairwiseTest.cs b/MoreLinq.Test/PairwiseTest.cs
index 5dace66b8..004538b74 100644
--- a/MoreLinq.Test/PairwiseTest.cs
+++ b/MoreLinq.Test/PairwiseTest.cs
@@ -20,30 +20,60 @@ namespace MoreLinq.Test
     using NUnit.Framework;
 
     [TestFixture]
-    public class PairwiseTest
+    public static class PairwiseTest
     {
-        [Test]
-        public void PairwiseIsLazy()
+        public class ReturningTuples
         {
-            _ = new BreakingSequence<object>().Pairwise(BreakingFunc.Of<object, object, int>());
-        }
+            [Test]
+            public void PairwiseIsLazy()
+            {
+                _ = new BreakingSequence<object>().Pairwise();
+            }
 
-        [TestCase(0)]
-        [TestCase(1)]
-        public void PairwiseWithSequenceShorterThanTwo(int count)
-        {
-            var source = Enumerable.Range(0, count);
-            var result = source.Pairwise(BreakingFunc.Of<int, int, int>());
+            [TestCase(0)]
+            [TestCase(1)]
+            public void PairwiseWithSequenceShorterThanTwo(int count)
+            {
+                var source = Enumerable.Range(0, count);
+                var result = source.Pairwise();
+
+                Assert.That(result, Is.Empty);
+            }
 
-            Assert.That(result, Is.Empty);
+            [Test]
+            public void PairwiseWideSourceSequence()
+            {
+                using var source = new[] { "a", "b", "c", "d" }.AsTestingSequence();
+                var result = source.Pairwise();
+                result.AssertSequenceEqual(("a", "b"), ("b", "c"), ("c", "d"));
+            }
         }
 
-        [Test]
-        public void PairwiseWideSourceSequence()
+        public class ReturningSomeResults
         {
-            using var source = new[] { "a", "b", "c", "d" }.AsTestingSequence();
-            var result = source.Pairwise((x, y) => x + y);
-            result.AssertSequenceEqual("ab", "bc", "cd");
+            [Test]
+            public void PairwiseIsLazy()
+            {
+                _ = new BreakingSequence<object>().Pairwise(BreakingFunc.Of<object, object, int>());
+            }
+
+            [TestCase(0)]
+            [TestCase(1)]
+            public void PairwiseWithSequenceShorterThanTwo(int count)
+            {
+                var source = Enumerable.Range(0, count);
+                var result = source.Pairwise(BreakingFunc.Of<int, int, int>());
+
+                Assert.That(result, Is.Empty);
+            }
+
+            [Test]
+            public void PairwiseWideSourceSequence()
+            {
+                using var source = new[] { "a", "b", "c", "d" }.AsTestingSequence();
+                var result = source.Pairwise((x, y) => x + y);
+                result.AssertSequenceEqual("ab", "bc", "cd");
+            }
         }
     }
 }
diff --git a/MoreLinq/Cartesian.g.cs b/MoreLinq/Cartesian.g.cs
index 64694c065..23c094d39 100644
--- a/MoreLinq/Cartesian.g.cs
+++ b/MoreLinq/Cartesian.g.cs
@@ -82,6 +82,33 @@ public static IEnumerable<TResult> Cartesian<T1, T2, TResult>(
             }
         }
 
+        /// <summary>
+        /// Returns the Cartesian product of two sequences by enumerating tuples
+        /// of all possible combinations of one item from each sequence.
+        /// </summary>
+        /// <typeparam name="T1">The type of the elements of <paramref name="first"/>.</typeparam>
+        /// <typeparam name="T2">The type of the elements of <paramref name="second"/>.</typeparam>
+        /// <param name="first">The first sequence of elements.</param>
+        /// <param name="second">The second sequence of elements.</param>
+        /// <returns>A sequence of tuples.</returns>
+        /// <remarks>
+        /// <para>
+        /// The method returns items in the same order as a nested foreach
+        /// loop, but all sequences except for <paramref name="first"/> are
+        /// cached when iterated over. The cache is then re-used for any
+        /// subsequent iterations.</para>
+        /// <para>
+        /// This method uses deferred execution and stream its results.</para>
+        /// </remarks>
+
+        public static IEnumerable<(T1 First, T2 Second)>
+            Cartesian<T1, T2>(
+                this IEnumerable<T1> first,
+                IEnumerable<T2> second)
+        {
+            return Cartesian(first, second, ValueTuple.Create);
+        }
+
         /// <summary>
         /// Returns the Cartesian product of three sequences by enumerating all
         /// possible combinations of one item from each sequence, and applying
@@ -139,6 +166,36 @@ public static IEnumerable<TResult> Cartesian<T1, T2, T3, TResult>(
             }
         }
 
+        /// <summary>
+        /// Returns the Cartesian product of three sequences by enumerating tuples
+        /// of all possible combinations of one item from each sequence.
+        /// </summary>
+        /// <typeparam name="T1">The type of the elements of <paramref name="first"/>.</typeparam>
+        /// <typeparam name="T2">The type of the elements of <paramref name="second"/>.</typeparam>
+        /// <typeparam name="T3">The type of the elements of <paramref name="third"/>.</typeparam>
+        /// <param name="first">The first sequence of elements.</param>
+        /// <param name="second">The second sequence of elements.</param>
+        /// <param name="third">The third sequence of elements.</param>
+        /// <returns>A sequence of tuples.</returns>
+        /// <remarks>
+        /// <para>
+        /// The method returns items in the same order as a nested foreach
+        /// loop, but all sequences except for <paramref name="first"/> are
+        /// cached when iterated over. The cache is then re-used for any
+        /// subsequent iterations.</para>
+        /// <para>
+        /// This method uses deferred execution and stream its results.</para>
+        /// </remarks>
+
+        public static IEnumerable<(T1 First, T2 Second, T3 Third)>
+            Cartesian<T1, T2, T3>(
+                this IEnumerable<T1> first,
+                IEnumerable<T2> second,
+                IEnumerable<T3> third)
+        {
+            return Cartesian(first, second, third, ValueTuple.Create);
+        }
+
         /// <summary>
         /// Returns the Cartesian product of four sequences by enumerating all
         /// possible combinations of one item from each sequence, and applying
@@ -204,6 +261,39 @@ public static IEnumerable<TResult> Cartesian<T1, T2, T3, T4, TResult>(
             }
         }
 
+        /// <summary>
+        /// Returns the Cartesian product of four sequences by enumerating tuples
+        /// of all possible combinations of one item from each sequence.
+        /// </summary>
+        /// <typeparam name="T1">The type of the elements of <paramref name="first"/>.</typeparam>
+        /// <typeparam name="T2">The type of the elements of <paramref name="second"/>.</typeparam>
+        /// <typeparam name="T3">The type of the elements of <paramref name="third"/>.</typeparam>
+        /// <typeparam name="T4">The type of the elements of <paramref name="fourth"/>.</typeparam>
+        /// <param name="first">The first sequence of elements.</param>
+        /// <param name="second">The second sequence of elements.</param>
+        /// <param name="third">The third sequence of elements.</param>
+        /// <param name="fourth">The fourth sequence of elements.</param>
+        /// <returns>A sequence of tuples.</returns>
+        /// <remarks>
+        /// <para>
+        /// The method returns items in the same order as a nested foreach
+        /// loop, but all sequences except for <paramref name="first"/> are
+        /// cached when iterated over. The cache is then re-used for any
+        /// subsequent iterations.</para>
+        /// <para>
+        /// This method uses deferred execution and stream its results.</para>
+        /// </remarks>
+
+        public static IEnumerable<(T1 First, T2 Second, T3 Third, T4 Fourth)>
+            Cartesian<T1, T2, T3, T4>(
+                this IEnumerable<T1> first,
+                IEnumerable<T2> second,
+                IEnumerable<T3> third,
+                IEnumerable<T4> fourth)
+        {
+            return Cartesian(first, second, third, fourth, ValueTuple.Create);
+        }
+
         /// <summary>
         /// Returns the Cartesian product of five sequences by enumerating all
         /// possible combinations of one item from each sequence, and applying
@@ -277,6 +367,42 @@ public static IEnumerable<TResult> Cartesian<T1, T2, T3, T4, T5, TResult>(
             }
         }
 
+        /// <summary>
+        /// Returns the Cartesian product of five sequences by enumerating tuples
+        /// of all possible combinations of one item from each sequence.
+        /// </summary>
+        /// <typeparam name="T1">The type of the elements of <paramref name="first"/>.</typeparam>
+        /// <typeparam name="T2">The type of the elements of <paramref name="second"/>.</typeparam>
+        /// <typeparam name="T3">The type of the elements of <paramref name="third"/>.</typeparam>
+        /// <typeparam name="T4">The type of the elements of <paramref name="fourth"/>.</typeparam>
+        /// <typeparam name="T5">The type of the elements of <paramref name="fifth"/>.</typeparam>
+        /// <param name="first">The first sequence of elements.</param>
+        /// <param name="second">The second sequence of elements.</param>
+        /// <param name="third">The third sequence of elements.</param>
+        /// <param name="fourth">The fourth sequence of elements.</param>
+        /// <param name="fifth">The fifth sequence of elements.</param>
+        /// <returns>A sequence of tuples.</returns>
+        /// <remarks>
+        /// <para>
+        /// The method returns items in the same order as a nested foreach
+        /// loop, but all sequences except for <paramref name="first"/> are
+        /// cached when iterated over. The cache is then re-used for any
+        /// subsequent iterations.</para>
+        /// <para>
+        /// This method uses deferred execution and stream its results.</para>
+        /// </remarks>
+
+        public static IEnumerable<(T1 First, T2 Second, T3 Third, T4 Fourth, T5 Fifth)>
+            Cartesian<T1, T2, T3, T4, T5>(
+                this IEnumerable<T1> first,
+                IEnumerable<T2> second,
+                IEnumerable<T3> third,
+                IEnumerable<T4> fourth,
+                IEnumerable<T5> fifth)
+        {
+            return Cartesian(first, second, third, fourth, fifth, ValueTuple.Create);
+        }
+
         /// <summary>
         /// Returns the Cartesian product of six sequences by enumerating all
         /// possible combinations of one item from each sequence, and applying
@@ -358,6 +484,45 @@ public static IEnumerable<TResult> Cartesian<T1, T2, T3, T4, T5, T6, TResult>(
             }
         }
 
+        /// <summary>
+        /// Returns the Cartesian product of six sequences by enumerating tuples
+        /// of all possible combinations of one item from each sequence.
+        /// </summary>
+        /// <typeparam name="T1">The type of the elements of <paramref name="first"/>.</typeparam>
+        /// <typeparam name="T2">The type of the elements of <paramref name="second"/>.</typeparam>
+        /// <typeparam name="T3">The type of the elements of <paramref name="third"/>.</typeparam>
+        /// <typeparam name="T4">The type of the elements of <paramref name="fourth"/>.</typeparam>
+        /// <typeparam name="T5">The type of the elements of <paramref name="fifth"/>.</typeparam>
+        /// <typeparam name="T6">The type of the elements of <paramref name="sixth"/>.</typeparam>
+        /// <param name="first">The first sequence of elements.</param>
+        /// <param name="second">The second sequence of elements.</param>
+        /// <param name="third">The third sequence of elements.</param>
+        /// <param name="fourth">The fourth sequence of elements.</param>
+        /// <param name="fifth">The fifth sequence of elements.</param>
+        /// <param name="sixth">The sixth sequence of elements.</param>
+        /// <returns>A sequence of tuples.</returns>
+        /// <remarks>
+        /// <para>
+        /// The method returns items in the same order as a nested foreach
+        /// loop, but all sequences except for <paramref name="first"/> are
+        /// cached when iterated over. The cache is then re-used for any
+        /// subsequent iterations.</para>
+        /// <para>
+        /// This method uses deferred execution and stream its results.</para>
+        /// </remarks>
+
+        public static IEnumerable<(T1 First, T2 Second, T3 Third, T4 Fourth, T5 Fifth, T6 Sixth)>
+            Cartesian<T1, T2, T3, T4, T5, T6>(
+                this IEnumerable<T1> first,
+                IEnumerable<T2> second,
+                IEnumerable<T3> third,
+                IEnumerable<T4> fourth,
+                IEnumerable<T5> fifth,
+                IEnumerable<T6> sixth)
+        {
+            return Cartesian(first, second, third, fourth, fifth, sixth, ValueTuple.Create);
+        }
+
         /// <summary>
         /// Returns the Cartesian product of seven sequences by enumerating all
         /// possible combinations of one item from each sequence, and applying
@@ -447,6 +612,48 @@ public static IEnumerable<TResult> Cartesian<T1, T2, T3, T4, T5, T6, T7, TResult
             }
         }
 
+        /// <summary>
+        /// Returns the Cartesian product of seven sequences by enumerating tuples
+        /// of all possible combinations of one item from each sequence.
+        /// </summary>
+        /// <typeparam name="T1">The type of the elements of <paramref name="first"/>.</typeparam>
+        /// <typeparam name="T2">The type of the elements of <paramref name="second"/>.</typeparam>
+        /// <typeparam name="T3">The type of the elements of <paramref name="third"/>.</typeparam>
+        /// <typeparam name="T4">The type of the elements of <paramref name="fourth"/>.</typeparam>
+        /// <typeparam name="T5">The type of the elements of <paramref name="fifth"/>.</typeparam>
+        /// <typeparam name="T6">The type of the elements of <paramref name="sixth"/>.</typeparam>
+        /// <typeparam name="T7">The type of the elements of <paramref name="seventh"/>.</typeparam>
+        /// <param name="first">The first sequence of elements.</param>
+        /// <param name="second">The second sequence of elements.</param>
+        /// <param name="third">The third sequence of elements.</param>
+        /// <param name="fourth">The fourth sequence of elements.</param>
+        /// <param name="fifth">The fifth sequence of elements.</param>
+        /// <param name="sixth">The sixth sequence of elements.</param>
+        /// <param name="seventh">The seventh sequence of elements.</param>
+        /// <returns>A sequence of tuples.</returns>
+        /// <remarks>
+        /// <para>
+        /// The method returns items in the same order as a nested foreach
+        /// loop, but all sequences except for <paramref name="first"/> are
+        /// cached when iterated over. The cache is then re-used for any
+        /// subsequent iterations.</para>
+        /// <para>
+        /// This method uses deferred execution and stream its results.</para>
+        /// </remarks>
+
+        public static IEnumerable<(T1 First, T2 Second, T3 Third, T4 Fourth, T5 Fifth, T6 Sixth, T7 Seventh)>
+            Cartesian<T1, T2, T3, T4, T5, T6, T7>(
+                this IEnumerable<T1> first,
+                IEnumerable<T2> second,
+                IEnumerable<T3> third,
+                IEnumerable<T4> fourth,
+                IEnumerable<T5> fifth,
+                IEnumerable<T6> sixth,
+                IEnumerable<T7> seventh)
+        {
+            return Cartesian(first, second, third, fourth, fifth, sixth, seventh, ValueTuple.Create);
+        }
+
         /// <summary>
         /// Returns the Cartesian product of eight sequences by enumerating all
         /// possible combinations of one item from each sequence, and applying
@@ -543,5 +750,50 @@ public static IEnumerable<TResult> Cartesian<T1, T2, T3, T4, T5, T6, T7, T8, TRe
                 }
             }
         }
+
+        /// <summary>
+        /// Returns the Cartesian product of eight sequences by enumerating tuples
+        /// of all possible combinations of one item from each sequence.
+        /// </summary>
+        /// <typeparam name="T1">The type of the elements of <paramref name="first"/>.</typeparam>
+        /// <typeparam name="T2">The type of the elements of <paramref name="second"/>.</typeparam>
+        /// <typeparam name="T3">The type of the elements of <paramref name="third"/>.</typeparam>
+        /// <typeparam name="T4">The type of the elements of <paramref name="fourth"/>.</typeparam>
+        /// <typeparam name="T5">The type of the elements of <paramref name="fifth"/>.</typeparam>
+        /// <typeparam name="T6">The type of the elements of <paramref name="sixth"/>.</typeparam>
+        /// <typeparam name="T7">The type of the elements of <paramref name="seventh"/>.</typeparam>
+        /// <typeparam name="T8">The type of the elements of <paramref name="eighth"/>.</typeparam>
+        /// <param name="first">The first sequence of elements.</param>
+        /// <param name="second">The second sequence of elements.</param>
+        /// <param name="third">The third sequence of elements.</param>
+        /// <param name="fourth">The fourth sequence of elements.</param>
+        /// <param name="fifth">The fifth sequence of elements.</param>
+        /// <param name="sixth">The sixth sequence of elements.</param>
+        /// <param name="seventh">The seventh sequence of elements.</param>
+        /// <param name="eighth">The eighth sequence of elements.</param>
+        /// <returns>A sequence of tuples.</returns>
+        /// <remarks>
+        /// <para>
+        /// The method returns items in the same order as a nested foreach
+        /// loop, but all sequences except for <paramref name="first"/> are
+        /// cached when iterated over. The cache is then re-used for any
+        /// subsequent iterations.</para>
+        /// <para>
+        /// This method uses deferred execution and stream its results.</para>
+        /// </remarks>
+
+        public static IEnumerable<(T1 First, T2 Second, T3 Third, T4 Fourth, T5 Fifth, T6 Sixth, T7 Seventh, T8 Eighth)>
+            Cartesian<T1, T2, T3, T4, T5, T6, T7, T8>(
+                this IEnumerable<T1> first,
+                IEnumerable<T2> second,
+                IEnumerable<T3> third,
+                IEnumerable<T4> fourth,
+                IEnumerable<T5> fifth,
+                IEnumerable<T6> sixth,
+                IEnumerable<T7> seventh,
+                IEnumerable<T8> eighth)
+        {
+            return Cartesian(first, second, third, fourth, fifth, sixth, seventh, eighth, ValueTuple.Create);
+        }
     }
 }
diff --git a/MoreLinq/Cartesian.g.tt b/MoreLinq/Cartesian.g.tt
index 4bc112cea..b6ebf8510 100644
--- a/MoreLinq/Cartesian.g.tt
+++ b/MoreLinq/Cartesian.g.tt
@@ -43,19 +43,20 @@ namespace MoreLinq
         {
             new[]
             {
-                new { Ordinal = "first"  , Arity = "one"   },
-                new { Ordinal = "second" , Arity = "two"   },
-                new { Ordinal = "third"  , Arity = "three" },
-                new { Ordinal = "fourth" , Arity = "four"  },
-                new { Ordinal = "fifth"  , Arity = "five"  },
-                new { Ordinal = "sixth"  , Arity = "six"   },
-                new { Ordinal = "seventh", Arity = "seven" },
-                new { Ordinal = "eighth" , Arity = "eight" },
+                new { Ordinal = "First"  , Arity = "one"   },
+                new { Ordinal = "Second" , Arity = "two"   },
+                new { Ordinal = "Third"  , Arity = "three" },
+                new { Ordinal = "Fourth" , Arity = "four"  },
+                new { Ordinal = "Fifth"  , Arity = "five"  },
+                new { Ordinal = "Sixth"  , Arity = "six"   },
+                new { Ordinal = "Seventh", Arity = "seven" },
+                new { Ordinal = "Eighth" , Arity = "eight" },
             }
         }
         select args.Select((a, i) => new
         {
             a.Ordinal,
+            OrdinalLower = a.Ordinal.ToLowerInvariant(),
             a.Arity,
             Count  = i + 1,
             Number = (i + 1).ToString(CultureInfo.InvariantCulture),
@@ -66,9 +67,8 @@ namespace MoreLinq
         select new
         {
             a.Arity,
-            Arguments = args.Take(a.Count)
-                            .Select(aa => new { aa.Number, aa.Ordinal })
-                            .ToList(),
+            Arguments = args.Take(a.Count).ToList(),
+            TypeParams = string.Join(", ", from aa in args.Take(a.Count) select $"T{aa.Number}")
         };
 
     foreach (var o in overloads)
@@ -81,12 +81,12 @@ namespace MoreLinq
         /// </summary>
 <#      foreach (var arg in o.Arguments) { #>
         /// <typeparam name="T<#= arg.Number #>">
-        /// The type of the elements of <paramref name="<#= arg.Ordinal #>"/>.</typeparam>
+        /// The type of the elements of <paramref name="<#= arg.OrdinalLower #>"/>.</typeparam>
 <#      } #>
         /// <typeparam name="TResult">
         /// The type of the elements of the result sequence.</typeparam>
 <#      foreach (var arg in o.Arguments) {#>
-        /// <param name="<#= arg.Ordinal #>">The <#= arg.Ordinal #> sequence of elements.</param>
+        /// <param name="<#= arg.OrdinalLower #>">The <#= arg.OrdinalLower #> sequence of elements.</param>
 <#      } #>
         /// <param name="resultSelector">A projection function that combines
         /// elements from all of the sequences.</param>
@@ -102,37 +102,67 @@ namespace MoreLinq
         /// This method uses deferred execution and stream its results.</para>
         /// </remarks>
 
-        public static IEnumerable<TResult> Cartesian<<#= string.Join(", ", from x in o.Arguments select "T" + x.Number) #>, TResult>(
+        public static IEnumerable<TResult> Cartesian<<#= o.TypeParams #>, TResult>(
             this <#
         foreach (var arg in o.Arguments) { #>
-IEnumerable<T<#= arg.Number #>> <#= arg.Ordinal #>,
+IEnumerable<T<#= arg.Number #>> <#= arg.OrdinalLower #>,
             <#
         } #>
-Func<<#= string.Join(", ", from x in o.Arguments select "T" + x.Number) #>, TResult> resultSelector)
+Func<<#= o.TypeParams #>, TResult> resultSelector)
         {
 <#      foreach (var arg in o.Arguments) { #>
-            if (<#= arg.Ordinal #> == null) throw new ArgumentNullException(nameof(<#= arg.Ordinal #>));
+            if (<#= arg.OrdinalLower #> == null) throw new ArgumentNullException(nameof(<#= arg.OrdinalLower #>));
 <#      } #>
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
             return _(); IEnumerable<TResult> _()
             {
 <#      foreach (var arg in o.Arguments.Skip(1)) { #>
-                IEnumerable<T<#= arg.Number #>> <#= arg.Ordinal #>Memo;
+                IEnumerable<T<#= arg.Number #>> <#= arg.OrdinalLower #>Memo;
 <#      } #>
 
 <#      foreach (var arg in o.Arguments.Skip(1)) { #>
-                using ((<#= arg.Ordinal #>Memo = <#= arg.Ordinal #>.Memoize()) as IDisposable)
+                using ((<#= arg.OrdinalLower #>Memo = <#= arg.OrdinalLower #>.Memoize()) as IDisposable)
 <#      } #>
                 {
                     foreach (var item1 in first)
 <#      foreach (var arg in o.Arguments.Skip(1)) { #>
-                    foreach (var item<#= arg.Number #> in <#= arg.Ordinal #>Memo)
+                    foreach (var item<#= arg.Number #> in <#= arg.OrdinalLower #>Memo)
 <#      } #>
                         yield return resultSelector(<#= string.Join(", ", from x in o.Arguments select "item" + x.Number) #>);
                 }
             }
         }
+
+        /// <summary>
+        /// Returns the Cartesian product of <#= o.Arity #> sequences by enumerating tuples
+        /// of all possible combinations of one item from each sequence.
+        /// </summary>
+<#      foreach (var arg in o.Arguments) { #>
+        /// <typeparam name="T<#= arg.Number #>">The type of the elements of <paramref name="<#= arg.OrdinalLower #>"/>.</typeparam>
+<#      } #>
+<#      foreach (var arg in o.Arguments) {#>
+        /// <param name="<#= arg.OrdinalLower #>">The <#= arg.OrdinalLower #> sequence of elements.</param>
+<#      } #>
+        /// <returns>A sequence of tuples.</returns>
+        /// <remarks>
+        /// <para>
+        /// The method returns items in the same order as a nested foreach
+        /// loop, but all sequences except for <paramref name="first"/> are
+        /// cached when iterated over. The cache is then re-used for any
+        /// subsequent iterations.</para>
+        /// <para>
+        /// This method uses deferred execution and stream its results.</para>
+        /// </remarks>
+
+        public static IEnumerable<(<#= string.Join(", ", from a in o.Arguments select $"T{a.Number} {a.Ordinal}") #>)>
+            Cartesian<<#= o.TypeParams #>>(
+                this <#= string.Join($",{Environment.NewLine}                ",
+                                     from arg in o.Arguments
+                                     select $"IEnumerable<T{arg.Number}> {arg.OrdinalLower}") #>)
+        {
+            return Cartesian(<#= string.Join(", ", from a in o.Arguments select a.OrdinalLower) #>, ValueTuple.Create);
+        }
 <#  } #>
     }
 }
diff --git a/MoreLinq/CountDown.cs b/MoreLinq/CountDown.cs
index 53310e79a..1e0ca6d4f 100644
--- a/MoreLinq/CountDown.cs
+++ b/MoreLinq/CountDown.cs
@@ -94,5 +94,31 @@ IEnumerable<TResult> IterateSequence()
                     yield return resultSelector(queue.Dequeue(), queue.Count);
             }
         }
+
+        /// <summary>
+        /// Provides a countdown counter for a given count of elements at the
+        /// tail of the sequence where zero always represents the last element,
+        /// one represents the second-last element, two represents the
+        /// third-last element and so on.
+        /// </summary>
+        /// <typeparam name="T">
+        /// The type of elements of <paramref name="source"/></typeparam>
+        /// <param name="source">The source sequence.</param>
+        /// <param name="count">Count of tail elements of <paramref name="source"/> to count down.</param>
+        /// <returns>
+        /// A sequence of tuple with an element from <paramref name="source"/> and its countdown.
+        /// For elements before the last <paramref name="count"/>, the countdown value is <c>null</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method uses deferred execution semantics and streams its
+        /// results. At most, <paramref name="count"/> elements of the source
+        /// sequence may be buffered at any one time unless
+        /// <paramref name="source"/> is a collection or a list.
+        /// </remarks>
+
+        public static IEnumerable<(T Item, int? CountDown)> CountDown<T>(this IEnumerable<T> source, int count)
+        {
+            return source.CountDown(count, ValueTuple.Create);
+        }
     }
 }
diff --git a/MoreLinq/EquiZip.cs b/MoreLinq/EquiZip.cs
index 61212f122..5c09d8079 100644
--- a/MoreLinq/EquiZip.cs
+++ b/MoreLinq/EquiZip.cs
@@ -181,6 +181,118 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, TResult>(
             return EquiZipImpl(first, second, third, fourth, resultSelector);
         }
 
+        /// <summary>
+        /// Returns tuples, where each tuple contains the N-th
+        /// element from each of the argument sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first sequence</typeparam>
+        /// <typeparam name="T2">Type of elements in second sequence</typeparam>
+        /// <param name="first">The first sequence.</param>
+        /// <param name="second">The second sequence.</param>
+        /// <returns>
+        /// A sequence of tuples that contains elements of the two input sequences.
+        /// </returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <example>
+        /// <code><![CDATA[
+        /// var numbers = new[] { 1, 2, 3, 4 };
+        /// var letters = new[] { "A", "B", "C", "D" };
+        /// var zipped = numbers.EquiZip(letters);
+        /// ]]></code>
+        /// The <c>zipped</c> variable, when iterated over, will yield the tuples : (1, A),
+        /// (2, B), (3, C), (4, D) in turn.
+        /// </example>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+
+        public static IEnumerable<(T1, T2)> EquiZip<T1, T2>(this IEnumerable<T1> first, IEnumerable<T2> second)
+        {
+            return first.EquiZip(second, ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns tuples, where each tuple contains the N-th
+        /// element from each of the argument sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first sequence</typeparam>
+        /// <typeparam name="T2">Type of elements in second sequence</typeparam>
+        /// <typeparam name="T3">Type of elements in third sequence</typeparam>
+        /// <param name="first">The first sequence.</param>
+        /// <param name="second">The second sequence.</param>
+        /// <param name="third">The third sequence.</param>
+        /// <returns>
+        /// A sequence of tuples that contains elements of the three input sequences.
+        /// </returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <example>
+        /// <code><![CDATA[
+        /// var numbers = new[] { 1, 2, 3, 4 };
+        /// var letters = new[] { "A", "B", "C", "D" };
+        /// var chars   = new[] { 'a', 'b', 'c', 'd' };
+        /// var zipped = numbers.EquiZip(letters, chars);
+        /// ]]></code>
+        /// The <c>zipped</c> variable, when iterated over, will yield the tuples : (1, A, a),
+        /// (2, B, b), (3, C, c), (4, D, d) in turn.
+        /// </example>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+
+        public static IEnumerable<(T1, T2, T3)> EquiZip<T1, T2, T3>(
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second, IEnumerable<T3> third)
+        {
+            return first.EquiZip(second, third, ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns tuples, where each tuple contains the N-th
+        /// element from each of the argument sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first sequence</typeparam>
+        /// <typeparam name="T2">Type of elements in second sequence</typeparam>
+        /// <typeparam name="T3">Type of elements in third sequence</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth sequence</typeparam>
+        /// <param name="first">The first sequence.</param>
+        /// <param name="second">The second sequence.</param>
+        /// <param name="third">The third sequence.</param>
+        /// <param name="fourth">The fourth sequence.</param>
+        /// <returns>
+        /// A sequence of tuples that contains elements of the four input sequences.
+        /// </returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <example>
+        /// <code><![CDATA[
+        /// var numbers = new[] { 1, 2, 3, 4 };
+        /// var letters = new[] { "A", "B", "C", "D" };
+        /// var chars   = new[] { 'a', 'b', 'c', 'd' };
+        /// var flags   = new[] { true, false, true, false };
+        /// var zipped = numbers.EquiZip(letters, chars, flags);
+        /// ]]></code>
+        /// The <c>zipped</c> variable, when iterated over, will yield the tuples : (1, A, a, True),
+        /// (2, B, b, False), (3, C, c, True), (4, D, d, False) in turn.
+        /// </example>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+
+        public static IEnumerable<(T1, T2, T3, T4)> EquiZip<T1, T2, T3, T4>(
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second, IEnumerable<T3> third, IEnumerable<T4> fourth)
+        {
+            return first.EquiZip(second, third, fourth, ValueTuple.Create);
+        }
+
         static IEnumerable<TResult> EquiZipImpl<T1, T2, T3, T4, TResult>(
             IEnumerable<T1>  s1,
             IEnumerable<T2>  s2,
diff --git a/MoreLinq/Extensions.g.cs b/MoreLinq/Extensions.g.cs
index b7fcf096d..cf7d7b47e 100644
--- a/MoreLinq/Extensions.g.cs
+++ b/MoreLinq/Extensions.g.cs
@@ -721,6 +721,59 @@ public static IEnumerable<TResult> Batch<TSource, TResult>(this IEnumerable<TSou
     [GeneratedCode("MoreLinq.ExtensionsGenerator", "1.0.0.0")]
     public static partial class CartesianExtension
     {
+
+        /// <summary>
+        /// Returns the Cartesian product of two sequences by enumerating tuples
+        /// of all possible combinations of one item from each sequence.
+        /// </summary>
+        /// <typeparam name="T1">The type of the elements of <paramref name="first"/>.</typeparam>
+        /// <typeparam name="T2">The type of the elements of <paramref name="second"/>.</typeparam>
+        /// <param name="first">The first sequence of elements.</param>
+        /// <param name="second">The second sequence of elements.</param>
+        /// <returns>A sequence of tuples.</returns>
+        /// <remarks>
+        /// <para>
+        /// The method returns items in the same order as a nested foreach
+        /// loop, but all sequences except for <paramref name="first"/> are
+        /// cached when iterated over. The cache is then re-used for any
+        /// subsequent iterations.</para>
+        /// <para>
+        /// This method uses deferred execution and stream its results.</para>
+        /// </remarks>
+
+        public static IEnumerable<(T1 First, T2 Second)>
+            Cartesian<T1, T2>(
+                this IEnumerable<T1> first,
+                IEnumerable<T2> second)
+            => MoreEnumerable.            Cartesian(first, second);
+
+        /// <summary>
+        /// Returns the Cartesian product of three sequences by enumerating tuples
+        /// of all possible combinations of one item from each sequence.
+        /// </summary>
+        /// <typeparam name="T1">The type of the elements of <paramref name="first"/>.</typeparam>
+        /// <typeparam name="T2">The type of the elements of <paramref name="second"/>.</typeparam>
+        /// <typeparam name="T3">The type of the elements of <paramref name="third"/>.</typeparam>
+        /// <param name="first">The first sequence of elements.</param>
+        /// <param name="second">The second sequence of elements.</param>
+        /// <param name="third">The third sequence of elements.</param>
+        /// <returns>A sequence of tuples.</returns>
+        /// <remarks>
+        /// <para>
+        /// The method returns items in the same order as a nested foreach
+        /// loop, but all sequences except for <paramref name="first"/> are
+        /// cached when iterated over. The cache is then re-used for any
+        /// subsequent iterations.</para>
+        /// <para>
+        /// This method uses deferred execution and stream its results.</para>
+        /// </remarks>
+
+        public static IEnumerable<(T1 First, T2 Second, T3 Third)>
+            Cartesian<T1, T2, T3>(
+                this IEnumerable<T1> first,
+                IEnumerable<T2> second,
+                IEnumerable<T3> third)
+            => MoreEnumerable.            Cartesian(first, second, third);
         /// <summary>
         /// Returns the Cartesian product of two sequences by enumerating all
         /// possible combinations of one item from each sequence, and applying
@@ -754,6 +807,37 @@ public static IEnumerable<TResult> Cartesian<T1, T2, TResult>(
             Func<T1, T2, TResult> resultSelector)
             => MoreEnumerable.Cartesian(first, second, resultSelector);
 
+        /// <summary>
+        /// Returns the Cartesian product of four sequences by enumerating tuples
+        /// of all possible combinations of one item from each sequence.
+        /// </summary>
+        /// <typeparam name="T1">The type of the elements of <paramref name="first"/>.</typeparam>
+        /// <typeparam name="T2">The type of the elements of <paramref name="second"/>.</typeparam>
+        /// <typeparam name="T3">The type of the elements of <paramref name="third"/>.</typeparam>
+        /// <typeparam name="T4">The type of the elements of <paramref name="fourth"/>.</typeparam>
+        /// <param name="first">The first sequence of elements.</param>
+        /// <param name="second">The second sequence of elements.</param>
+        /// <param name="third">The third sequence of elements.</param>
+        /// <param name="fourth">The fourth sequence of elements.</param>
+        /// <returns>A sequence of tuples.</returns>
+        /// <remarks>
+        /// <para>
+        /// The method returns items in the same order as a nested foreach
+        /// loop, but all sequences except for <paramref name="first"/> are
+        /// cached when iterated over. The cache is then re-used for any
+        /// subsequent iterations.</para>
+        /// <para>
+        /// This method uses deferred execution and stream its results.</para>
+        /// </remarks>
+
+        public static IEnumerable<(T1 First, T2 Second, T3 Third, T4 Fourth)>
+            Cartesian<T1, T2, T3, T4>(
+                this IEnumerable<T1> first,
+                IEnumerable<T2> second,
+                IEnumerable<T3> third,
+                IEnumerable<T4> fourth)
+            => MoreEnumerable.            Cartesian(first, second, third, fourth);
+
         /// <summary>
         /// Returns the Cartesian product of three sequences by enumerating all
         /// possible combinations of one item from each sequence, and applying
@@ -791,6 +875,40 @@ public static IEnumerable<TResult> Cartesian<T1, T2, T3, TResult>(
             Func<T1, T2, T3, TResult> resultSelector)
             => MoreEnumerable.Cartesian(first, second, third, resultSelector);
 
+        /// <summary>
+        /// Returns the Cartesian product of five sequences by enumerating tuples
+        /// of all possible combinations of one item from each sequence.
+        /// </summary>
+        /// <typeparam name="T1">The type of the elements of <paramref name="first"/>.</typeparam>
+        /// <typeparam name="T2">The type of the elements of <paramref name="second"/>.</typeparam>
+        /// <typeparam name="T3">The type of the elements of <paramref name="third"/>.</typeparam>
+        /// <typeparam name="T4">The type of the elements of <paramref name="fourth"/>.</typeparam>
+        /// <typeparam name="T5">The type of the elements of <paramref name="fifth"/>.</typeparam>
+        /// <param name="first">The first sequence of elements.</param>
+        /// <param name="second">The second sequence of elements.</param>
+        /// <param name="third">The third sequence of elements.</param>
+        /// <param name="fourth">The fourth sequence of elements.</param>
+        /// <param name="fifth">The fifth sequence of elements.</param>
+        /// <returns>A sequence of tuples.</returns>
+        /// <remarks>
+        /// <para>
+        /// The method returns items in the same order as a nested foreach
+        /// loop, but all sequences except for <paramref name="first"/> are
+        /// cached when iterated over. The cache is then re-used for any
+        /// subsequent iterations.</para>
+        /// <para>
+        /// This method uses deferred execution and stream its results.</para>
+        /// </remarks>
+
+        public static IEnumerable<(T1 First, T2 Second, T3 Third, T4 Fourth, T5 Fifth)>
+            Cartesian<T1, T2, T3, T4, T5>(
+                this IEnumerable<T1> first,
+                IEnumerable<T2> second,
+                IEnumerable<T3> third,
+                IEnumerable<T4> fourth,
+                IEnumerable<T5> fifth)
+            => MoreEnumerable.            Cartesian(first, second, third, fourth, fifth);
+
         /// <summary>
         /// Returns the Cartesian product of four sequences by enumerating all
         /// possible combinations of one item from each sequence, and applying
@@ -832,6 +950,43 @@ public static IEnumerable<TResult> Cartesian<T1, T2, T3, T4, TResult>(
             Func<T1, T2, T3, T4, TResult> resultSelector)
             => MoreEnumerable.Cartesian(first, second, third, fourth, resultSelector);
 
+        /// <summary>
+        /// Returns the Cartesian product of six sequences by enumerating tuples
+        /// of all possible combinations of one item from each sequence.
+        /// </summary>
+        /// <typeparam name="T1">The type of the elements of <paramref name="first"/>.</typeparam>
+        /// <typeparam name="T2">The type of the elements of <paramref name="second"/>.</typeparam>
+        /// <typeparam name="T3">The type of the elements of <paramref name="third"/>.</typeparam>
+        /// <typeparam name="T4">The type of the elements of <paramref name="fourth"/>.</typeparam>
+        /// <typeparam name="T5">The type of the elements of <paramref name="fifth"/>.</typeparam>
+        /// <typeparam name="T6">The type of the elements of <paramref name="sixth"/>.</typeparam>
+        /// <param name="first">The first sequence of elements.</param>
+        /// <param name="second">The second sequence of elements.</param>
+        /// <param name="third">The third sequence of elements.</param>
+        /// <param name="fourth">The fourth sequence of elements.</param>
+        /// <param name="fifth">The fifth sequence of elements.</param>
+        /// <param name="sixth">The sixth sequence of elements.</param>
+        /// <returns>A sequence of tuples.</returns>
+        /// <remarks>
+        /// <para>
+        /// The method returns items in the same order as a nested foreach
+        /// loop, but all sequences except for <paramref name="first"/> are
+        /// cached when iterated over. The cache is then re-used for any
+        /// subsequent iterations.</para>
+        /// <para>
+        /// This method uses deferred execution and stream its results.</para>
+        /// </remarks>
+
+        public static IEnumerable<(T1 First, T2 Second, T3 Third, T4 Fourth, T5 Fifth, T6 Sixth)>
+            Cartesian<T1, T2, T3, T4, T5, T6>(
+                this IEnumerable<T1> first,
+                IEnumerable<T2> second,
+                IEnumerable<T3> third,
+                IEnumerable<T4> fourth,
+                IEnumerable<T5> fifth,
+                IEnumerable<T6> sixth)
+            => MoreEnumerable.            Cartesian(first, second, third, fourth, fifth, sixth);
+
         /// <summary>
         /// Returns the Cartesian product of five sequences by enumerating all
         /// possible combinations of one item from each sequence, and applying
@@ -877,6 +1032,46 @@ public static IEnumerable<TResult> Cartesian<T1, T2, T3, T4, T5, TResult>(
             Func<T1, T2, T3, T4, T5, TResult> resultSelector)
             => MoreEnumerable.Cartesian(first, second, third, fourth, fifth, resultSelector);
 
+        /// <summary>
+        /// Returns the Cartesian product of seven sequences by enumerating tuples
+        /// of all possible combinations of one item from each sequence.
+        /// </summary>
+        /// <typeparam name="T1">The type of the elements of <paramref name="first"/>.</typeparam>
+        /// <typeparam name="T2">The type of the elements of <paramref name="second"/>.</typeparam>
+        /// <typeparam name="T3">The type of the elements of <paramref name="third"/>.</typeparam>
+        /// <typeparam name="T4">The type of the elements of <paramref name="fourth"/>.</typeparam>
+        /// <typeparam name="T5">The type of the elements of <paramref name="fifth"/>.</typeparam>
+        /// <typeparam name="T6">The type of the elements of <paramref name="sixth"/>.</typeparam>
+        /// <typeparam name="T7">The type of the elements of <paramref name="seventh"/>.</typeparam>
+        /// <param name="first">The first sequence of elements.</param>
+        /// <param name="second">The second sequence of elements.</param>
+        /// <param name="third">The third sequence of elements.</param>
+        /// <param name="fourth">The fourth sequence of elements.</param>
+        /// <param name="fifth">The fifth sequence of elements.</param>
+        /// <param name="sixth">The sixth sequence of elements.</param>
+        /// <param name="seventh">The seventh sequence of elements.</param>
+        /// <returns>A sequence of tuples.</returns>
+        /// <remarks>
+        /// <para>
+        /// The method returns items in the same order as a nested foreach
+        /// loop, but all sequences except for <paramref name="first"/> are
+        /// cached when iterated over. The cache is then re-used for any
+        /// subsequent iterations.</para>
+        /// <para>
+        /// This method uses deferred execution and stream its results.</para>
+        /// </remarks>
+
+        public static IEnumerable<(T1 First, T2 Second, T3 Third, T4 Fourth, T5 Fifth, T6 Sixth, T7 Seventh)>
+            Cartesian<T1, T2, T3, T4, T5, T6, T7>(
+                this IEnumerable<T1> first,
+                IEnumerable<T2> second,
+                IEnumerable<T3> third,
+                IEnumerable<T4> fourth,
+                IEnumerable<T5> fifth,
+                IEnumerable<T6> sixth,
+                IEnumerable<T7> seventh)
+            => MoreEnumerable.            Cartesian(first, second, third, fourth, fifth, sixth, seventh);
+
         /// <summary>
         /// Returns the Cartesian product of six sequences by enumerating all
         /// possible combinations of one item from each sequence, and applying
@@ -926,6 +1121,49 @@ public static IEnumerable<TResult> Cartesian<T1, T2, T3, T4, T5, T6, TResult>(
             Func<T1, T2, T3, T4, T5, T6, TResult> resultSelector)
             => MoreEnumerable.Cartesian(first, second, third, fourth, fifth, sixth, resultSelector);
 
+        /// <summary>
+        /// Returns the Cartesian product of eight sequences by enumerating tuples
+        /// of all possible combinations of one item from each sequence.
+        /// </summary>
+        /// <typeparam name="T1">The type of the elements of <paramref name="first"/>.</typeparam>
+        /// <typeparam name="T2">The type of the elements of <paramref name="second"/>.</typeparam>
+        /// <typeparam name="T3">The type of the elements of <paramref name="third"/>.</typeparam>
+        /// <typeparam name="T4">The type of the elements of <paramref name="fourth"/>.</typeparam>
+        /// <typeparam name="T5">The type of the elements of <paramref name="fifth"/>.</typeparam>
+        /// <typeparam name="T6">The type of the elements of <paramref name="sixth"/>.</typeparam>
+        /// <typeparam name="T7">The type of the elements of <paramref name="seventh"/>.</typeparam>
+        /// <typeparam name="T8">The type of the elements of <paramref name="eighth"/>.</typeparam>
+        /// <param name="first">The first sequence of elements.</param>
+        /// <param name="second">The second sequence of elements.</param>
+        /// <param name="third">The third sequence of elements.</param>
+        /// <param name="fourth">The fourth sequence of elements.</param>
+        /// <param name="fifth">The fifth sequence of elements.</param>
+        /// <param name="sixth">The sixth sequence of elements.</param>
+        /// <param name="seventh">The seventh sequence of elements.</param>
+        /// <param name="eighth">The eighth sequence of elements.</param>
+        /// <returns>A sequence of tuples.</returns>
+        /// <remarks>
+        /// <para>
+        /// The method returns items in the same order as a nested foreach
+        /// loop, but all sequences except for <paramref name="first"/> are
+        /// cached when iterated over. The cache is then re-used for any
+        /// subsequent iterations.</para>
+        /// <para>
+        /// This method uses deferred execution and stream its results.</para>
+        /// </remarks>
+
+        public static IEnumerable<(T1 First, T2 Second, T3 Third, T4 Fourth, T5 Fifth, T6 Sixth, T7 Seventh, T8 Eighth)>
+            Cartesian<T1, T2, T3, T4, T5, T6, T7, T8>(
+                this IEnumerable<T1> first,
+                IEnumerable<T2> second,
+                IEnumerable<T3> third,
+                IEnumerable<T4> fourth,
+                IEnumerable<T5> fifth,
+                IEnumerable<T6> sixth,
+                IEnumerable<T7> seventh,
+                IEnumerable<T8> eighth)
+            => MoreEnumerable.            Cartesian(first, second, third, fourth, fifth, sixth, seventh, eighth);
+
         /// <summary>
         /// Returns the Cartesian product of seven sequences by enumerating all
         /// possible combinations of one item from each sequence, and applying
@@ -1199,6 +1437,30 @@ public static IEnumerable<KeyValuePair<TKey, int>> CountBy<TSource, TKey>(this I
     [GeneratedCode("MoreLinq.ExtensionsGenerator", "1.0.0.0")]
     public static partial class CountDownExtension
     {
+
+        /// <summary>
+        /// Provides a countdown counter for a given count of elements at the
+        /// tail of the sequence where zero always represents the last element,
+        /// one represents the second-last element, two represents the
+        /// third-last element and so on.
+        /// </summary>
+        /// <typeparam name="T">
+        /// The type of elements of <paramref name="source"/></typeparam>
+        /// <param name="source">The source sequence.</param>
+        /// <param name="count">Count of tail elements of <paramref name="source"/> to count down.</param>
+        /// <returns>
+        /// A sequence of tuple with an element from <paramref name="source"/> and its countdown.
+        /// For elements before the last <paramref name="count"/>, the countdown value is <c>null</c>.
+        /// </returns>
+        /// <remarks>
+        /// This method uses deferred execution semantics and streams its
+        /// results. At most, <paramref name="count"/> elements of the source
+        /// sequence may be buffered at any one time unless
+        /// <paramref name="source"/> is a collection or a list.
+        /// </remarks>
+
+        public static IEnumerable<(T Item, int? CountDown)> CountDown<T>(this IEnumerable<T> source, int count)
+            => MoreEnumerable.CountDown(source, count);
         /// <summary>
         /// Provides a countdown counter for a given count of elements at the
         /// tail of the sequence where zero always represents the last element,
@@ -1339,6 +1601,73 @@ public static bool EndsWith<T>(this IEnumerable<T> first, IEnumerable<T> second,
     [GeneratedCode("MoreLinq.ExtensionsGenerator", "1.0.0.0")]
     public static partial class EquiZipExtension
     {
+
+        /// <summary>
+        /// Returns tuples, where each tuple contains the N-th
+        /// element from each of the argument sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first sequence</typeparam>
+        /// <typeparam name="T2">Type of elements in second sequence</typeparam>
+        /// <param name="first">The first sequence.</param>
+        /// <param name="second">The second sequence.</param>
+        /// <returns>
+        /// A sequence of tuples that contains elements of the two input sequences.
+        /// </returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <example>
+        /// <code><![CDATA[
+        /// var numbers = new[] { 1, 2, 3, 4 };
+        /// var letters = new[] { "A", "B", "C", "D" };
+        /// var zipped = numbers.EquiZip(letters);
+        /// ]]></code>
+        /// The <c>zipped</c> variable, when iterated over, will yield the tuples : (1, A),
+        /// (2, B), (3, C), (4, D) in turn.
+        /// </example>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+
+        public static IEnumerable<(T1, T2)> EquiZip<T1, T2>(this IEnumerable<T1> first, IEnumerable<T2> second)
+            => MoreEnumerable.EquiZip(first, second);
+
+        /// <summary>
+        /// Returns tuples, where each tuple contains the N-th
+        /// element from each of the argument sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first sequence</typeparam>
+        /// <typeparam name="T2">Type of elements in second sequence</typeparam>
+        /// <typeparam name="T3">Type of elements in third sequence</typeparam>
+        /// <param name="first">The first sequence.</param>
+        /// <param name="second">The second sequence.</param>
+        /// <param name="third">The third sequence.</param>
+        /// <returns>
+        /// A sequence of tuples that contains elements of the three input sequences.
+        /// </returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <example>
+        /// <code><![CDATA[
+        /// var numbers = new[] { 1, 2, 3, 4 };
+        /// var letters = new[] { "A", "B", "C", "D" };
+        /// var chars   = new[] { 'a', 'b', 'c', 'd' };
+        /// var zipped = numbers.EquiZip(letters, chars);
+        /// ]]></code>
+        /// The <c>zipped</c> variable, when iterated over, will yield the tuples : (1, A, a),
+        /// (2, B, b), (3, C, c), (4, D, d) in turn.
+        /// </example>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+
+        public static IEnumerable<(T1, T2, T3)> EquiZip<T1, T2, T3>(
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second, IEnumerable<T3> third)
+            => MoreEnumerable.EquiZip(first, second, third);
         /// <summary>
         /// Returns a projection of tuples, where each tuple contains the N-th
         /// element from each of the argument sequences. An exception is thrown
@@ -1381,6 +1710,45 @@ public static IEnumerable<TResult> EquiZip<TFirst, TSecond, TResult>(
             Func<TFirst, TSecond, TResult> resultSelector)
             => MoreEnumerable.EquiZip(first, second, resultSelector);
 
+        /// <summary>
+        /// Returns tuples, where each tuple contains the N-th
+        /// element from each of the argument sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first sequence</typeparam>
+        /// <typeparam name="T2">Type of elements in second sequence</typeparam>
+        /// <typeparam name="T3">Type of elements in third sequence</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth sequence</typeparam>
+        /// <param name="first">The first sequence.</param>
+        /// <param name="second">The second sequence.</param>
+        /// <param name="third">The third sequence.</param>
+        /// <param name="fourth">The fourth sequence.</param>
+        /// <returns>
+        /// A sequence of tuples that contains elements of the four input sequences.
+        /// </returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <example>
+        /// <code><![CDATA[
+        /// var numbers = new[] { 1, 2, 3, 4 };
+        /// var letters = new[] { "A", "B", "C", "D" };
+        /// var chars   = new[] { 'a', 'b', 'c', 'd' };
+        /// var flags   = new[] { true, false, true, false };
+        /// var zipped = numbers.EquiZip(letters, chars, flags);
+        /// ]]></code>
+        /// The <c>zipped</c> variable, when iterated over, will yield the tuples : (1, A, a, True),
+        /// (2, B, b, False), (3, C, c, True), (4, D, d, False) in turn.
+        /// </example>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+
+        public static IEnumerable<(T1, T2, T3, T4)> EquiZip<T1, T2, T3, T4>(
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second, IEnumerable<T3> third, IEnumerable<T4> fourth)
+            => MoreEnumerable.EquiZip(first, second, third, fourth);
+
         /// <summary>
         /// Returns a projection of tuples, where each tuple contains the N-th
         /// element from each of the argument sequences. An exception is thrown
@@ -3075,6 +3443,37 @@ public static IEnumerable<T> Interleave<T>(this IEnumerable<T> sequence, params
     [GeneratedCode("MoreLinq.ExtensionsGenerator", "1.0.0.0")]
     public static partial class LagExtension
     {
+
+        /// <summary>
+        /// Produces a sequence of tuple containing a pair of elements separated by a negative offset.
+        /// </summary>
+        /// <remarks>
+        /// This operator evaluates in a deferred and streaming manner.<br/>
+        /// For elements prior to the lag offset, <c>default(T)</c> is used as the lagged value.<br/>
+        /// </remarks>
+        /// <typeparam name="TSource">The type of the elements of the source sequence</typeparam>
+        /// <param name="source">The sequence over which to evaluate lag</param>
+        /// <param name="offset">The offset (expressed as a positive number) by which to lag each value of the sequence</param>
+        /// <returns>A sequence of element of the sequence with its lagged pairing</returns>
+
+        public static IEnumerable<(TSource Item, TSource OffsetItem)> Lag<TSource>(this IEnumerable<TSource> source, int offset)
+            => MoreEnumerable.Lag(source, offset);
+
+        /// <summary>
+        /// Produces a sequence of tuple containing a pair of elements separated by a negative offset.
+        /// </summary>
+        /// <remarks>
+        /// This operator evaluates in a deferred and streaming manner.<br/>
+        /// For elements prior to the lag offset, <paramref name="defaultLagValue"/> is used as the lagged value.<br/>
+        /// </remarks>
+        /// <typeparam name="TSource">The type of the elements of the source sequence</typeparam>
+        /// <param name="source">The sequence over which to evaluate lag</param>
+        /// <param name="offset">The offset (expressed as a positive number) by which to lag each value of the sequence</param>
+        /// <param name="defaultLagValue">A default value supplied for the lagged value prior to the lag offset</param>
+        /// <returns>A sequence of element of the sequence with its lagged pairing</returns>
+
+        public static IEnumerable<(TSource Item, TSource OffsetItem)> Lag<TSource>(this IEnumerable<TSource> source, int offset, TSource defaultLagValue)
+            => MoreEnumerable.Lag(source, offset, defaultLagValue);
         /// <summary>
         /// Produces a projection of a sequence by evaluating pairs of elements separated by a
         /// negative offset.
@@ -3176,6 +3575,37 @@ public static partial class LastOrDefaultExtension
     [GeneratedCode("MoreLinq.ExtensionsGenerator", "1.0.0.0")]
     public static partial class LeadExtension
     {
+
+        /// <summary>
+        /// Produces a sequence of tuple containing a pair of elements separated by a positive offset.
+        /// </summary>
+        /// <remarks>
+        /// This operator evaluates in a deferred and streaming manner.<br/>
+        /// For elements of the sequence that are less than <paramref name="offset"/> items from the end,
+        /// default(T) is used as the lead value.<br/>
+        /// </remarks>
+        /// <typeparam name="TSource">The type of the elements in the source sequence</typeparam>
+        /// <param name="source">The sequence over which to evaluate Lead</param>
+        /// <param name="offset">The offset (expressed as a positive number) by which to lead each element of the sequence</param>
+        /// <returns>The produced sequence of tuple</returns>
+
+        public static IEnumerable<(TSource Item, TSource? OffsetItem)> Lead<TSource>(this IEnumerable<TSource> source, int offset)
+            => MoreEnumerable.Lead(source, offset);
+
+        /// <summary>
+        /// Produces a sequence of tuple containing a pair of elements separated by a positive offset.
+        /// </summary>
+        /// <remarks>
+        /// This operator evaluates in a deferred and streaming manner.<br/>
+        /// </remarks>
+        /// <typeparam name="TSource">The type of the elements in the source sequence</typeparam>
+        /// <param name="source">The sequence over which to evaluate Lead</param>
+        /// <param name="offset">The offset (expressed as a positive number) by which to lead each element of the sequence</param>
+        /// <param name="defaultLeadValue">A default value supplied for the leading element when none is available</param>
+        /// <returns>The produced sequence of tuple</returns>
+
+        public static IEnumerable<(TSource Item, TSource OffsetItem)> Lead<TSource>(this IEnumerable<TSource> source, int offset, TSource defaultLeadValue)
+            => MoreEnumerable.Lead(source, offset, defaultLeadValue);
         /// <summary>
         /// Produces a projection of a sequence by evaluating pairs of elements separated by a
         /// positive offset.
@@ -4093,6 +4523,25 @@ public static IEnumerable<TSource> PadStart<TSource>(this IEnumerable<TSource> s
     [GeneratedCode("MoreLinq.ExtensionsGenerator", "1.0.0.0")]
     public static partial class PairwiseExtension
     {
+        /// <summary>
+        /// Returns a sequence where each element in the source sequence is
+        /// paired with its predecessor, with the exception of the first
+        /// element which is only returned as the predecessor of the second
+        /// element.
+        /// </summary>
+        /// <typeparam name="TSource">
+        /// The type of the elements of <paramref name="source"/>.</typeparam>
+        /// <param name="source">The source sequence.</param>
+        /// <returns>
+        /// Returns the resulting sequence.
+        /// </returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+
+        public static IEnumerable<(TSource, TSource)>
+            Pairwise<TSource>(this IEnumerable<TSource> source)             => MoreEnumerable.            Pairwise(source);
+
         /// <summary>
         /// Returns a sequence resulting from applying a function to each
         /// element in the source sequence and its
@@ -5888,6 +6337,32 @@ public static IEnumerable<IList<T>> Subsets<T>(this IEnumerable<T> sequence, int
     [GeneratedCode("MoreLinq.ExtensionsGenerator", "1.0.0.0")]
     public static partial class TagFirstLastExtension
     {
+
+        /// <summary>
+        /// Returns a sequence of tuples, where the N-th tuple contains the N-th
+        /// element of the source sequence and two booleans indicating whether the
+        /// element is the first and/or last.
+        /// </summary>
+        /// <typeparam name="TSource">The type of the elements of <paramref name="source"/>.</typeparam>
+        /// <param name="source">The source sequence.</param>
+        /// <returns>
+        /// Returns the resulting sequence.
+        /// </returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        /// <example>
+        /// <code><![CDATA[
+        /// var numbers = new[] { 123, 456, 789 };
+        /// var result = numbers.TagFirstLast();
+        /// ]]></code>
+        /// The <c>result</c> variable, when iterated over, will yield
+        /// <c>(123, True, False)</c>, <c>(456, False, False)</c> and
+        /// <c>(789, False, True)</c> in turn.
+        /// </example>
+
+        public static IEnumerable<(TSource Item, bool IsFirst, bool IsLast)> TagFirstLast<TSource>(this IEnumerable<TSource> source)
+            => MoreEnumerable.TagFirstLast(source);
         /// <summary>
         /// Returns a sequence resulting from applying a function to each
         /// element in the source sequence with additional parameters
@@ -6996,6 +7471,74 @@ public static IEnumerable<IList<TSource>> WindowRight<TSource>(this IEnumerable<
     [GeneratedCode("MoreLinq.ExtensionsGenerator", "1.0.0.0")]
     public static partial class ZipLongestExtension
     {
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the argument sequences. The resulting sequence
+        /// will always be as long as the longest of input sequences where the
+        /// default value of each of the shorter sequence element types is used
+        /// for padding.
+        /// </summary>
+        /// <typeparam name="TFirst">Type of elements in first sequence.</typeparam>
+        /// <typeparam name="TSecond">Type of elements in second sequence.</typeparam>
+        /// <param name="first">The first sequence.</param>
+        /// <param name="second">The second sequence.</param>
+        /// <returns>
+        /// A sequence of tuples that contains elements of the two input sequences.
+        /// </returns>
+        /// <example>
+        /// <code><![CDATA[
+        /// var numbers = { 1, 2, 3 };
+        /// var letters = { "A", "B", "C", "D" };
+        /// var zipped = numbers.ZipLongest(letters);
+        /// ]]></code>
+        /// The <c>zipped</c> variable, when iterated over, will yield the tuples : (1, A),
+        /// (2, B), (3, C), (0, D) in turn.
+        /// </example>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+
+        public static IEnumerable<(TFirst, TSecond)> ZipLongest<TFirst, TSecond>(
+            this IEnumerable<TFirst> first,
+            IEnumerable<TSecond> second)
+            => MoreEnumerable.ZipLongest(first, second);
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the argument sequences. The resulting sequence
+        /// will always be as long as the longest of input sequences where the
+        /// default value of each of the shorter sequence element types is used
+        /// for padding.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third sequence.</typeparam>
+        /// <param name="first">The first sequence.</param>
+        /// <param name="second">The second sequence.</param>
+        /// <param name="third">The third sequence.</param>
+        /// <returns>
+        /// A sequence of tuples that contains elements of the three input sequences.
+        /// </returns>
+        /// <example>
+        /// <code><![CDATA[
+        /// var numbers = new[] { 1, 2, 3 };
+        /// var letters = new[] { "A", "B", "C", "D" };
+        /// var chars   = new[] { 'a', 'b', 'c', 'd', 'e' };
+        /// var zipped  = numbers.ZipLongest(letters, chars);
+        /// ]]></code>
+        /// The <c>zipped</c> variable, when iterated over, will yield (1, "A", 'a'),
+        /// (2, "B", 'b'), (3, "C", 'c'), (0, "D", 'd'), (0, <see langword="null"/>, 'e') in turn.
+        /// </example>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+
+        public static IEnumerable<(T1, T2, T3)> ZipLongest<T1, T2, T3>(
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third)
+            => MoreEnumerable.ZipLongest(first, second, third);
         /// <summary>
         /// Returns a projection of tuples, where each tuple contains the N-th
         /// element from each of the argument sequences. The resulting sequence
@@ -7037,6 +7580,47 @@ public static IEnumerable<TResult> ZipLongest<TFirst, TSecond, TResult>(
             Func<TFirst?, TSecond?, TResult> resultSelector)
             => MoreEnumerable.ZipLongest(first, second, resultSelector);
 
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the argument sequences. The resulting sequence
+        /// will always be as long as the longest of input sequences where the
+        /// default value of each of the shorter sequence element types is used
+        /// for padding.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first sequence</typeparam>
+        /// <typeparam name="T2">Type of elements in second sequence</typeparam>
+        /// <typeparam name="T3">Type of elements in third sequence</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth sequence</typeparam>
+        /// <param name="first">The first sequence.</param>
+        /// <param name="second">The second sequence.</param>
+        /// <param name="third">The third sequence.</param>
+        /// <param name="fourth">The fourth sequence.</param>
+        /// <returns>
+        /// A sequence of tuples that contains elements of the four input sequences.
+        /// </returns>
+        /// <example>
+        /// <code><![CDATA[
+        /// var numbers = new[] { 1, 2, 3 };
+        /// var letters = new[] { "A", "B", "C", "D" };
+        /// var chars   = new[] { 'a', 'b', 'c', 'd', 'e' };
+        /// var flags   = new[] { true, false, true, false, true, false };
+        /// var zipped  = numbers.ZipLongest(letters, chars, flags);
+        /// ]]></code>
+        /// The <c>zipped</c> variable, when iterated over, will yield (1, "A", 'a', <see langword="true"/>),
+        /// (2, "B", 'b', <see langword="false"/>), (3, "C", 'c', <see langword="true"/>), (0, "D", 'd', <see langword="false"/>),
+        /// (0, <see langword="null"/>, 'e', <see langword="true"/>), (0, <see langword="null"/>, '\0', <see langword="false"/>) in turn.
+        /// </example>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+
+        public static IEnumerable<(T1, T2, T3, T4)> ZipLongest<T1, T2, T3, T4>(
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth)
+            => MoreEnumerable.ZipLongest(first, second, third, fourth);
+
         /// <summary>
         /// Returns a projection of tuples, where each tuple contains the N-th
         /// element from each of the argument sequences. The resulting sequence
@@ -7140,6 +7724,82 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, TResult>(
     [GeneratedCode("MoreLinq.ExtensionsGenerator", "1.0.0.0")]
     public static partial class ZipShortestExtension
     {
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the argument sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="TFirst">Type of elements in first sequence.</typeparam>
+        /// <typeparam name="TSecond">Type of elements in second sequence.</typeparam>
+        /// <param name="first">The first sequence.</param>
+        /// <param name="second">The second sequence.</param>
+        /// <returns>
+        /// A sequence of tuples that contains elements of the two input sequences.
+        /// </returns>
+        /// <example>
+        /// <code><![CDATA[
+        /// var numbers = new[] { 1, 2, 3 };
+        /// var letters = new[] { "A", "B", "C", "D" };
+        /// var zipped  = numbers.ZipShortest(letters);
+        /// ]]></code>
+        /// The <c>zipped</c> variable, when iterated over, will yield
+        /// (1, "A"), (2, "B"), (3, "C") in turn.
+        /// </example>
+        /// <remarks>
+        /// <para>
+        /// If the input sequences are of different lengths, the result sequence
+        /// is terminated as soon as the shortest input sequence is exhausted
+        /// and remainder elements from the longer sequences are never consumed.
+        /// </para>
+        /// <para>
+        /// This operator uses deferred execution and streams its results.</para>
+        /// </remarks>
+
+        public static IEnumerable<(TFirst, TSecond)> ZipShortest<TFirst, TSecond>(
+            this IEnumerable<TFirst> first,
+            IEnumerable<TSecond> second)
+            => MoreEnumerable.ZipShortest(first, second);
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the argument sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third sequence.</typeparam>
+        /// <param name="first">First sequence</param>
+        /// <param name="second">Second sequence</param>
+        /// <param name="third">Third sequence</param>
+        /// <returns>
+        /// A sequence of tuples that contains elements of the three input sequences.
+        /// </returns>
+        /// <example>
+        /// <code><![CDATA[
+        /// var numbers = new[] { 1, 2, 3 };
+        /// var letters = new[] { "A", "B", "C", "D" };
+        /// var chars   = new[] { 'a', 'b', 'c', 'd', 'e' };
+        /// var zipped  = numbers.ZipShortest(letters, chars);
+        /// ]]></code>
+        /// The <c>zipped</c> variable, when iterated over, will yield
+        /// (1, "A", 'a'), (2, "B", 'b'), (3, "C", 'c') in turn.
+        /// </example>
+        /// <remarks>
+        /// <para>
+        /// If the input sequences are of different lengths, the result sequence
+        /// is terminated as soon as the shortest input sequence is exhausted
+        /// and remainder elements from the longer sequences are never consumed.
+        /// </para>
+        /// <para>
+        /// This operator uses deferred execution and streams its results.</para>
+        /// </remarks>
+
+        public static IEnumerable<(T1, T2, T3)> ZipShortest<T1, T2, T3>(
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third)
+            => MoreEnumerable.ZipShortest(first, second, third);
         /// <summary>
         /// Returns a projection of tuples, where each tuple contains the N-th
         /// element from each of the argument sequences. The resulting sequence
@@ -7183,6 +7843,50 @@ public static IEnumerable<TResult> ZipShortest<TFirst, TSecond, TResult>(
             Func<TFirst, TSecond, TResult> resultSelector)
             => MoreEnumerable.ZipShortest(first, second, resultSelector);
 
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the argument sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth sequence.</typeparam>
+        /// <param name="first">The first sequence.</param>
+        /// <param name="second">The second sequence.</param>
+        /// <param name="third">The third sequence.</param>
+        /// <param name="fourth">The fourth sequence.</param>
+        /// <returns>
+        /// A sequence of tuples that contains elements of the four input sequences.
+        /// </returns>
+        /// <example>
+        /// <code><![CDATA[
+        /// var numbers = new[] { 1, 2, 3 };
+        /// var letters = new[] { "A", "B", "C", "D" };
+        /// var chars   = new[] { 'a', 'b', 'c', 'd', 'e' };
+        /// var flags   = new[] { true, false };
+        /// var zipped  = numbers.ZipShortest(letters, chars, flags);
+        /// ]]></code>
+        /// The <c>zipped</c> variable, when iterated over, will yield
+        /// (1, "A", 'a', <see langword="true"/>), (2, "B", 'b', <see langword="false"/>) in turn.
+        /// </example>
+        /// <remarks>
+        /// <para>
+        /// If the input sequences are of different lengths, the result sequence
+        /// is terminated as soon as the shortest input sequence is exhausted
+        /// and remainder elements from the longer sequences are never consumed.
+        /// </para>
+        /// <para>
+        /// This operator uses deferred execution and streams its results.</para>
+        /// </remarks>
+
+        public static IEnumerable<(T1, T2, T3, T4)> ZipShortest<T1, T2, T3, T4>(
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth)
+            => MoreEnumerable.ZipShortest(first, second, third, fourth);
+
         /// <summary>
         /// Returns a projection of tuples, where each tuple contains the N-th
         /// element from each of the argument sequences. The resulting sequence
diff --git a/MoreLinq/Lag.cs b/MoreLinq/Lag.cs
index 4b532a649..24c36b81e 100644
--- a/MoreLinq/Lag.cs
+++ b/MoreLinq/Lag.cs
@@ -113,5 +113,40 @@ public static IEnumerable<TResult> Lag<TSource, TResult>(this IEnumerable<TSourc
                 }
             }
         }
+
+        /// <summary>
+        /// Produces a sequence of tuple containing a pair of elements separated by a negative offset.
+        /// </summary>
+        /// <remarks>
+        /// This operator evaluates in a deferred and streaming manner.<br/>
+        /// For elements prior to the lag offset, <c>default(T)</c> is used as the lagged value.<br/>
+        /// </remarks>
+        /// <typeparam name="TSource">The type of the elements of the source sequence</typeparam>
+        /// <param name="source">The sequence over which to evaluate lag</param>
+        /// <param name="offset">The offset (expressed as a positive number) by which to lag each value of the sequence</param>
+        /// <returns>A sequence of element of the sequence with its lagged pairing</returns>
+
+        public static IEnumerable<(TSource Item, TSource OffsetItem)> Lag<TSource>(this IEnumerable<TSource> source, int offset)
+        {
+            return Lag(source, offset, default, ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Produces a sequence of tuple containing a pair of elements separated by a negative offset.
+        /// </summary>
+        /// <remarks>
+        /// This operator evaluates in a deferred and streaming manner.<br/>
+        /// For elements prior to the lag offset, <paramref name="defaultLagValue"/> is used as the lagged value.<br/>
+        /// </remarks>
+        /// <typeparam name="TSource">The type of the elements of the source sequence</typeparam>
+        /// <param name="source">The sequence over which to evaluate lag</param>
+        /// <param name="offset">The offset (expressed as a positive number) by which to lag each value of the sequence</param>
+        /// <param name="defaultLagValue">A default value supplied for the lagged value prior to the lag offset</param>
+        /// <returns>A sequence of element of the sequence with its lagged pairing</returns>
+
+        public static IEnumerable<(TSource Item, TSource OffsetItem)> Lag<TSource>(this IEnumerable<TSource> source, int offset, TSource defaultLagValue)
+        {
+            return Lag(source, offset, defaultLagValue, ValueTuple.Create);
+        }
     }
 }
diff --git a/MoreLinq/Lead.cs b/MoreLinq/Lead.cs
index 2a0b7cbb3..2668f4805 100644
--- a/MoreLinq/Lead.cs
+++ b/MoreLinq/Lead.cs
@@ -103,5 +103,40 @@ public static IEnumerable<TResult> Lead<TSource, TResult>(this IEnumerable<TSour
                     yield return resultSelector(leadQueue.Dequeue(), defaultLeadValue);
             }
         }
+
+        /// <summary>
+        /// Produces a sequence of tuple containing a pair of elements separated by a positive offset.
+        /// </summary>
+        /// <remarks>
+        /// This operator evaluates in a deferred and streaming manner.<br/>
+        /// For elements of the sequence that are less than <paramref name="offset"/> items from the end,
+        /// default(T) is used as the lead value.<br/>
+        /// </remarks>
+        /// <typeparam name="TSource">The type of the elements in the source sequence</typeparam>
+        /// <param name="source">The sequence over which to evaluate Lead</param>
+        /// <param name="offset">The offset (expressed as a positive number) by which to lead each element of the sequence</param>
+        /// <returns>The produced sequence of tuple</returns>
+
+        public static IEnumerable<(TSource Item, TSource? OffsetItem)> Lead<TSource>(this IEnumerable<TSource> source, int offset)
+        {
+            return Lead(source, offset, ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Produces a sequence of tuple containing a pair of elements separated by a positive offset.
+        /// </summary>
+        /// <remarks>
+        /// This operator evaluates in a deferred and streaming manner.<br/>
+        /// </remarks>
+        /// <typeparam name="TSource">The type of the elements in the source sequence</typeparam>
+        /// <param name="source">The sequence over which to evaluate Lead</param>
+        /// <param name="offset">The offset (expressed as a positive number) by which to lead each element of the sequence</param>
+        /// <param name="defaultLeadValue">A default value supplied for the leading element when none is available</param>
+        /// <returns>The produced sequence of tuple</returns>
+
+        public static IEnumerable<(TSource Item, TSource OffsetItem)> Lead<TSource>(this IEnumerable<TSource> source, int offset, TSource defaultLeadValue)
+        {
+            return Lead(source, offset, defaultLeadValue, ValueTuple.Create);
+        }
     }
 }
diff --git a/MoreLinq/Pairwise.cs b/MoreLinq/Pairwise.cs
index 9e262e85d..aa8bbed02 100644
--- a/MoreLinq/Pairwise.cs
+++ b/MoreLinq/Pairwise.cs
@@ -22,6 +22,26 @@ namespace MoreLinq
 
     static partial class MoreEnumerable
     {
+        /// <summary>
+        /// Returns a sequence where each element in the source sequence is
+        /// paired with its predecessor, with the exception of the first
+        /// element which is only returned as the predecessor of the second
+        /// element.
+        /// </summary>
+        /// <typeparam name="TSource">
+        /// The type of the elements of <paramref name="source"/>.</typeparam>
+        /// <param name="source">The source sequence.</param>
+        /// <returns>
+        /// Returns the resulting sequence.
+        /// </returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+
+        public static IEnumerable<(TSource, TSource)>
+            Pairwise<TSource>(this IEnumerable<TSource> source) =>
+                Pairwise(source, ValueTuple.Create);
+
         /// <summary>
         /// Returns a sequence resulting from applying a function to each
         /// element in the source sequence and its
diff --git a/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt
index 8b26bf00b..152471471 100644
--- a/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt
+++ b/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt
@@ -21,15 +21,53 @@ MoreLinq.Extensions.MaximaExtension
 MoreLinq.Extensions.MinimaExtension
 static MoreLinq.Extensions.BatchExtension.Batch<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, int size, System.Func<TSource[]!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
 static MoreLinq.Extensions.BatchExtension.Batch<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int size) -> System.Collections.Generic.IEnumerable<TSource[]!>!
+static MoreLinq.Extensions.CartesianExtension.Cartesian<T1, T2, T3, T4, T5, T6, T7, T8>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth, System.Collections.Generic.IEnumerable<T6>! sixth, System.Collections.Generic.IEnumerable<T7>! seventh, System.Collections.Generic.IEnumerable<T8>! eighth) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second, T3 Third, T4 Fourth, T5 Fifth, T6 Sixth, T7 Seventh, T8 Eighth)>!
+static MoreLinq.Extensions.CartesianExtension.Cartesian<T1, T2, T3, T4, T5, T6, T7>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth, System.Collections.Generic.IEnumerable<T6>! sixth, System.Collections.Generic.IEnumerable<T7>! seventh) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second, T3 Third, T4 Fourth, T5 Fifth, T6 Sixth, T7 Seventh)>!
+static MoreLinq.Extensions.CartesianExtension.Cartesian<T1, T2, T3, T4, T5, T6>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth, System.Collections.Generic.IEnumerable<T6>! sixth) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second, T3 Third, T4 Fourth, T5 Fifth, T6 Sixth)>!
+static MoreLinq.Extensions.CartesianExtension.Cartesian<T1, T2, T3, T4, T5>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second, T3 Third, T4 Fourth, T5 Fifth)>!
+static MoreLinq.Extensions.CartesianExtension.Cartesian<T1, T2, T3, T4>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second, T3 Third, T4 Fourth)>!
+static MoreLinq.Extensions.CartesianExtension.Cartesian<T1, T2, T3>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second, T3 Third)>!
+static MoreLinq.Extensions.CartesianExtension.Cartesian<T1, T2>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second)>!
+static MoreLinq.Extensions.CountDownExtension.CountDown<T>(this System.Collections.Generic.IEnumerable<T>! source, int count) -> System.Collections.Generic.IEnumerable<(T Item, int? CountDown)>!
+static MoreLinq.Extensions.EquiZipExtension.EquiZip<T1, T2, T3, T4>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth) -> System.Collections.Generic.IEnumerable<(T1, T2, T3, T4)>!
+static MoreLinq.Extensions.EquiZipExtension.EquiZip<T1, T2, T3>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third) -> System.Collections.Generic.IEnumerable<(T1, T2, T3)>!
+static MoreLinq.Extensions.EquiZipExtension.EquiZip<T1, T2>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second) -> System.Collections.Generic.IEnumerable<(T1, T2)>!
+static MoreLinq.Extensions.LagExtension.Lag<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset) -> System.Collections.Generic.IEnumerable<(TSource Item, TSource OffsetItem)>!
+static MoreLinq.Extensions.LagExtension.Lag<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset, TSource defaultLagValue) -> System.Collections.Generic.IEnumerable<(TSource Item, TSource OffsetItem)>!
+static MoreLinq.Extensions.LeadExtension.Lead<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset) -> System.Collections.Generic.IEnumerable<(TSource Item, TSource? OffsetItem)>!
+static MoreLinq.Extensions.LeadExtension.Lead<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset, TSource defaultLeadValue) -> System.Collections.Generic.IEnumerable<(TSource Item, TSource OffsetItem)>!
 static MoreLinq.Extensions.MaximaExtension.Maxima<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
 static MoreLinq.Extensions.MaximaExtension.Maxima<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector, System.Collections.Generic.IComparer<TKey>? comparer) -> MoreLinq.IExtremaEnumerable<TSource>!
 static MoreLinq.Extensions.MinimaExtension.Minima<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
 static MoreLinq.Extensions.MinimaExtension.Minima<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector, System.Collections.Generic.IComparer<TKey>? comparer) -> MoreLinq.IExtremaEnumerable<TSource>!
+static MoreLinq.Extensions.PairwiseExtension.Pairwise<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<(TSource, TSource)>!
+static MoreLinq.Extensions.TagFirstLastExtension.TagFirstLast<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<(TSource Item, bool IsFirst, bool IsLast)>!
+static MoreLinq.Extensions.ZipLongestExtension.ZipLongest<T1, T2, T3, T4>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth) -> System.Collections.Generic.IEnumerable<(T1, T2, T3, T4)>!
+static MoreLinq.Extensions.ZipLongestExtension.ZipLongest<T1, T2, T3>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third) -> System.Collections.Generic.IEnumerable<(T1, T2, T3)>!
+static MoreLinq.Extensions.ZipLongestExtension.ZipLongest<TFirst, TSecond>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second) -> System.Collections.Generic.IEnumerable<(TFirst, TSecond)>!
+static MoreLinq.Extensions.ZipShortestExtension.ZipShortest<T1, T2, T3, T4>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth) -> System.Collections.Generic.IEnumerable<(T1, T2, T3, T4)>!
+static MoreLinq.Extensions.ZipShortestExtension.ZipShortest<T1, T2, T3>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third) -> System.Collections.Generic.IEnumerable<(T1, T2, T3)>!
+static MoreLinq.Extensions.ZipShortestExtension.ZipShortest<TFirst, TSecond>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second) -> System.Collections.Generic.IEnumerable<(TFirst, TSecond)>!
 static MoreLinq.MoreEnumerable.Append<T>(System.Collections.Generic.IEnumerable<T>! head, T tail) -> System.Collections.Generic.IEnumerable<T>!
 static MoreLinq.MoreEnumerable.Batch<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, int size, System.Func<TSource[]!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
 static MoreLinq.MoreEnumerable.Batch<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int size) -> System.Collections.Generic.IEnumerable<TSource[]!>!
+static MoreLinq.MoreEnumerable.Cartesian<T1, T2, T3, T4, T5, T6, T7, T8>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth, System.Collections.Generic.IEnumerable<T6>! sixth, System.Collections.Generic.IEnumerable<T7>! seventh, System.Collections.Generic.IEnumerable<T8>! eighth) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second, T3 Third, T4 Fourth, T5 Fifth, T6 Sixth, T7 Seventh, T8 Eighth)>!
+static MoreLinq.MoreEnumerable.Cartesian<T1, T2, T3, T4, T5, T6, T7>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth, System.Collections.Generic.IEnumerable<T6>! sixth, System.Collections.Generic.IEnumerable<T7>! seventh) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second, T3 Third, T4 Fourth, T5 Fifth, T6 Sixth, T7 Seventh)>!
+static MoreLinq.MoreEnumerable.Cartesian<T1, T2, T3, T4, T5, T6>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth, System.Collections.Generic.IEnumerable<T6>! sixth) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second, T3 Third, T4 Fourth, T5 Fifth, T6 Sixth)>!
+static MoreLinq.MoreEnumerable.Cartesian<T1, T2, T3, T4, T5>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second, T3 Third, T4 Fourth, T5 Fifth)>!
+static MoreLinq.MoreEnumerable.Cartesian<T1, T2, T3, T4>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second, T3 Third, T4 Fourth)>!
+static MoreLinq.MoreEnumerable.Cartesian<T1, T2, T3>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second, T3 Third)>!
+static MoreLinq.MoreEnumerable.Cartesian<T1, T2>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second)>!
+static MoreLinq.MoreEnumerable.CountDown<T>(this System.Collections.Generic.IEnumerable<T>! source, int count) -> System.Collections.Generic.IEnumerable<(T Item, int? CountDown)>!
 static MoreLinq.MoreEnumerable.DistinctBy<TSource, TKey>(System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<TSource>!
 static MoreLinq.MoreEnumerable.DistinctBy<TSource, TKey>(System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.EquiZip<T1, T2, T3, T4>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth) -> System.Collections.Generic.IEnumerable<(T1, T2, T3, T4)>!
+static MoreLinq.MoreEnumerable.EquiZip<T1, T2, T3>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third) -> System.Collections.Generic.IEnumerable<(T1, T2, T3)>!
+static MoreLinq.MoreEnumerable.EquiZip<T1, T2>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second) -> System.Collections.Generic.IEnumerable<(T1, T2)>!
+static MoreLinq.MoreEnumerable.Lag<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset) -> System.Collections.Generic.IEnumerable<(TSource Item, TSource OffsetItem)>!
+static MoreLinq.MoreEnumerable.Lag<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset, TSource defaultLagValue) -> System.Collections.Generic.IEnumerable<(TSource Item, TSource OffsetItem)>!
+static MoreLinq.MoreEnumerable.Lead<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset) -> System.Collections.Generic.IEnumerable<(TSource Item, TSource? OffsetItem)>!
+static MoreLinq.MoreEnumerable.Lead<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset, TSource defaultLeadValue) -> System.Collections.Generic.IEnumerable<(TSource Item, TSource OffsetItem)>!
 static MoreLinq.MoreEnumerable.MaxBy<TSource, TKey>(System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
 static MoreLinq.MoreEnumerable.MaxBy<TSource, TKey>(System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector, System.Collections.Generic.IComparer<TKey>? comparer) -> MoreLinq.IExtremaEnumerable<TSource>!
 static MoreLinq.MoreEnumerable.Maxima<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
@@ -38,8 +76,16 @@ static MoreLinq.MoreEnumerable.MinBy<TSource, TKey>(System.Collections.Generic.I
 static MoreLinq.MoreEnumerable.MinBy<TSource, TKey>(System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector, System.Collections.Generic.IComparer<TKey>? comparer) -> MoreLinq.IExtremaEnumerable<TSource>!
 static MoreLinq.MoreEnumerable.Minima<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
 static MoreLinq.MoreEnumerable.Minima<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector, System.Collections.Generic.IComparer<TKey>? comparer) -> MoreLinq.IExtremaEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.Pairwise<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<(TSource, TSource)>!
 static MoreLinq.MoreEnumerable.Prepend<TSource>(System.Collections.Generic.IEnumerable<TSource>! source, TSource value) -> System.Collections.Generic.IEnumerable<TSource>!
 static MoreLinq.MoreEnumerable.SkipLast<T>(System.Collections.Generic.IEnumerable<T>! source, int count) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.TagFirstLast<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<(TSource Item, bool IsFirst, bool IsLast)>!
 static MoreLinq.MoreEnumerable.TakeLast<TSource>(System.Collections.Generic.IEnumerable<TSource>! source, int count) -> System.Collections.Generic.IEnumerable<TSource>!
 static MoreLinq.MoreEnumerable.ToHashSet<TSource>(System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.HashSet<TSource>!
 static MoreLinq.MoreEnumerable.ToHashSet<TSource>(System.Collections.Generic.IEnumerable<TSource>! source, System.Collections.Generic.IEqualityComparer<TSource>? comparer) -> System.Collections.Generic.HashSet<TSource>!
+static MoreLinq.MoreEnumerable.ZipLongest<T1, T2, T3, T4>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth) -> System.Collections.Generic.IEnumerable<(T1, T2, T3, T4)>!
+static MoreLinq.MoreEnumerable.ZipLongest<T1, T2, T3>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third) -> System.Collections.Generic.IEnumerable<(T1, T2, T3)>!
+static MoreLinq.MoreEnumerable.ZipLongest<TFirst, TSecond>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second) -> System.Collections.Generic.IEnumerable<(TFirst, TSecond)>!
+static MoreLinq.MoreEnumerable.ZipShortest<T1, T2, T3, T4>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth) -> System.Collections.Generic.IEnumerable<(T1, T2, T3, T4)>!
+static MoreLinq.MoreEnumerable.ZipShortest<T1, T2, T3>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third) -> System.Collections.Generic.IEnumerable<(T1, T2, T3)>!
+static MoreLinq.MoreEnumerable.ZipShortest<TFirst, TSecond>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second) -> System.Collections.Generic.IEnumerable<(TFirst, TSecond)>!
diff --git a/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt
index baeef302c..b8ca0b3d2 100644
--- a/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt
+++ b/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt
@@ -11,15 +11,61 @@ MoreLinq.Extensions.MaximaExtension
 MoreLinq.Extensions.MinimaExtension
 static MoreLinq.Extensions.BatchExtension.Batch<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, int size, System.Func<TSource[]!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
 static MoreLinq.Extensions.BatchExtension.Batch<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int size) -> System.Collections.Generic.IEnumerable<TSource[]!>!
+static MoreLinq.Extensions.CartesianExtension.Cartesian<T1, T2, T3, T4, T5, T6, T7, T8>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth, System.Collections.Generic.IEnumerable<T6>! sixth, System.Collections.Generic.IEnumerable<T7>! seventh, System.Collections.Generic.IEnumerable<T8>! eighth) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second, T3 Third, T4 Fourth, T5 Fifth, T6 Sixth, T7 Seventh, T8 Eighth)>!
+static MoreLinq.Extensions.CartesianExtension.Cartesian<T1, T2, T3, T4, T5, T6, T7>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth, System.Collections.Generic.IEnumerable<T6>! sixth, System.Collections.Generic.IEnumerable<T7>! seventh) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second, T3 Third, T4 Fourth, T5 Fifth, T6 Sixth, T7 Seventh)>!
+static MoreLinq.Extensions.CartesianExtension.Cartesian<T1, T2, T3, T4, T5, T6>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth, System.Collections.Generic.IEnumerable<T6>! sixth) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second, T3 Third, T4 Fourth, T5 Fifth, T6 Sixth)>!
+static MoreLinq.Extensions.CartesianExtension.Cartesian<T1, T2, T3, T4, T5>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second, T3 Third, T4 Fourth, T5 Fifth)>!
+static MoreLinq.Extensions.CartesianExtension.Cartesian<T1, T2, T3, T4>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second, T3 Third, T4 Fourth)>!
+static MoreLinq.Extensions.CartesianExtension.Cartesian<T1, T2, T3>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second, T3 Third)>!
+static MoreLinq.Extensions.CartesianExtension.Cartesian<T1, T2>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second)>!
+static MoreLinq.Extensions.CountDownExtension.CountDown<T>(this System.Collections.Generic.IEnumerable<T>! source, int count) -> System.Collections.Generic.IEnumerable<(T Item, int? CountDown)>!
+static MoreLinq.Extensions.EquiZipExtension.EquiZip<T1, T2, T3, T4>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth) -> System.Collections.Generic.IEnumerable<(T1, T2, T3, T4)>!
+static MoreLinq.Extensions.EquiZipExtension.EquiZip<T1, T2, T3>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third) -> System.Collections.Generic.IEnumerable<(T1, T2, T3)>!
+static MoreLinq.Extensions.EquiZipExtension.EquiZip<T1, T2>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second) -> System.Collections.Generic.IEnumerable<(T1, T2)>!
+static MoreLinq.Extensions.LagExtension.Lag<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset) -> System.Collections.Generic.IEnumerable<(TSource Item, TSource OffsetItem)>!
+static MoreLinq.Extensions.LagExtension.Lag<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset, TSource defaultLagValue) -> System.Collections.Generic.IEnumerable<(TSource Item, TSource OffsetItem)>!
+static MoreLinq.Extensions.LeadExtension.Lead<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset) -> System.Collections.Generic.IEnumerable<(TSource Item, TSource? OffsetItem)>!
+static MoreLinq.Extensions.LeadExtension.Lead<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset, TSource defaultLeadValue) -> System.Collections.Generic.IEnumerable<(TSource Item, TSource OffsetItem)>!
 static MoreLinq.Extensions.MaximaExtension.Maxima<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
 static MoreLinq.Extensions.MaximaExtension.Maxima<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector, System.Collections.Generic.IComparer<TKey>? comparer) -> MoreLinq.IExtremaEnumerable<TSource>!
 static MoreLinq.Extensions.MinimaExtension.Minima<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
 static MoreLinq.Extensions.MinimaExtension.Minima<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector, System.Collections.Generic.IComparer<TKey>? comparer) -> MoreLinq.IExtremaEnumerable<TSource>!
+static MoreLinq.Extensions.PairwiseExtension.Pairwise<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<(TSource, TSource)>!
+static MoreLinq.Extensions.TagFirstLastExtension.TagFirstLast<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<(TSource Item, bool IsFirst, bool IsLast)>!
+static MoreLinq.Extensions.ZipLongestExtension.ZipLongest<T1, T2, T3, T4>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth) -> System.Collections.Generic.IEnumerable<(T1, T2, T3, T4)>!
+static MoreLinq.Extensions.ZipLongestExtension.ZipLongest<T1, T2, T3>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third) -> System.Collections.Generic.IEnumerable<(T1, T2, T3)>!
+static MoreLinq.Extensions.ZipLongestExtension.ZipLongest<TFirst, TSecond>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second) -> System.Collections.Generic.IEnumerable<(TFirst, TSecond)>!
+static MoreLinq.Extensions.ZipShortestExtension.ZipShortest<T1, T2, T3, T4>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth) -> System.Collections.Generic.IEnumerable<(T1, T2, T3, T4)>!
+static MoreLinq.Extensions.ZipShortestExtension.ZipShortest<T1, T2, T3>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third) -> System.Collections.Generic.IEnumerable<(T1, T2, T3)>!
+static MoreLinq.Extensions.ZipShortestExtension.ZipShortest<TFirst, TSecond>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second) -> System.Collections.Generic.IEnumerable<(TFirst, TSecond)>!
 static MoreLinq.MoreEnumerable.Append<T>(System.Collections.Generic.IEnumerable<T>! head, T tail) -> System.Collections.Generic.IEnumerable<T>!
 static MoreLinq.MoreEnumerable.Batch<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, int size, System.Func<TSource[]!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
 static MoreLinq.MoreEnumerable.Batch<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int size) -> System.Collections.Generic.IEnumerable<TSource[]!>!
+static MoreLinq.MoreEnumerable.Cartesian<T1, T2, T3, T4, T5, T6, T7, T8>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth, System.Collections.Generic.IEnumerable<T6>! sixth, System.Collections.Generic.IEnumerable<T7>! seventh, System.Collections.Generic.IEnumerable<T8>! eighth) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second, T3 Third, T4 Fourth, T5 Fifth, T6 Sixth, T7 Seventh, T8 Eighth)>!
+static MoreLinq.MoreEnumerable.Cartesian<T1, T2, T3, T4, T5, T6, T7>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth, System.Collections.Generic.IEnumerable<T6>! sixth, System.Collections.Generic.IEnumerable<T7>! seventh) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second, T3 Third, T4 Fourth, T5 Fifth, T6 Sixth, T7 Seventh)>!
+static MoreLinq.MoreEnumerable.Cartesian<T1, T2, T3, T4, T5, T6>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth, System.Collections.Generic.IEnumerable<T6>! sixth) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second, T3 Third, T4 Fourth, T5 Fifth, T6 Sixth)>!
+static MoreLinq.MoreEnumerable.Cartesian<T1, T2, T3, T4, T5>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second, T3 Third, T4 Fourth, T5 Fifth)>!
+static MoreLinq.MoreEnumerable.Cartesian<T1, T2, T3, T4>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second, T3 Third, T4 Fourth)>!
+static MoreLinq.MoreEnumerable.Cartesian<T1, T2, T3>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second, T3 Third)>!
+static MoreLinq.MoreEnumerable.Cartesian<T1, T2>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second)>!
+static MoreLinq.MoreEnumerable.CountDown<T>(this System.Collections.Generic.IEnumerable<T>! source, int count) -> System.Collections.Generic.IEnumerable<(T Item, int? CountDown)>!
+static MoreLinq.MoreEnumerable.EquiZip<T1, T2, T3, T4>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth) -> System.Collections.Generic.IEnumerable<(T1, T2, T3, T4)>!
+static MoreLinq.MoreEnumerable.EquiZip<T1, T2, T3>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third) -> System.Collections.Generic.IEnumerable<(T1, T2, T3)>!
+static MoreLinq.MoreEnumerable.EquiZip<T1, T2>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second) -> System.Collections.Generic.IEnumerable<(T1, T2)>!
+static MoreLinq.MoreEnumerable.Lag<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset) -> System.Collections.Generic.IEnumerable<(TSource Item, TSource OffsetItem)>!
+static MoreLinq.MoreEnumerable.Lag<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset, TSource defaultLagValue) -> System.Collections.Generic.IEnumerable<(TSource Item, TSource OffsetItem)>!
+static MoreLinq.MoreEnumerable.Lead<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset) -> System.Collections.Generic.IEnumerable<(TSource Item, TSource? OffsetItem)>!
+static MoreLinq.MoreEnumerable.Lead<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset, TSource defaultLeadValue) -> System.Collections.Generic.IEnumerable<(TSource Item, TSource OffsetItem)>!
 static MoreLinq.MoreEnumerable.Maxima<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
 static MoreLinq.MoreEnumerable.Maxima<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector, System.Collections.Generic.IComparer<TKey>? comparer) -> MoreLinq.IExtremaEnumerable<TSource>!
 static MoreLinq.MoreEnumerable.Minima<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
 static MoreLinq.MoreEnumerable.Minima<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector, System.Collections.Generic.IComparer<TKey>? comparer) -> MoreLinq.IExtremaEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.Pairwise<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<(TSource, TSource)>!
 static MoreLinq.MoreEnumerable.Prepend<TSource>(System.Collections.Generic.IEnumerable<TSource>! source, TSource value) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.TagFirstLast<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<(TSource Item, bool IsFirst, bool IsLast)>!
+static MoreLinq.MoreEnumerable.ZipLongest<T1, T2, T3, T4>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth) -> System.Collections.Generic.IEnumerable<(T1, T2, T3, T4)>!
+static MoreLinq.MoreEnumerable.ZipLongest<T1, T2, T3>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third) -> System.Collections.Generic.IEnumerable<(T1, T2, T3)>!
+static MoreLinq.MoreEnumerable.ZipLongest<TFirst, TSecond>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second) -> System.Collections.Generic.IEnumerable<(TFirst, TSecond)>!
+static MoreLinq.MoreEnumerable.ZipShortest<T1, T2, T3, T4>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth) -> System.Collections.Generic.IEnumerable<(T1, T2, T3, T4)>!
+static MoreLinq.MoreEnumerable.ZipShortest<T1, T2, T3>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third) -> System.Collections.Generic.IEnumerable<(T1, T2, T3)>!
+static MoreLinq.MoreEnumerable.ZipShortest<TFirst, TSecond>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second) -> System.Collections.Generic.IEnumerable<(TFirst, TSecond)>!
diff --git a/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt
index 0a76e35e0..7d42906b5 100644
--- a/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt
+++ b/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt
@@ -15,19 +15,65 @@ MoreLinq.Extensions.MaximaExtension
 MoreLinq.Extensions.MinimaExtension
 static MoreLinq.Extensions.BatchExtension.Batch<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, int size, System.Func<TSource[]!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
 static MoreLinq.Extensions.BatchExtension.Batch<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int size) -> System.Collections.Generic.IEnumerable<TSource[]!>!
+static MoreLinq.Extensions.CartesianExtension.Cartesian<T1, T2, T3, T4, T5, T6, T7, T8>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth, System.Collections.Generic.IEnumerable<T6>! sixth, System.Collections.Generic.IEnumerable<T7>! seventh, System.Collections.Generic.IEnumerable<T8>! eighth) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second, T3 Third, T4 Fourth, T5 Fifth, T6 Sixth, T7 Seventh, T8 Eighth)>!
+static MoreLinq.Extensions.CartesianExtension.Cartesian<T1, T2, T3, T4, T5, T6, T7>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth, System.Collections.Generic.IEnumerable<T6>! sixth, System.Collections.Generic.IEnumerable<T7>! seventh) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second, T3 Third, T4 Fourth, T5 Fifth, T6 Sixth, T7 Seventh)>!
+static MoreLinq.Extensions.CartesianExtension.Cartesian<T1, T2, T3, T4, T5, T6>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth, System.Collections.Generic.IEnumerable<T6>! sixth) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second, T3 Third, T4 Fourth, T5 Fifth, T6 Sixth)>!
+static MoreLinq.Extensions.CartesianExtension.Cartesian<T1, T2, T3, T4, T5>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second, T3 Third, T4 Fourth, T5 Fifth)>!
+static MoreLinq.Extensions.CartesianExtension.Cartesian<T1, T2, T3, T4>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second, T3 Third, T4 Fourth)>!
+static MoreLinq.Extensions.CartesianExtension.Cartesian<T1, T2, T3>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second, T3 Third)>!
+static MoreLinq.Extensions.CartesianExtension.Cartesian<T1, T2>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second)>!
+static MoreLinq.Extensions.CountDownExtension.CountDown<T>(this System.Collections.Generic.IEnumerable<T>! source, int count) -> System.Collections.Generic.IEnumerable<(T Item, int? CountDown)>!
+static MoreLinq.Extensions.EquiZipExtension.EquiZip<T1, T2, T3, T4>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth) -> System.Collections.Generic.IEnumerable<(T1, T2, T3, T4)>!
+static MoreLinq.Extensions.EquiZipExtension.EquiZip<T1, T2, T3>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third) -> System.Collections.Generic.IEnumerable<(T1, T2, T3)>!
+static MoreLinq.Extensions.EquiZipExtension.EquiZip<T1, T2>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second) -> System.Collections.Generic.IEnumerable<(T1, T2)>!
+static MoreLinq.Extensions.LagExtension.Lag<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset) -> System.Collections.Generic.IEnumerable<(TSource Item, TSource OffsetItem)>!
+static MoreLinq.Extensions.LagExtension.Lag<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset, TSource defaultLagValue) -> System.Collections.Generic.IEnumerable<(TSource Item, TSource OffsetItem)>!
+static MoreLinq.Extensions.LeadExtension.Lead<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset) -> System.Collections.Generic.IEnumerable<(TSource Item, TSource? OffsetItem)>!
+static MoreLinq.Extensions.LeadExtension.Lead<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset, TSource defaultLeadValue) -> System.Collections.Generic.IEnumerable<(TSource Item, TSource OffsetItem)>!
 static MoreLinq.Extensions.MaximaExtension.Maxima<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
 static MoreLinq.Extensions.MaximaExtension.Maxima<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector, System.Collections.Generic.IComparer<TKey>? comparer) -> MoreLinq.IExtremaEnumerable<TSource>!
 static MoreLinq.Extensions.MinimaExtension.Minima<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
 static MoreLinq.Extensions.MinimaExtension.Minima<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector, System.Collections.Generic.IComparer<TKey>? comparer) -> MoreLinq.IExtremaEnumerable<TSource>!
+static MoreLinq.Extensions.PairwiseExtension.Pairwise<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<(TSource, TSource)>!
+static MoreLinq.Extensions.TagFirstLastExtension.TagFirstLast<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<(TSource Item, bool IsFirst, bool IsLast)>!
+static MoreLinq.Extensions.ZipLongestExtension.ZipLongest<T1, T2, T3, T4>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth) -> System.Collections.Generic.IEnumerable<(T1, T2, T3, T4)>!
+static MoreLinq.Extensions.ZipLongestExtension.ZipLongest<T1, T2, T3>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third) -> System.Collections.Generic.IEnumerable<(T1, T2, T3)>!
+static MoreLinq.Extensions.ZipLongestExtension.ZipLongest<TFirst, TSecond>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second) -> System.Collections.Generic.IEnumerable<(TFirst, TSecond)>!
+static MoreLinq.Extensions.ZipShortestExtension.ZipShortest<T1, T2, T3, T4>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth) -> System.Collections.Generic.IEnumerable<(T1, T2, T3, T4)>!
+static MoreLinq.Extensions.ZipShortestExtension.ZipShortest<T1, T2, T3>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third) -> System.Collections.Generic.IEnumerable<(T1, T2, T3)>!
+static MoreLinq.Extensions.ZipShortestExtension.ZipShortest<TFirst, TSecond>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second) -> System.Collections.Generic.IEnumerable<(TFirst, TSecond)>!
 static MoreLinq.MoreEnumerable.Append<T>(System.Collections.Generic.IEnumerable<T>! head, T tail) -> System.Collections.Generic.IEnumerable<T>!
 static MoreLinq.MoreEnumerable.Batch<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, int size, System.Func<TSource[]!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
 static MoreLinq.MoreEnumerable.Batch<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int size) -> System.Collections.Generic.IEnumerable<TSource[]!>!
+static MoreLinq.MoreEnumerable.Cartesian<T1, T2, T3, T4, T5, T6, T7, T8>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth, System.Collections.Generic.IEnumerable<T6>! sixth, System.Collections.Generic.IEnumerable<T7>! seventh, System.Collections.Generic.IEnumerable<T8>! eighth) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second, T3 Third, T4 Fourth, T5 Fifth, T6 Sixth, T7 Seventh, T8 Eighth)>!
+static MoreLinq.MoreEnumerable.Cartesian<T1, T2, T3, T4, T5, T6, T7>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth, System.Collections.Generic.IEnumerable<T6>! sixth, System.Collections.Generic.IEnumerable<T7>! seventh) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second, T3 Third, T4 Fourth, T5 Fifth, T6 Sixth, T7 Seventh)>!
+static MoreLinq.MoreEnumerable.Cartesian<T1, T2, T3, T4, T5, T6>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth, System.Collections.Generic.IEnumerable<T6>! sixth) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second, T3 Third, T4 Fourth, T5 Fifth, T6 Sixth)>!
+static MoreLinq.MoreEnumerable.Cartesian<T1, T2, T3, T4, T5>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second, T3 Third, T4 Fourth, T5 Fifth)>!
+static MoreLinq.MoreEnumerable.Cartesian<T1, T2, T3, T4>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second, T3 Third, T4 Fourth)>!
+static MoreLinq.MoreEnumerable.Cartesian<T1, T2, T3>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second, T3 Third)>!
+static MoreLinq.MoreEnumerable.Cartesian<T1, T2>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second) -> System.Collections.Generic.IEnumerable<(T1 First, T2 Second)>!
+static MoreLinq.MoreEnumerable.CountDown<T>(this System.Collections.Generic.IEnumerable<T>! source, int count) -> System.Collections.Generic.IEnumerable<(T Item, int? CountDown)>!
+static MoreLinq.MoreEnumerable.EquiZip<T1, T2, T3, T4>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth) -> System.Collections.Generic.IEnumerable<(T1, T2, T3, T4)>!
+static MoreLinq.MoreEnumerable.EquiZip<T1, T2, T3>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third) -> System.Collections.Generic.IEnumerable<(T1, T2, T3)>!
+static MoreLinq.MoreEnumerable.EquiZip<T1, T2>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second) -> System.Collections.Generic.IEnumerable<(T1, T2)>!
+static MoreLinq.MoreEnumerable.Lag<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset) -> System.Collections.Generic.IEnumerable<(TSource Item, TSource OffsetItem)>!
+static MoreLinq.MoreEnumerable.Lag<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset, TSource defaultLagValue) -> System.Collections.Generic.IEnumerable<(TSource Item, TSource OffsetItem)>!
+static MoreLinq.MoreEnumerable.Lead<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset) -> System.Collections.Generic.IEnumerable<(TSource Item, TSource? OffsetItem)>!
+static MoreLinq.MoreEnumerable.Lead<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset, TSource defaultLeadValue) -> System.Collections.Generic.IEnumerable<(TSource Item, TSource OffsetItem)>!
 static MoreLinq.MoreEnumerable.Maxima<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
 static MoreLinq.MoreEnumerable.Maxima<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector, System.Collections.Generic.IComparer<TKey>? comparer) -> MoreLinq.IExtremaEnumerable<TSource>!
 static MoreLinq.MoreEnumerable.Minima<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
 static MoreLinq.MoreEnumerable.Minima<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector, System.Collections.Generic.IComparer<TKey>? comparer) -> MoreLinq.IExtremaEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.Pairwise<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<(TSource, TSource)>!
 static MoreLinq.MoreEnumerable.Prepend<TSource>(System.Collections.Generic.IEnumerable<TSource>! source, TSource value) -> System.Collections.Generic.IEnumerable<TSource>!
 static MoreLinq.MoreEnumerable.SkipLast<T>(System.Collections.Generic.IEnumerable<T>! source, int count) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.TagFirstLast<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<(TSource Item, bool IsFirst, bool IsLast)>!
 static MoreLinq.MoreEnumerable.TakeLast<TSource>(System.Collections.Generic.IEnumerable<TSource>! source, int count) -> System.Collections.Generic.IEnumerable<TSource>!
 static MoreLinq.MoreEnumerable.ToHashSet<TSource>(System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.HashSet<TSource>!
 static MoreLinq.MoreEnumerable.ToHashSet<TSource>(System.Collections.Generic.IEnumerable<TSource>! source, System.Collections.Generic.IEqualityComparer<TSource>? comparer) -> System.Collections.Generic.HashSet<TSource>!
+static MoreLinq.MoreEnumerable.ZipLongest<T1, T2, T3, T4>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth) -> System.Collections.Generic.IEnumerable<(T1, T2, T3, T4)>!
+static MoreLinq.MoreEnumerable.ZipLongest<T1, T2, T3>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third) -> System.Collections.Generic.IEnumerable<(T1, T2, T3)>!
+static MoreLinq.MoreEnumerable.ZipLongest<TFirst, TSecond>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second) -> System.Collections.Generic.IEnumerable<(TFirst, TSecond)>!
+static MoreLinq.MoreEnumerable.ZipShortest<T1, T2, T3, T4>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth) -> System.Collections.Generic.IEnumerable<(T1, T2, T3, T4)>!
+static MoreLinq.MoreEnumerable.ZipShortest<T1, T2, T3>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third) -> System.Collections.Generic.IEnumerable<(T1, T2, T3)>!
+static MoreLinq.MoreEnumerable.ZipShortest<TFirst, TSecond>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second) -> System.Collections.Generic.IEnumerable<(TFirst, TSecond)>!
diff --git a/MoreLinq/TagFirstLast.cs b/MoreLinq/TagFirstLast.cs
index 61d90f6e7..3e38f9477 100644
--- a/MoreLinq/TagFirstLast.cs
+++ b/MoreLinq/TagFirstLast.cs
@@ -78,5 +78,33 @@ public static IEnumerable<TResult> TagFirstLast<TSource, TResult>(this IEnumerab
                 }
             }
         }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where the N-th tuple contains the N-th
+        /// element of the source sequence and two booleans indicating whether the
+        /// element is the first and/or last.
+        /// </summary>
+        /// <typeparam name="TSource">The type of the elements of <paramref name="source"/>.</typeparam>
+        /// <param name="source">The source sequence.</param>
+        /// <returns>
+        /// Returns the resulting sequence.
+        /// </returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        /// <example>
+        /// <code><![CDATA[
+        /// var numbers = new[] { 123, 456, 789 };
+        /// var result = numbers.TagFirstLast();
+        /// ]]></code>
+        /// The <c>result</c> variable, when iterated over, will yield
+        /// <c>(123, True, False)</c>, <c>(456, False, False)</c> and
+        /// <c>(789, False, True)</c> in turn.
+        /// </example>
+
+        public static IEnumerable<(TSource Item, bool IsFirst, bool IsLast)> TagFirstLast<TSource>(this IEnumerable<TSource> source)
+        {
+            return TagFirstLast(source, ValueTuple.Create);
+        }
     }
 }
diff --git a/MoreLinq/ZipLongest.cs b/MoreLinq/ZipLongest.cs
index 38e5fdefc..d3d0485e6 100644
--- a/MoreLinq/ZipLongest.cs
+++ b/MoreLinq/ZipLongest.cs
@@ -179,5 +179,120 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, TResult>(
 
             return ZipImpl(first, second, third, fourth, resultSelector, 3);
         }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the argument sequences. The resulting sequence
+        /// will always be as long as the longest of input sequences where the
+        /// default value of each of the shorter sequence element types is used
+        /// for padding.
+        /// </summary>
+        /// <typeparam name="TFirst">Type of elements in first sequence.</typeparam>
+        /// <typeparam name="TSecond">Type of elements in second sequence.</typeparam>
+        /// <param name="first">The first sequence.</param>
+        /// <param name="second">The second sequence.</param>
+        /// <returns>
+        /// A sequence of tuples that contains elements of the two input sequences.
+        /// </returns>
+        /// <example>
+        /// <code><![CDATA[
+        /// var numbers = { 1, 2, 3 };
+        /// var letters = { "A", "B", "C", "D" };
+        /// var zipped = numbers.ZipLongest(letters);
+        /// ]]></code>
+        /// The <c>zipped</c> variable, when iterated over, will yield the tuples : (1, A),
+        /// (2, B), (3, C), (0, D) in turn.
+        /// </example>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+
+        public static IEnumerable<(TFirst, TSecond)> ZipLongest<TFirst, TSecond>(
+            this IEnumerable<TFirst> first,
+            IEnumerable<TSecond> second)
+        {
+            return first.ZipLongest(second, ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the argument sequences. The resulting sequence
+        /// will always be as long as the longest of input sequences where the
+        /// default value of each of the shorter sequence element types is used
+        /// for padding.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third sequence.</typeparam>
+        /// <param name="first">The first sequence.</param>
+        /// <param name="second">The second sequence.</param>
+        /// <param name="third">The third sequence.</param>
+        /// <returns>
+        /// A sequence of tuples that contains elements of the three input sequences.
+        /// </returns>
+        /// <example>
+        /// <code><![CDATA[
+        /// var numbers = new[] { 1, 2, 3 };
+        /// var letters = new[] { "A", "B", "C", "D" };
+        /// var chars   = new[] { 'a', 'b', 'c', 'd', 'e' };
+        /// var zipped  = numbers.ZipLongest(letters, chars);
+        /// ]]></code>
+        /// The <c>zipped</c> variable, when iterated over, will yield (1, "A", 'a'),
+        /// (2, "B", 'b'), (3, "C", 'c'), (0, "D", 'd'), (0, <see langword="null"/>, 'e') in turn.
+        /// </example>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+
+        public static IEnumerable<(T1, T2, T3)> ZipLongest<T1, T2, T3>(
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third)
+        {
+            return first.ZipLongest(second, third, ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the argument sequences. The resulting sequence
+        /// will always be as long as the longest of input sequences where the
+        /// default value of each of the shorter sequence element types is used
+        /// for padding.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first sequence</typeparam>
+        /// <typeparam name="T2">Type of elements in second sequence</typeparam>
+        /// <typeparam name="T3">Type of elements in third sequence</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth sequence</typeparam>
+        /// <param name="first">The first sequence.</param>
+        /// <param name="second">The second sequence.</param>
+        /// <param name="third">The third sequence.</param>
+        /// <param name="fourth">The fourth sequence.</param>
+        /// <returns>
+        /// A sequence of tuples that contains elements of the four input sequences.
+        /// </returns>
+        /// <example>
+        /// <code><![CDATA[
+        /// var numbers = new[] { 1, 2, 3 };
+        /// var letters = new[] { "A", "B", "C", "D" };
+        /// var chars   = new[] { 'a', 'b', 'c', 'd', 'e' };
+        /// var flags   = new[] { true, false, true, false, true, false };
+        /// var zipped  = numbers.ZipLongest(letters, chars, flags);
+        /// ]]></code>
+        /// The <c>zipped</c> variable, when iterated over, will yield (1, "A", 'a', <see langword="true"/>),
+        /// (2, "B", 'b', <see langword="false"/>), (3, "C", 'c', <see langword="true"/>), (0, "D", 'd', <see langword="false"/>),
+        /// (0, <see langword="null"/>, 'e', <see langword="true"/>), (0, <see langword="null"/>, '\0', <see langword="false"/>) in turn.
+        /// </example>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+
+        public static IEnumerable<(T1, T2, T3, T4)> ZipLongest<T1, T2, T3, T4>(
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth)
+        {
+            return first.ZipLongest(second, third, fourth, ValueTuple.Create);
+        }
     }
 }
diff --git a/MoreLinq/ZipShortest.cs b/MoreLinq/ZipShortest.cs
index fbb28d046..360104832 100644
--- a/MoreLinq/ZipShortest.cs
+++ b/MoreLinq/ZipShortest.cs
@@ -188,6 +188,132 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, TResult>(
             return ZipImpl(first, second, third, fourth, resultSelector);
         }
 
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the argument sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="TFirst">Type of elements in first sequence.</typeparam>
+        /// <typeparam name="TSecond">Type of elements in second sequence.</typeparam>
+        /// <param name="first">The first sequence.</param>
+        /// <param name="second">The second sequence.</param>
+        /// <returns>
+        /// A sequence of tuples that contains elements of the two input sequences.
+        /// </returns>
+        /// <example>
+        /// <code><![CDATA[
+        /// var numbers = new[] { 1, 2, 3 };
+        /// var letters = new[] { "A", "B", "C", "D" };
+        /// var zipped  = numbers.ZipShortest(letters);
+        /// ]]></code>
+        /// The <c>zipped</c> variable, when iterated over, will yield
+        /// (1, "A"), (2, "B"), (3, "C") in turn.
+        /// </example>
+        /// <remarks>
+        /// <para>
+        /// If the input sequences are of different lengths, the result sequence
+        /// is terminated as soon as the shortest input sequence is exhausted
+        /// and remainder elements from the longer sequences are never consumed.
+        /// </para>
+        /// <para>
+        /// This operator uses deferred execution and streams its results.</para>
+        /// </remarks>
+
+        public static IEnumerable<(TFirst, TSecond)> ZipShortest<TFirst, TSecond>(
+            this IEnumerable<TFirst> first,
+            IEnumerable<TSecond> second)
+        {
+            return first.ZipShortest(second, ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the argument sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third sequence.</typeparam>
+        /// <param name="first">First sequence</param>
+        /// <param name="second">Second sequence</param>
+        /// <param name="third">Third sequence</param>
+        /// <returns>
+        /// A sequence of tuples that contains elements of the three input sequences.
+        /// </returns>
+        /// <example>
+        /// <code><![CDATA[
+        /// var numbers = new[] { 1, 2, 3 };
+        /// var letters = new[] { "A", "B", "C", "D" };
+        /// var chars   = new[] { 'a', 'b', 'c', 'd', 'e' };
+        /// var zipped  = numbers.ZipShortest(letters, chars);
+        /// ]]></code>
+        /// The <c>zipped</c> variable, when iterated over, will yield
+        /// (1, "A", 'a'), (2, "B", 'b'), (3, "C", 'c') in turn.
+        /// </example>
+        /// <remarks>
+        /// <para>
+        /// If the input sequences are of different lengths, the result sequence
+        /// is terminated as soon as the shortest input sequence is exhausted
+        /// and remainder elements from the longer sequences are never consumed.
+        /// </para>
+        /// <para>
+        /// This operator uses deferred execution and streams its results.</para>
+        /// </remarks>
+
+        public static IEnumerable<(T1, T2, T3)> ZipShortest<T1, T2, T3>(
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third)
+        {
+            return first.ZipShortest(second, third, ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the argument sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth sequence.</typeparam>
+        /// <param name="first">The first sequence.</param>
+        /// <param name="second">The second sequence.</param>
+        /// <param name="third">The third sequence.</param>
+        /// <param name="fourth">The fourth sequence.</param>
+        /// <returns>
+        /// A sequence of tuples that contains elements of the four input sequences.
+        /// </returns>
+        /// <example>
+        /// <code><![CDATA[
+        /// var numbers = new[] { 1, 2, 3 };
+        /// var letters = new[] { "A", "B", "C", "D" };
+        /// var chars   = new[] { 'a', 'b', 'c', 'd', 'e' };
+        /// var flags   = new[] { true, false };
+        /// var zipped  = numbers.ZipShortest(letters, chars, flags);
+        /// ]]></code>
+        /// The <c>zipped</c> variable, when iterated over, will yield
+        /// (1, "A", 'a', <see langword="true"/>), (2, "B", 'b', <see langword="false"/>) in turn.
+        /// </example>
+        /// <remarks>
+        /// <para>
+        /// If the input sequences are of different lengths, the result sequence
+        /// is terminated as soon as the shortest input sequence is exhausted
+        /// and remainder elements from the longer sequences are never consumed.
+        /// </para>
+        /// <para>
+        /// This operator uses deferred execution and streams its results.</para>
+        /// </remarks>
+
+        public static IEnumerable<(T1, T2, T3, T4)> ZipShortest<T1, T2, T3, T4>(
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth)
+        {
+            return first.ZipShortest(second, third, fourth, ValueTuple.Create);
+        }
+
         static IEnumerable<TResult> ZipImpl<T1, T2, T3, T4, TResult>(
             IEnumerable<T1>  s1,
             IEnumerable<T2>  s2,
diff --git a/README.md b/README.md
index ac9da48de..83371caee 100644
--- a/README.md
+++ b/README.md
@@ -150,7 +150,7 @@ Returns the Cartesian product of two or more sequences by combining each
 element from the sequences and applying a user-defined projection to the
 set.
 
-This method has 7 overloads.
+This method has 14 overloads.
 
 ### Choose
 
@@ -198,6 +198,8 @@ Provides a countdown counter for a given count of elements at the tail of the
 sequence where zero always represents the last element, one represents the
 second-last element, two represents the third-last element and so on.
 
+This method has 2 overloads.
+
 ### DistinctBy
 
 Returns all distinct elements of the given source, where "distinctness" is
@@ -219,7 +221,7 @@ Returns a projection of tuples, where each tuple contains the N-th
 element from each of the argument sequences. An exception is thrown
 if the input sequences are of different lengths.
 
-This method has 3 overloads.
+This method has 6 overloads.
 
 ### Exactly
 
@@ -346,14 +348,14 @@ skipping sequences as they are consumed.
 Produces a projection of a sequence by evaluating pairs of elements separated
 by a negative offset.
 
-This method has 2 overloads.
+This method has 4 overloads.
 
 ### Lead
 
 Produces a projection of a sequence by evaluating pairs of elements separated
 by a positive offset.
 
-This method has 2 overloads.
+This method has 4 overloads.
 
 ### LeftJoin
 
@@ -433,6 +435,8 @@ Returns a sequence resulting from applying a function to each element in the
 source sequence and its predecessor, with the exception of the first element
 which is only returned as the predecessor of the second element
 
+This method has 2 overloads.
+
 ### PartialSort
 
 Combines `OrderBy` (where element is key) and `Take` in a single operation.
@@ -612,6 +616,8 @@ Returns a sequence resulting from applying a function to each element in the
 source sequence with additional parameters indicating whether the element is
 the first and/or last of the sequence
 
+This method has 2 overloads.
+
 ### TakeEvery
 
 Returns every N-th element of a source sequence
@@ -729,7 +735,7 @@ will always be as long as the longest of input sequences where the
 default value of each of the shorter sequence element types is used
 for padding.
 
-This method has 3 overloads.
+This method has 6 overloads.
 
 ### ZipShortest
 
@@ -737,7 +743,7 @@ Returns a projection of tuples, where each tuple contains the N-th
 element from each of the argument sequences. The resulting sequence
 is as short as the shortest input sequence.
 
-This method has 3 overloads.
+This method has 6 overloads.
 
 
 ## Experimental Operators