From 56a5bfadbd67c4e31ef45e1336adb8c4747e069b Mon Sep 17 00:00:00 2001
From: Orace <pierre.lando@gmail.com>
Date: Mon, 4 Nov 2019 17:57:43 +0100
Subject: [PATCH 01/11] Zip refactoring. - introduce CustomZip with separate
 behavior by source - use CustomZip for EquiZip, ZipLongest and ZipShortest -
 add ValueTuple overloads - use t4 file to have up to 8 input sequences.

---
 MoreLinq/EquiZip.cs      |  213 ---
 MoreLinq/Extensions.g.cs | 1611 +++++++++++++++++++----
 MoreLinq/MoreLinq.csproj |    9 +
 MoreLinq/Zip.g.cs        | 2660 ++++++++++++++++++++++++++++++++++++++
 MoreLinq/Zip.g.tt        |  458 +++++++
 MoreLinq/ZipImpl.cs      |   97 --
 MoreLinq/ZipLongest.cs   |  169 ---
 MoreLinq/ZipShortest.cs  |  185 ---
 README.md                |    6 +-
 9 files changed, 4496 insertions(+), 912 deletions(-)
 delete mode 100644 MoreLinq/EquiZip.cs
 create mode 100644 MoreLinq/Zip.g.cs
 create mode 100644 MoreLinq/Zip.g.tt
 delete mode 100644 MoreLinq/ZipImpl.cs
 delete mode 100644 MoreLinq/ZipLongest.cs
 delete mode 100644 MoreLinq/ZipShortest.cs

diff --git a/MoreLinq/EquiZip.cs b/MoreLinq/EquiZip.cs
deleted file mode 100644
index edede6ef1..000000000
--- a/MoreLinq/EquiZip.cs
+++ /dev/null
@@ -1,213 +0,0 @@
-#region License and Terms
-// MoreLINQ - Extensions to LINQ to Objects
-// Copyright (c) 2008 Jonathan Skeet. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-#endregion
-
-namespace MoreLinq
-{
-    using System;
-    using System.Collections.Generic;
-    using System.Diagnostics;
-    using System.Linq;
-
-    static partial class MoreEnumerable
-    {
-        /// <summary>
-        /// 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.
-        /// </summary>
-        /// <typeparam name="TFirst">Type of elements in first sequence.</typeparam>
-        /// <typeparam name="TSecond">Type of elements in second sequence.</typeparam>
-        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="first">The first sequence.</param>
-        /// <param name="second">The second sequence.</param>
-        /// <param name="resultSelector">
-        /// Function to apply to each pair of elements.</param>
-        /// <returns>
-        /// A sequence that contains elements of the two input sequences,
-        /// combined by <paramref name="resultSelector"/>.
-        /// </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, (n, l) => n + l);
-        /// ]]></code>
-        /// The <c>zipped</c> variable, when iterated over, will yield "1A",
-        /// "2B", "3C", "4D" in turn.
-        /// </example>
-        /// <remarks>
-        /// This operator uses deferred execution and streams its results.
-        /// </remarks>
-
-        public static IEnumerable<TResult> EquiZip<TFirst, TSecond, TResult>(
-            this IEnumerable<TFirst> first,
-            IEnumerable<TSecond> second,
-            Func<TFirst, TSecond, TResult> resultSelector)
-        {
-            if (first == null) throw new ArgumentNullException(nameof(first));
-            if (second == null) throw new ArgumentNullException(nameof(second));
-            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
-
-            return EquiZipImpl<TFirst, TSecond, object, object, TResult>(first, second, null, null, (a, b, c, d) => resultSelector(a, b));
-        }
-
-        /// <summary>
-        /// 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.
-        /// </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="TResult">Type of elements in result 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="resultSelector">
-        /// Function to apply to each triplet of elements.</param>
-        /// <returns>
-        /// A sequence that contains elements of the three input sequences,
-        /// combined by <paramref name="resultSelector"/>.
-        /// </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, (n, l, c) => n + l + c);
-        /// ]]></code>
-        /// The <c>zipped</c> variable, when iterated over, will yield "1Aa",
-        /// "2Bb", "3Cc", "4Dd" in turn.
-        /// </example>
-        /// <remarks>
-        /// This operator uses deferred execution and streams its results.
-        /// </remarks>
-
-        public static IEnumerable<TResult> EquiZip<T1, T2, T3, TResult>(
-            this IEnumerable<T1> first,
-            IEnumerable<T2> second, IEnumerable<T3> third,
-            Func<T1, T2, T3, TResult> resultSelector)
-        {
-            if (first == null) throw new ArgumentNullException(nameof(first));
-            if (second == null) throw new ArgumentNullException(nameof(second));
-            if (third == null) throw new ArgumentNullException(nameof(third));
-            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
-
-            return EquiZipImpl<T1, T2, T3, object, TResult>(first, second, third, null, (a, b, c, _) => resultSelector(a, b, c));
-        }
-
-        /// <summary>
-        /// 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.
-        /// </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>
-        /// <typeparam name="TResult">Type of elements in result 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>
-        /// <param name="resultSelector">
-        /// Function to apply to each quadruplet of elements.</param>
-        /// <returns>
-        /// A sequence that contains elements of the four input sequences,
-        /// combined by <paramref name="resultSelector"/>.
-        /// </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, (n, l, c, f) => n + l + c + f);
-        /// ]]></code>
-        /// The <c>zipped</c> variable, when iterated over, will yield "1AaTrue",
-        /// "2BbFalse", "3CcTrue", "4DdFalse" in turn.
-        /// </example>
-        /// <remarks>
-        /// This operator uses deferred execution and streams its results.
-        /// </remarks>
-
-        public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, TResult>(
-            this IEnumerable<T1> first,
-            IEnumerable<T2> second, IEnumerable<T3> third, IEnumerable<T4> fourth,
-            Func<T1, T2, T3, T4, TResult> resultSelector)
-        {
-            if (first == null) throw new ArgumentNullException(nameof(first));
-            if (second == null) throw new ArgumentNullException(nameof(second));
-            if (third == null) throw new ArgumentNullException(nameof(third));
-            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
-            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
-
-            return EquiZipImpl(first, second, third, fourth, resultSelector);
-        }
-
-        static IEnumerable<TResult> EquiZipImpl<T1, T2, T3, T4, TResult>(
-            IEnumerable<T1> s1,
-            IEnumerable<T2> s2,
-            IEnumerable<T3> s3,
-            IEnumerable<T4> s4,
-            Func<T1, T2, T3, T4, TResult> resultSelector)
-        {
-            Debug.Assert(s1 != null);
-            Debug.Assert(s2 != null);
-
-            const int zero = 0, one = 1;
-
-            var limit = 1 + (s3 != null ? one : zero)
-                          + (s4 != null ? one : zero);
-
-            return ZipImpl(s1, s2, s3, s4, resultSelector, limit, enumerators =>
-            {
-                var i = enumerators.Index().First(x => x.Value == null).Key;
-                return new InvalidOperationException(OrdinalNumbers[i] + " sequence too short.");
-            });
-        }
-
-        static readonly string[] OrdinalNumbers =
-        {
-            "First",
-            "Second",
-            "Third",
-            "Fourth",
-            // "Fifth",
-            // "Sixth",
-            // "Seventh",
-            // "Eighth",
-            // "Ninth",
-            // "Tenth",
-            // "Eleventh",
-            // "Twelfth",
-            // "Thirteenth",
-            // "Fourteenth",
-            // "Fifteenth",
-            // "Sixteenth",
-        };
-    }
-}
diff --git a/MoreLinq/Extensions.g.cs b/MoreLinq/Extensions.g.cs
index 9c0485718..acd6a1d69 100644
--- a/MoreLinq/Extensions.g.cs
+++ b/MoreLinq/Extensions.g.cs
@@ -650,7 +650,21 @@ public static partial class BatchExtension
         /// <param name="size">Size of buckets.</param>
         /// <returns>A sequence of equally sized buckets containing elements of the source collection.</returns>
         /// <remarks>
-        /// This operator uses deferred execution and streams its results (buckets and bucket content).
+        /// <para>
+        /// This operator uses deferred execution and streams its results
+        /// (buckets are streamed but their content buffered).</para>
+        /// <para>
+        /// When more than one bucket is streamed, all buckets except the last
+        /// is guaranteed to have <paramref name="size"/> elements. The last
+        /// bucket may be smaller depending on the remaining elements in the
+        /// <paramref name="source"/> sequence.</para>
+        /// <para>
+        /// Each bucket is pre-allocated to <paramref name="size"/> elements.
+        /// If <paramref name="size"/> is set to a very large value, e.g.
+        /// <see cref="int.MaxValue"/> to effectively disable batching by just
+        /// hoping for a single bucket, then it can lead to memory exhaustion
+        /// (<see cref="OutOfMemoryException"/>).
+        /// </para>
         /// </remarks>
 
         public static IEnumerable<IEnumerable<TSource>> Batch<TSource>(this IEnumerable<TSource> source, int size)
@@ -665,9 +679,21 @@ public static IEnumerable<IEnumerable<TSource>> Batch<TSource>(this IEnumerable<
         /// <param name="size">Size of buckets.</param>
         /// <param name="resultSelector">The projection to apply to each bucket.</param>
         /// <returns>A sequence of projections on equally sized buckets containing elements of the source collection.</returns>
-        /// <remarks>
-        /// This operator uses deferred execution and streams its results (buckets and bucket content).
-        /// </remarks>
+        /// <para>
+        /// This operator uses deferred execution and streams its results
+        /// (buckets are streamed but their content buffered).</para>
+        /// <para>
+        /// <para>
+        /// When more than one bucket is streamed, all buckets except the last
+        /// is guaranteed to have <paramref name="size"/> elements. The last
+        /// bucket may be smaller depending on the remaining elements in the
+        /// <paramref name="source"/> sequence.</para>
+        /// Each bucket is pre-allocated to <paramref name="size"/> elements.
+        /// If <paramref name="size"/> is set to a very large value, e.g.
+        /// <see cref="int.MaxValue"/> to effectively disable batching by just
+        /// hoping for a single bucket, then it can lead to memory exhaustion
+        /// (<see cref="OutOfMemoryException"/>).
+        /// </para>
 
         public static IEnumerable<TResult> Batch<TSource, TResult>(this IEnumerable<TSource> source, int size,
             Func<IEnumerable<TSource>, TResult> resultSelector)
@@ -1298,128 +1324,481 @@ 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 a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<(T1, T2)> EquiZip<T1, T2>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource)
+            => MoreEnumerable.EquiZip(firstSource, secondSource);
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<(T1, T2, T3)> EquiZip<T1, T2, T3>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource)
+            => MoreEnumerable.EquiZip(firstSource, secondSource, thirdSource);
         /// <summary>
         /// Returns a projection of tuples, where each tuple contains the N-th
-        /// element from each of the argument sequences. An exception is thrown
+        /// element from each of the input sequences. An exception is thrown
         /// if the input sequences are of different lengths.
         /// </summary>
-        /// <typeparam name="TFirst">Type of elements in first sequence.</typeparam>
-        /// <typeparam name="TSecond">Type of elements in second sequence.</typeparam>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="first">The first sequence.</param>
-        /// <param name="second">The second sequence.</param>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
         /// <param name="resultSelector">
-        /// Function to apply to each pair of elements.</param>
+        /// Function to apply to each tuple of elements.</param>
         /// <returns>
-        /// A sequence that contains elements of the two input sequences,
-        /// combined by <paramref name="resultSelector"/>.
-        /// </returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument 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, (n, l) => n + l);
-        /// ]]></code>
-        /// The <c>zipped</c> variable, when iterated over, will yield "1A",
-        /// "2B", "3C", "4D" in turn.
-        /// </example>
         /// <remarks>
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
+        public static IEnumerable<TResult> EquiZip<T1, T2, TResult>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            Func<T1, T2, TResult> resultSelector)
+            => MoreEnumerable.EquiZip(firstSource, secondSource, resultSelector);
 
-        public static IEnumerable<TResult> EquiZip<TFirst, TSecond, TResult>(
-            this IEnumerable<TFirst> first,
-            IEnumerable<TSecond> second,
-            Func<TFirst, TSecond, TResult> resultSelector)
-            => MoreEnumerable.EquiZip(first, second, resultSelector);
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <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> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource)
+            => MoreEnumerable.EquiZip(firstSource, secondSource, thirdSource, fourthSource);
 
         /// <summary>
         /// Returns a projection of tuples, where each tuple contains the N-th
-        /// element from each of the argument sequences. An exception is thrown
+        /// element from each of the input 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="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result 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="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
         /// <param name="resultSelector">
-        /// Function to apply to each triplet of elements.</param>
+        /// Function to apply to each tuple of elements.</param>
         /// <returns>
-        /// A sequence that contains elements of the three input sequences,
-        /// combined by <paramref name="resultSelector"/>.
-        /// </returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument 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, (n, l, c) => n + l + c);
-        /// ]]></code>
-        /// The <c>zipped</c> variable, when iterated over, will yield "1Aa",
-        /// "2Bb", "3Cc", "4Dd" in turn.
-        /// </example>
         /// <remarks>
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
-
         public static IEnumerable<TResult> EquiZip<T1, T2, T3, TResult>(
-            this IEnumerable<T1> first,
-            IEnumerable<T2> second, IEnumerable<T3> third,
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
             Func<T1, T2, T3, TResult> resultSelector)
-            => MoreEnumerable.EquiZip(first, second, third, resultSelector);
+            => MoreEnumerable.EquiZip(firstSource, secondSource, thirdSource, resultSelector);
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<(T1, T2, T3, T4, T5)> EquiZip<T1, T2, T3, T4, T5>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource)
+            => MoreEnumerable.EquiZip(firstSource, secondSource, thirdSource, fourthSource, fifthSource);
 
         /// <summary>
         /// Returns a projection of tuples, where each tuple contains the N-th
-        /// element from each of the argument sequences. An exception is thrown
+        /// element from each of the input 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>
-        /// <typeparam name="TResult">Type of elements in result 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>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
         /// <param name="resultSelector">
-        /// Function to apply to each quadruplet of elements.</param>
+        /// Function to apply to each tuple of elements.</param>
         /// <returns>
-        /// A sequence that contains elements of the four input sequences,
-        /// combined by <paramref name="resultSelector"/>.
-        /// </returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument 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, (n, l, c, f) => n + l + c + f);
-        /// ]]></code>
-        /// The <c>zipped</c> variable, when iterated over, will yield "1AaTrue",
-        /// "2BbFalse", "3CcTrue", "4DdFalse" in turn.
-        /// </example>
         /// <remarks>
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
-
         public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, TResult>(
-            this IEnumerable<T1> first,
-            IEnumerable<T2> second, IEnumerable<T3> third, IEnumerable<T4> fourth,
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
             Func<T1, T2, T3, T4, TResult> resultSelector)
-            => MoreEnumerable.EquiZip(first, second, third, fourth, resultSelector);
+            => MoreEnumerable.EquiZip(firstSource, secondSource, thirdSource, fourthSource, resultSelector);
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<(T1, T2, T3, T4, T5, T6)> EquiZip<T1, T2, T3, T4, T5, T6>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            IEnumerable<T6> sixthSource)
+            => MoreEnumerable.EquiZip(firstSource, secondSource, thirdSource, fourthSource, fifthSource, sixthSource);
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, TResult>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            Func<T1, T2, T3, T4, T5, TResult> resultSelector)
+            => MoreEnumerable.EquiZip(firstSource, secondSource, thirdSource, fourthSource, fifthSource, resultSelector);
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="seventhSource">The seventh source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<(T1, T2, T3, T4, T5, T6, T7)> EquiZip<T1, T2, T3, T4, T5, T6, T7>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            IEnumerable<T6> sixthSource,
+            IEnumerable<T7> seventhSource)
+            => MoreEnumerable.EquiZip(firstSource, secondSource, thirdSource, fourthSource, fifthSource, sixthSource, seventhSource);
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, TResult>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            IEnumerable<T6> sixthSource,
+            Func<T1, T2, T3, T4, T5, T6, TResult> resultSelector)
+            => MoreEnumerable.EquiZip(firstSource, secondSource, thirdSource, fourthSource, fifthSource, sixthSource, resultSelector);
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
+        /// <typeparam name="T8">Type of elements in eighth input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="seventhSource">The seventh source sequence.</param>
+        /// <param name="eighthSource">The eighth source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<(T1, T2, T3, T4, T5, T6, T7, T8)> EquiZip<T1, T2, T3, T4, T5, T6, T7, T8>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            IEnumerable<T6> sixthSource,
+            IEnumerable<T7> seventhSource,
+            IEnumerable<T8> eighthSource)
+            => MoreEnumerable.EquiZip(firstSource, secondSource, thirdSource, fourthSource, fifthSource, sixthSource, seventhSource, eighthSource);
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="seventhSource">The seventh source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, T7, TResult>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            IEnumerable<T6> sixthSource,
+            IEnumerable<T7> seventhSource,
+            Func<T1, T2, T3, T4, T5, T6, T7, TResult> resultSelector)
+            => MoreEnumerable.EquiZip(firstSource, secondSource, thirdSource, fourthSource, fifthSource, sixthSource, seventhSource, resultSelector);
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
+        /// <typeparam name="T8">Type of elements in eighth input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="seventhSource">The seventh source sequence.</param>
+        /// <param name="eighthSource">The eighth source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            IEnumerable<T6> sixthSource,
+            IEnumerable<T7> seventhSource,
+            IEnumerable<T8> eighthSource,
+            Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> resultSelector)
+            => MoreEnumerable.EquiZip(firstSource, secondSource, thirdSource, fourthSource, fifthSource, sixthSource, seventhSource, eighthSource, resultSelector);
 
     }
 
@@ -6761,159 +7140,489 @@ public static IEnumerable<IList<TSource>> WindowRight<TSource>(this IEnumerable<
     [GeneratedCode("MoreLinq.ExtensionsGenerator", "1.0.0.0")]
     public static partial class ZipLongestExtension
     {
+
         /// <summary>
-        /// Returns a projection of tuples, where each tuple contains the N-th
-        /// element from each of the argument sequences. The resulting sequence
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input 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>
-        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="first">The first sequence.</param>
-        /// <param name="second">The second sequence.</param>
-        /// <param name="resultSelector">
-        /// Function to apply to each pair of elements.</param>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
         /// <returns>
-        /// A sequence that contains elements of the two input sequences,
-        /// combined by <paramref name="resultSelector"/>.
-        /// </returns>
-        /// <example>
-        /// <code><![CDATA[
-        /// var numbers = { 1, 2, 3 };
-        /// var letters = { "A", "B", "C", "D" };
-        /// var zipped = numbers.ZipLongest(letters, (n, l) => n + l);
-        /// ]]></code>
-        /// The <c>zipped</c> variable, when iterated over, will yield "1A",
-        /// "2B", "3C", "0D" in turn.
-        /// </example>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
         /// <remarks>
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
+        public static IEnumerable<(T1, T2)> ZipLongest<T1, T2>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource)
+            => MoreEnumerable.ZipLongest(firstSource, secondSource);
 
-        public static IEnumerable<TResult> ZipLongest<TFirst, TSecond, TResult>(
-            this IEnumerable<TFirst> first,
-            IEnumerable<TSecond> second,
-            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 input 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 input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<(T1, T2, T3)> ZipLongest<T1, T2, T3>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource)
+            => MoreEnumerable.ZipLongest(firstSource, secondSource, thirdSource);
 
         /// <summary>
         /// Returns a projection of tuples, where each tuple contains the N-th
-        /// element from each of the argument sequences. The resulting sequence
+        /// element from each of the input 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="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result 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="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
         /// <param name="resultSelector">
-        /// Function to apply to each triplet of elements.</param>
+        /// Function to apply to each tuple of elements.</param>
         /// <returns>
-        /// A sequence that contains elements of the three input sequences,
-        /// combined by <paramref name="resultSelector"/>.
-        /// </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, (n, l, c) => n + l + c);
-        /// ]]></code>
-        /// The <c>zipped</c> variable, when iterated over, will yield "1Aa",
-        /// "2Bb", "3Cc", "0Dd", "0e" in turn.
-        /// </example>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
         /// <remarks>
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
-
-        public static IEnumerable<TResult> ZipLongest<T1, T2, T3, TResult>(
-            this IEnumerable<T1> first,
-            IEnumerable<T2> second,
-            IEnumerable<T3> third,
-            Func<T1, T2, T3, TResult> resultSelector)
-            => MoreEnumerable.ZipLongest(first, second, third, resultSelector);
+        public static IEnumerable<TResult> ZipLongest<T1, T2, TResult>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            Func<T1, T2, TResult> resultSelector)
+            => MoreEnumerable.ZipLongest(firstSource, secondSource, resultSelector);
 
         /// <summary>
-        /// Returns a projection of tuples, where each tuple contains the N-th
-        /// element from each of the argument sequences. The resulting sequence
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input 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>
-        /// <typeparam name="TResult">Type of elements in result 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>
-        /// <param name="resultSelector">
-        /// Function to apply to each quadruplet of elements.</param>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
         /// <returns>
-        /// A sequence that contains elements of the four input sequences,
-        /// combined by <paramref name="resultSelector"/>.
-        /// </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, (n, l, c, f) => n + l + c + f);
-        /// ]]></code>
-        /// The <c>zipped</c> variable, when iterated over, will yield "1AaTrue",
-        /// "2BbFalse", "3CcTrue", "0DdFalse", "0eTrue", "0\0False" in turn.
-        /// </example>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
         /// <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> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource)
+            => MoreEnumerable.ZipLongest(firstSource, secondSource, thirdSource, fourthSource);
 
-        public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, TResult>(
-            this IEnumerable<T1> first,
-            IEnumerable<T2> second,
-            IEnumerable<T3> third,
-            IEnumerable<T4> fourth,
-            Func<T1, T2, T3, T4, TResult> resultSelector)
-            => MoreEnumerable.ZipLongest(first, second, third, fourth, resultSelector);
-
-    }
-
-    /// <summary><c>ZipShortest</c> extension.</summary>
-
-    [GeneratedCode("MoreLinq.ExtensionsGenerator", "1.0.0.0")]
-    public static partial class ZipShortestExtension
-    {
         /// <summary>
         /// 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.
+        /// element from each of the input 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>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="first">The first sequence.</param>
-        /// <param name="second">The second sequence.</param>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
         /// <param name="resultSelector">
-        /// Function to apply to each pair of elements.</param>
+        /// Function to apply to each tuple of elements.</param>
         /// <returns>
         /// A projection of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
-        /// <example>
-        /// <code><![CDATA[
-        /// var numbers = new[] { 1, 2, 3 };
-        /// var letters = new[] { "A", "B", "C", "D" };
-        /// var zipped = numbers.ZipShortest(letters, (n, l) => n + l);
-        /// ]]></code>
-        /// The <c>zipped</c> variable, when iterated over, will yield "1A", "2B", "3C", in turn.
-        /// </example>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<TResult> ZipLongest<T1, T2, T3, TResult>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            Func<T1, T2, T3, TResult> resultSelector)
+            => MoreEnumerable.ZipLongest(firstSource, secondSource, thirdSource, resultSelector);
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input 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 input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<(T1, T2, T3, T4, T5)> ZipLongest<T1, T2, T3, T4, T5>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource)
+            => MoreEnumerable.ZipLongest(firstSource, secondSource, thirdSource, fourthSource, fifthSource);
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input 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 input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, TResult>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            Func<T1, T2, T3, T4, TResult> resultSelector)
+            => MoreEnumerable.ZipLongest(firstSource, secondSource, thirdSource, fourthSource, resultSelector);
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input 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 input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<(T1, T2, T3, T4, T5, T6)> ZipLongest<T1, T2, T3, T4, T5, T6>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            IEnumerable<T6> sixthSource)
+            => MoreEnumerable.ZipLongest(firstSource, secondSource, thirdSource, fourthSource, fifthSource, sixthSource);
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input 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 input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, TResult>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            Func<T1, T2, T3, T4, T5, TResult> resultSelector)
+            => MoreEnumerable.ZipLongest(firstSource, secondSource, thirdSource, fourthSource, fifthSource, resultSelector);
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input 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 input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="seventhSource">The seventh source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<(T1, T2, T3, T4, T5, T6, T7)> ZipLongest<T1, T2, T3, T4, T5, T6, T7>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            IEnumerable<T6> sixthSource,
+            IEnumerable<T7> seventhSource)
+            => MoreEnumerable.ZipLongest(firstSource, secondSource, thirdSource, fourthSource, fifthSource, sixthSource, seventhSource);
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input 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 input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, TResult>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            IEnumerable<T6> sixthSource,
+            Func<T1, T2, T3, T4, T5, T6, TResult> resultSelector)
+            => MoreEnumerable.ZipLongest(firstSource, secondSource, thirdSource, fourthSource, fifthSource, sixthSource, resultSelector);
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input 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 input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
+        /// <typeparam name="T8">Type of elements in eighth input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="seventhSource">The seventh source sequence.</param>
+        /// <param name="eighthSource">The eighth source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<(T1, T2, T3, T4, T5, T6, T7, T8)> ZipLongest<T1, T2, T3, T4, T5, T6, T7, T8>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            IEnumerable<T6> sixthSource,
+            IEnumerable<T7> seventhSource,
+            IEnumerable<T8> eighthSource)
+            => MoreEnumerable.ZipLongest(firstSource, secondSource, thirdSource, fourthSource, fifthSource, sixthSource, seventhSource, eighthSource);
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input 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 input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="seventhSource">The seventh source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, T7, TResult>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            IEnumerable<T6> sixthSource,
+            IEnumerable<T7> seventhSource,
+            Func<T1, T2, T3, T4, T5, T6, T7, TResult> resultSelector)
+            => MoreEnumerable.ZipLongest(firstSource, secondSource, thirdSource, fourthSource, fifthSource, sixthSource, seventhSource, resultSelector);
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input 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 input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
+        /// <typeparam name="T8">Type of elements in eighth input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="seventhSource">The seventh source sequence.</param>
+        /// <param name="eighthSource">The eighth source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            IEnumerable<T6> sixthSource,
+            IEnumerable<T7> seventhSource,
+            IEnumerable<T8> eighthSource,
+            Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> resultSelector)
+            => MoreEnumerable.ZipLongest(firstSource, secondSource, thirdSource, fourthSource, fifthSource, sixthSource, seventhSource, eighthSource, resultSelector);
+
+    }
+
+    /// <summary><c>ZipShortest</c> extension.</summary>
+
+    [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 input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
         /// <remarks>
         /// <para>
         /// If the input sequences are of different lengths, the result sequence
@@ -6924,39 +7633,122 @@ public static partial class ZipShortestExtension
         /// This operator uses deferred execution and streams its results.</para>
         /// </remarks>
 
-        public static IEnumerable<TResult> ZipShortest<TFirst, TSecond, TResult>(
-            this IEnumerable<TFirst> first,
-            IEnumerable<TSecond> second,
-            Func<TFirst, TSecond, TResult> resultSelector)
-            => MoreEnumerable.ZipShortest(first, second, resultSelector);
+        public static IEnumerable<(T1, T2)> ZipShortest<T1, T2>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource)
+            => MoreEnumerable.ZipShortest(firstSource, secondSource);
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource)
+            => MoreEnumerable.ZipShortest(firstSource, secondSource, thirdSource);
 
         /// <summary>
         /// Returns a projection of tuples, where each tuple contains the N-th
-        /// element from each of the argument sequences. The resulting sequence
+        /// element from each of the input 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="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="first">First sequence</param>
-        /// <param name="second">Second sequence</param>
-        /// <param name="third">Third sequence</param>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
         /// <param name="resultSelector">
-        /// Function to apply to each triplet of elements.</param>
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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<TResult> ZipShortest<T1, T2, TResult>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            Func<T1, T2, TResult> resultSelector)
+            => MoreEnumerable.ZipShortest(firstSource, secondSource, resultSelector);
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource)
+            => MoreEnumerable.ZipShortest(firstSource, secondSource, thirdSource, fourthSource);
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
         /// <returns>
         /// A projection of tuples, where each tuple contains the N-th element
         /// from each of the argument 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, (n, l, c) => c + n + l);
-        /// ]]></code>
-        /// The <c>zipped</c> variable, when iterated over, will yield
-        /// "98A", "100B", "102C", in turn.
-        /// </example>
         /// <remarks>
         /// <para>
         /// If the input sequences are of different lengths, the result sequence
@@ -6968,42 +7760,67 @@ public static IEnumerable<TResult> ZipShortest<TFirst, TSecond, TResult>(
         /// </remarks>
 
         public static IEnumerable<TResult> ZipShortest<T1, T2, T3, TResult>(
-            this IEnumerable<T1> first,
-            IEnumerable<T2> second,
-            IEnumerable<T3> third,
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
             Func<T1, T2, T3, TResult> resultSelector)
-            => MoreEnumerable.ZipShortest(first, second, third, resultSelector);
+            => MoreEnumerable.ZipShortest(firstSource, secondSource, thirdSource, resultSelector);
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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, T5)> ZipShortest<T1, T2, T3, T4, T5>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource)
+            => MoreEnumerable.ZipShortest(firstSource, secondSource, thirdSource, fourthSource, fifthSource);
 
         /// <summary>
         /// Returns a projection of tuples, where each tuple contains the N-th
-        /// element from each of the argument sequences. The resulting sequence
+        /// element from each of the input 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>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result 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>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
         /// <param name="resultSelector">
-        /// Function to apply to each quadruplet of elements.</param>
+        /// Function to apply to each tuple of elements.</param>
         /// <returns>
         /// A projection of tuples, where each tuple contains the N-th element
         /// from each of the argument 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, (n, l, c, f) => n + l + c + f);
-        /// ]]></code>
-        /// The <c>zipped</c> variable, when iterated over, will yield
-        /// "1AaTrue", "2BbFalse" in turn.
-        /// </example>
         /// <remarks>
         /// <para>
         /// If the input sequences are of different lengths, the result sequence
@@ -7015,12 +7832,316 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, TResult>(
         /// </remarks>
 
         public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, TResult>(
-            this IEnumerable<T1> first,
-            IEnumerable<T2> second,
-            IEnumerable<T3> third,
-            IEnumerable<T4> fourth,
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
             Func<T1, T2, T3, T4, TResult> resultSelector)
-            => MoreEnumerable.ZipShortest(first, second, third, fourth, resultSelector);
+            => MoreEnumerable.ZipShortest(firstSource, secondSource, thirdSource, fourthSource, resultSelector);
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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, T5, T6)> ZipShortest<T1, T2, T3, T4, T5, T6>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            IEnumerable<T6> sixthSource)
+            => MoreEnumerable.ZipShortest(firstSource, secondSource, thirdSource, fourthSource, fifthSource, sixthSource);
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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<TResult> ZipShortest<T1, T2, T3, T4, T5, TResult>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            Func<T1, T2, T3, T4, T5, TResult> resultSelector)
+            => MoreEnumerable.ZipShortest(firstSource, secondSource, thirdSource, fourthSource, fifthSource, resultSelector);
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="seventhSource">The seventh source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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, T5, T6, T7)> ZipShortest<T1, T2, T3, T4, T5, T6, T7>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            IEnumerable<T6> sixthSource,
+            IEnumerable<T7> seventhSource)
+            => MoreEnumerable.ZipShortest(firstSource, secondSource, thirdSource, fourthSource, fifthSource, sixthSource, seventhSource);
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, TResult>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            IEnumerable<T6> sixthSource,
+            Func<T1, T2, T3, T4, T5, T6, TResult> resultSelector)
+            => MoreEnumerable.ZipShortest(firstSource, secondSource, thirdSource, fourthSource, fifthSource, sixthSource, resultSelector);
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
+        /// <typeparam name="T8">Type of elements in eighth input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="seventhSource">The seventh source sequence.</param>
+        /// <param name="eighthSource">The eighth source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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, T5, T6, T7, T8)> ZipShortest<T1, T2, T3, T4, T5, T6, T7, T8>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            IEnumerable<T6> sixthSource,
+            IEnumerable<T7> seventhSource,
+            IEnumerable<T8> eighthSource)
+            => MoreEnumerable.ZipShortest(firstSource, secondSource, thirdSource, fourthSource, fifthSource, sixthSource, seventhSource, eighthSource);
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="seventhSource">The seventh source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, T7, TResult>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            IEnumerable<T6> sixthSource,
+            IEnumerable<T7> seventhSource,
+            Func<T1, T2, T3, T4, T5, T6, T7, TResult> resultSelector)
+            => MoreEnumerable.ZipShortest(firstSource, secondSource, thirdSource, fourthSource, fifthSource, sixthSource, seventhSource, resultSelector);
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
+        /// <typeparam name="T8">Type of elements in eighth input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="seventhSource">The seventh source sequence.</param>
+        /// <param name="eighthSource">The eighth source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            IEnumerable<T6> sixthSource,
+            IEnumerable<T7> seventhSource,
+            IEnumerable<T8> eighthSource,
+            Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> resultSelector)
+            => MoreEnumerable.ZipShortest(firstSource, secondSource, thirdSource, fourthSource, fifthSource, sixthSource, seventhSource, eighthSource, resultSelector);
 
     }
 }
diff --git a/MoreLinq/MoreLinq.csproj b/MoreLinq/MoreLinq.csproj
index 551c30fc1..db2b6cc08 100644
--- a/MoreLinq/MoreLinq.csproj
+++ b/MoreLinq/MoreLinq.csproj
@@ -171,6 +171,10 @@
       <Generator>TextTemplatingFileGenerator</Generator>
       <LastGenOutput>ToDelimitedString.g.cs</LastGenOutput>
     </None>
+    <None Update="Zip.g.tt">
+      <Generator>TextTemplatingFileGenerator</Generator>
+      <LastGenOutput>Zip.g.cs</LastGenOutput>
+    </None>
   </ItemGroup>
 
   <ItemGroup Condition=" '$(TargetFramework)' == 'net451' ">
@@ -235,6 +239,11 @@
       <AutoGen>True</AutoGen>
       <DependentUpon>ToDelimitedString.g.tt</DependentUpon>
     </Compile>
+    <Compile Update="Zip.g.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>Zip.g.tt</DependentUpon>
+    </Compile>
   </ItemGroup>
 
   <ItemGroup>
diff --git a/MoreLinq/Zip.g.cs b/MoreLinq/Zip.g.cs
new file mode 100644
index 000000000..c2ace5253
--- /dev/null
+++ b/MoreLinq/Zip.g.cs
@@ -0,0 +1,2660 @@
+#region License and Terms
+// MoreLINQ - Extensions to LINQ to Objects
+// Copyright (c) 2019 Pierre Lando. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#endregion
+
+namespace MoreLinq
+{
+    using System;
+    using System.Collections.Generic;
+
+    static partial class MoreEnumerable
+    {
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<TResult> EquiZip<T1, T2, TResult>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            Func<T1, T2, TResult> resultSelector)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.ThrowOnShort,
+                secondSource, ZipSourceConfiguration<T2>.ThrowOnShort,
+                resultSelector);
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<(T1, T2)> EquiZip<T1, T2>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.ThrowOnShort,
+                secondSource, ZipSourceConfiguration<T2>.ThrowOnShort,
+                ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input 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 input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<TResult> ZipLongest<T1, T2, TResult>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            Func<T1, T2, TResult> resultSelector)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.PaddingWith(default),
+                secondSource, ZipSourceConfiguration<T2>.PaddingWith(default),
+                resultSelector);
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input 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 input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<(T1, T2)> ZipLongest<T1, T2>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.PaddingWith(default),
+                secondSource, ZipSourceConfiguration<T2>.PaddingWith(default),
+                ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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<TResult> ZipShortest<T1, T2, TResult>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            Func<T1, T2, TResult> resultSelector)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.StopOnShort,
+                secondSource, ZipSourceConfiguration<T2>.StopOnShort,
+                resultSelector);
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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)> ZipShortest<T1, T2>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.StopOnShort,
+                secondSource, ZipSourceConfiguration<T2>.StopOnShort,
+                ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<TResult> EquiZip<T1, T2, T3, TResult>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            Func<T1, T2, T3, TResult> resultSelector)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.ThrowOnShort,
+                secondSource, ZipSourceConfiguration<T2>.ThrowOnShort,
+                thirdSource, ZipSourceConfiguration<T3>.ThrowOnShort,
+                resultSelector);
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<(T1, T2, T3)> EquiZip<T1, T2, T3>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.ThrowOnShort,
+                secondSource, ZipSourceConfiguration<T2>.ThrowOnShort,
+                thirdSource, ZipSourceConfiguration<T3>.ThrowOnShort,
+                ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input 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 input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<TResult> ZipLongest<T1, T2, T3, TResult>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            Func<T1, T2, T3, TResult> resultSelector)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.PaddingWith(default),
+                secondSource, ZipSourceConfiguration<T2>.PaddingWith(default),
+                thirdSource, ZipSourceConfiguration<T3>.PaddingWith(default),
+                resultSelector);
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input 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 input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<(T1, T2, T3)> ZipLongest<T1, T2, T3>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.PaddingWith(default),
+                secondSource, ZipSourceConfiguration<T2>.PaddingWith(default),
+                thirdSource, ZipSourceConfiguration<T3>.PaddingWith(default),
+                ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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<TResult> ZipShortest<T1, T2, T3, TResult>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            Func<T1, T2, T3, TResult> resultSelector)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.StopOnShort,
+                secondSource, ZipSourceConfiguration<T2>.StopOnShort,
+                thirdSource, ZipSourceConfiguration<T3>.StopOnShort,
+                resultSelector);
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.StopOnShort,
+                secondSource, ZipSourceConfiguration<T2>.StopOnShort,
+                thirdSource, ZipSourceConfiguration<T3>.StopOnShort,
+                ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, TResult>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            Func<T1, T2, T3, T4, TResult> resultSelector)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
+            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.ThrowOnShort,
+                secondSource, ZipSourceConfiguration<T2>.ThrowOnShort,
+                thirdSource, ZipSourceConfiguration<T3>.ThrowOnShort,
+                fourthSource, ZipSourceConfiguration<T4>.ThrowOnShort,
+                resultSelector);
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <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> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
+            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.ThrowOnShort,
+                secondSource, ZipSourceConfiguration<T2>.ThrowOnShort,
+                thirdSource, ZipSourceConfiguration<T3>.ThrowOnShort,
+                fourthSource, ZipSourceConfiguration<T4>.ThrowOnShort,
+                ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input 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 input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, TResult>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            Func<T1, T2, T3, T4, TResult> resultSelector)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
+            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.PaddingWith(default),
+                secondSource, ZipSourceConfiguration<T2>.PaddingWith(default),
+                thirdSource, ZipSourceConfiguration<T3>.PaddingWith(default),
+                fourthSource, ZipSourceConfiguration<T4>.PaddingWith(default),
+                resultSelector);
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input 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 input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
+            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.PaddingWith(default),
+                secondSource, ZipSourceConfiguration<T2>.PaddingWith(default),
+                thirdSource, ZipSourceConfiguration<T3>.PaddingWith(default),
+                fourthSource, ZipSourceConfiguration<T4>.PaddingWith(default),
+                ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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<TResult> ZipShortest<T1, T2, T3, T4, TResult>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            Func<T1, T2, T3, T4, TResult> resultSelector)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
+            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.StopOnShort,
+                secondSource, ZipSourceConfiguration<T2>.StopOnShort,
+                thirdSource, ZipSourceConfiguration<T3>.StopOnShort,
+                fourthSource, ZipSourceConfiguration<T4>.StopOnShort,
+                resultSelector);
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
+            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.StopOnShort,
+                secondSource, ZipSourceConfiguration<T2>.StopOnShort,
+                thirdSource, ZipSourceConfiguration<T3>.StopOnShort,
+                fourthSource, ZipSourceConfiguration<T4>.StopOnShort,
+                ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, TResult>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            Func<T1, T2, T3, T4, T5, TResult> resultSelector)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
+            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
+            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.ThrowOnShort,
+                secondSource, ZipSourceConfiguration<T2>.ThrowOnShort,
+                thirdSource, ZipSourceConfiguration<T3>.ThrowOnShort,
+                fourthSource, ZipSourceConfiguration<T4>.ThrowOnShort,
+                fifthSource, ZipSourceConfiguration<T5>.ThrowOnShort,
+                resultSelector);
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<(T1, T2, T3, T4, T5)> EquiZip<T1, T2, T3, T4, T5>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
+            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
+            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.ThrowOnShort,
+                secondSource, ZipSourceConfiguration<T2>.ThrowOnShort,
+                thirdSource, ZipSourceConfiguration<T3>.ThrowOnShort,
+                fourthSource, ZipSourceConfiguration<T4>.ThrowOnShort,
+                fifthSource, ZipSourceConfiguration<T5>.ThrowOnShort,
+                ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input 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 input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, TResult>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            Func<T1, T2, T3, T4, T5, TResult> resultSelector)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
+            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
+            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.PaddingWith(default),
+                secondSource, ZipSourceConfiguration<T2>.PaddingWith(default),
+                thirdSource, ZipSourceConfiguration<T3>.PaddingWith(default),
+                fourthSource, ZipSourceConfiguration<T4>.PaddingWith(default),
+                fifthSource, ZipSourceConfiguration<T5>.PaddingWith(default),
+                resultSelector);
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input 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 input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<(T1, T2, T3, T4, T5)> ZipLongest<T1, T2, T3, T4, T5>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
+            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
+            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.PaddingWith(default),
+                secondSource, ZipSourceConfiguration<T2>.PaddingWith(default),
+                thirdSource, ZipSourceConfiguration<T3>.PaddingWith(default),
+                fourthSource, ZipSourceConfiguration<T4>.PaddingWith(default),
+                fifthSource, ZipSourceConfiguration<T5>.PaddingWith(default),
+                ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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<TResult> ZipShortest<T1, T2, T3, T4, T5, TResult>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            Func<T1, T2, T3, T4, T5, TResult> resultSelector)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
+            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
+            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.StopOnShort,
+                secondSource, ZipSourceConfiguration<T2>.StopOnShort,
+                thirdSource, ZipSourceConfiguration<T3>.StopOnShort,
+                fourthSource, ZipSourceConfiguration<T4>.StopOnShort,
+                fifthSource, ZipSourceConfiguration<T5>.StopOnShort,
+                resultSelector);
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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, T5)> ZipShortest<T1, T2, T3, T4, T5>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
+            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
+            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.StopOnShort,
+                secondSource, ZipSourceConfiguration<T2>.StopOnShort,
+                thirdSource, ZipSourceConfiguration<T3>.StopOnShort,
+                fourthSource, ZipSourceConfiguration<T4>.StopOnShort,
+                fifthSource, ZipSourceConfiguration<T5>.StopOnShort,
+                ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, TResult>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            IEnumerable<T6> sixthSource,
+            Func<T1, T2, T3, T4, T5, T6, TResult> resultSelector)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
+            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
+            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
+            if (sixthSource == null) throw new ArgumentNullException(nameof(sixthSource));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.ThrowOnShort,
+                secondSource, ZipSourceConfiguration<T2>.ThrowOnShort,
+                thirdSource, ZipSourceConfiguration<T3>.ThrowOnShort,
+                fourthSource, ZipSourceConfiguration<T4>.ThrowOnShort,
+                fifthSource, ZipSourceConfiguration<T5>.ThrowOnShort,
+                sixthSource, ZipSourceConfiguration<T6>.ThrowOnShort,
+                resultSelector);
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<(T1, T2, T3, T4, T5, T6)> EquiZip<T1, T2, T3, T4, T5, T6>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            IEnumerable<T6> sixthSource)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
+            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
+            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
+            if (sixthSource == null) throw new ArgumentNullException(nameof(sixthSource));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.ThrowOnShort,
+                secondSource, ZipSourceConfiguration<T2>.ThrowOnShort,
+                thirdSource, ZipSourceConfiguration<T3>.ThrowOnShort,
+                fourthSource, ZipSourceConfiguration<T4>.ThrowOnShort,
+                fifthSource, ZipSourceConfiguration<T5>.ThrowOnShort,
+                sixthSource, ZipSourceConfiguration<T6>.ThrowOnShort,
+                ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input 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 input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, TResult>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            IEnumerable<T6> sixthSource,
+            Func<T1, T2, T3, T4, T5, T6, TResult> resultSelector)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
+            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
+            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
+            if (sixthSource == null) throw new ArgumentNullException(nameof(sixthSource));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.PaddingWith(default),
+                secondSource, ZipSourceConfiguration<T2>.PaddingWith(default),
+                thirdSource, ZipSourceConfiguration<T3>.PaddingWith(default),
+                fourthSource, ZipSourceConfiguration<T4>.PaddingWith(default),
+                fifthSource, ZipSourceConfiguration<T5>.PaddingWith(default),
+                sixthSource, ZipSourceConfiguration<T6>.PaddingWith(default),
+                resultSelector);
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input 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 input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<(T1, T2, T3, T4, T5, T6)> ZipLongest<T1, T2, T3, T4, T5, T6>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            IEnumerable<T6> sixthSource)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
+            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
+            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
+            if (sixthSource == null) throw new ArgumentNullException(nameof(sixthSource));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.PaddingWith(default),
+                secondSource, ZipSourceConfiguration<T2>.PaddingWith(default),
+                thirdSource, ZipSourceConfiguration<T3>.PaddingWith(default),
+                fourthSource, ZipSourceConfiguration<T4>.PaddingWith(default),
+                fifthSource, ZipSourceConfiguration<T5>.PaddingWith(default),
+                sixthSource, ZipSourceConfiguration<T6>.PaddingWith(default),
+                ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, TResult>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            IEnumerable<T6> sixthSource,
+            Func<T1, T2, T3, T4, T5, T6, TResult> resultSelector)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
+            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
+            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
+            if (sixthSource == null) throw new ArgumentNullException(nameof(sixthSource));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.StopOnShort,
+                secondSource, ZipSourceConfiguration<T2>.StopOnShort,
+                thirdSource, ZipSourceConfiguration<T3>.StopOnShort,
+                fourthSource, ZipSourceConfiguration<T4>.StopOnShort,
+                fifthSource, ZipSourceConfiguration<T5>.StopOnShort,
+                sixthSource, ZipSourceConfiguration<T6>.StopOnShort,
+                resultSelector);
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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, T5, T6)> ZipShortest<T1, T2, T3, T4, T5, T6>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            IEnumerable<T6> sixthSource)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
+            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
+            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
+            if (sixthSource == null) throw new ArgumentNullException(nameof(sixthSource));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.StopOnShort,
+                secondSource, ZipSourceConfiguration<T2>.StopOnShort,
+                thirdSource, ZipSourceConfiguration<T3>.StopOnShort,
+                fourthSource, ZipSourceConfiguration<T4>.StopOnShort,
+                fifthSource, ZipSourceConfiguration<T5>.StopOnShort,
+                sixthSource, ZipSourceConfiguration<T6>.StopOnShort,
+                ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="seventhSource">The seventh source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, T7, TResult>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            IEnumerable<T6> sixthSource,
+            IEnumerable<T7> seventhSource,
+            Func<T1, T2, T3, T4, T5, T6, T7, TResult> resultSelector)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
+            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
+            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
+            if (sixthSource == null) throw new ArgumentNullException(nameof(sixthSource));
+            if (seventhSource == null) throw new ArgumentNullException(nameof(seventhSource));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.ThrowOnShort,
+                secondSource, ZipSourceConfiguration<T2>.ThrowOnShort,
+                thirdSource, ZipSourceConfiguration<T3>.ThrowOnShort,
+                fourthSource, ZipSourceConfiguration<T4>.ThrowOnShort,
+                fifthSource, ZipSourceConfiguration<T5>.ThrowOnShort,
+                sixthSource, ZipSourceConfiguration<T6>.ThrowOnShort,
+                seventhSource, ZipSourceConfiguration<T7>.ThrowOnShort,
+                resultSelector);
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="seventhSource">The seventh source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<(T1, T2, T3, T4, T5, T6, T7)> EquiZip<T1, T2, T3, T4, T5, T6, T7>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            IEnumerable<T6> sixthSource,
+            IEnumerable<T7> seventhSource)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
+            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
+            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
+            if (sixthSource == null) throw new ArgumentNullException(nameof(sixthSource));
+            if (seventhSource == null) throw new ArgumentNullException(nameof(seventhSource));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.ThrowOnShort,
+                secondSource, ZipSourceConfiguration<T2>.ThrowOnShort,
+                thirdSource, ZipSourceConfiguration<T3>.ThrowOnShort,
+                fourthSource, ZipSourceConfiguration<T4>.ThrowOnShort,
+                fifthSource, ZipSourceConfiguration<T5>.ThrowOnShort,
+                sixthSource, ZipSourceConfiguration<T6>.ThrowOnShort,
+                seventhSource, ZipSourceConfiguration<T7>.ThrowOnShort,
+                ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input 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 input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="seventhSource">The seventh source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, T7, TResult>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            IEnumerable<T6> sixthSource,
+            IEnumerable<T7> seventhSource,
+            Func<T1, T2, T3, T4, T5, T6, T7, TResult> resultSelector)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
+            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
+            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
+            if (sixthSource == null) throw new ArgumentNullException(nameof(sixthSource));
+            if (seventhSource == null) throw new ArgumentNullException(nameof(seventhSource));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.PaddingWith(default),
+                secondSource, ZipSourceConfiguration<T2>.PaddingWith(default),
+                thirdSource, ZipSourceConfiguration<T3>.PaddingWith(default),
+                fourthSource, ZipSourceConfiguration<T4>.PaddingWith(default),
+                fifthSource, ZipSourceConfiguration<T5>.PaddingWith(default),
+                sixthSource, ZipSourceConfiguration<T6>.PaddingWith(default),
+                seventhSource, ZipSourceConfiguration<T7>.PaddingWith(default),
+                resultSelector);
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input 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 input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="seventhSource">The seventh source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<(T1, T2, T3, T4, T5, T6, T7)> ZipLongest<T1, T2, T3, T4, T5, T6, T7>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            IEnumerable<T6> sixthSource,
+            IEnumerable<T7> seventhSource)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
+            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
+            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
+            if (sixthSource == null) throw new ArgumentNullException(nameof(sixthSource));
+            if (seventhSource == null) throw new ArgumentNullException(nameof(seventhSource));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.PaddingWith(default),
+                secondSource, ZipSourceConfiguration<T2>.PaddingWith(default),
+                thirdSource, ZipSourceConfiguration<T3>.PaddingWith(default),
+                fourthSource, ZipSourceConfiguration<T4>.PaddingWith(default),
+                fifthSource, ZipSourceConfiguration<T5>.PaddingWith(default),
+                sixthSource, ZipSourceConfiguration<T6>.PaddingWith(default),
+                seventhSource, ZipSourceConfiguration<T7>.PaddingWith(default),
+                ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="seventhSource">The seventh source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, T7, TResult>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            IEnumerable<T6> sixthSource,
+            IEnumerable<T7> seventhSource,
+            Func<T1, T2, T3, T4, T5, T6, T7, TResult> resultSelector)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
+            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
+            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
+            if (sixthSource == null) throw new ArgumentNullException(nameof(sixthSource));
+            if (seventhSource == null) throw new ArgumentNullException(nameof(seventhSource));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.StopOnShort,
+                secondSource, ZipSourceConfiguration<T2>.StopOnShort,
+                thirdSource, ZipSourceConfiguration<T3>.StopOnShort,
+                fourthSource, ZipSourceConfiguration<T4>.StopOnShort,
+                fifthSource, ZipSourceConfiguration<T5>.StopOnShort,
+                sixthSource, ZipSourceConfiguration<T6>.StopOnShort,
+                seventhSource, ZipSourceConfiguration<T7>.StopOnShort,
+                resultSelector);
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="seventhSource">The seventh source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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, T5, T6, T7)> ZipShortest<T1, T2, T3, T4, T5, T6, T7>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            IEnumerable<T6> sixthSource,
+            IEnumerable<T7> seventhSource)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
+            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
+            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
+            if (sixthSource == null) throw new ArgumentNullException(nameof(sixthSource));
+            if (seventhSource == null) throw new ArgumentNullException(nameof(seventhSource));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.StopOnShort,
+                secondSource, ZipSourceConfiguration<T2>.StopOnShort,
+                thirdSource, ZipSourceConfiguration<T3>.StopOnShort,
+                fourthSource, ZipSourceConfiguration<T4>.StopOnShort,
+                fifthSource, ZipSourceConfiguration<T5>.StopOnShort,
+                sixthSource, ZipSourceConfiguration<T6>.StopOnShort,
+                seventhSource, ZipSourceConfiguration<T7>.StopOnShort,
+                ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
+        /// <typeparam name="T8">Type of elements in eighth input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="seventhSource">The seventh source sequence.</param>
+        /// <param name="eighthSource">The eighth source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            IEnumerable<T6> sixthSource,
+            IEnumerable<T7> seventhSource,
+            IEnumerable<T8> eighthSource,
+            Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> resultSelector)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
+            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
+            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
+            if (sixthSource == null) throw new ArgumentNullException(nameof(sixthSource));
+            if (seventhSource == null) throw new ArgumentNullException(nameof(seventhSource));
+            if (eighthSource == null) throw new ArgumentNullException(nameof(eighthSource));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.ThrowOnShort,
+                secondSource, ZipSourceConfiguration<T2>.ThrowOnShort,
+                thirdSource, ZipSourceConfiguration<T3>.ThrowOnShort,
+                fourthSource, ZipSourceConfiguration<T4>.ThrowOnShort,
+                fifthSource, ZipSourceConfiguration<T5>.ThrowOnShort,
+                sixthSource, ZipSourceConfiguration<T6>.ThrowOnShort,
+                seventhSource, ZipSourceConfiguration<T7>.ThrowOnShort,
+                eighthSource, ZipSourceConfiguration<T8>.ThrowOnShort,
+                resultSelector);
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
+        /// <typeparam name="T8">Type of elements in eighth input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="seventhSource">The seventh source sequence.</param>
+        /// <param name="eighthSource">The eighth source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<(T1, T2, T3, T4, T5, T6, T7, T8)> EquiZip<T1, T2, T3, T4, T5, T6, T7, T8>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            IEnumerable<T6> sixthSource,
+            IEnumerable<T7> seventhSource,
+            IEnumerable<T8> eighthSource)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
+            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
+            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
+            if (sixthSource == null) throw new ArgumentNullException(nameof(sixthSource));
+            if (seventhSource == null) throw new ArgumentNullException(nameof(seventhSource));
+            if (eighthSource == null) throw new ArgumentNullException(nameof(eighthSource));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.ThrowOnShort,
+                secondSource, ZipSourceConfiguration<T2>.ThrowOnShort,
+                thirdSource, ZipSourceConfiguration<T3>.ThrowOnShort,
+                fourthSource, ZipSourceConfiguration<T4>.ThrowOnShort,
+                fifthSource, ZipSourceConfiguration<T5>.ThrowOnShort,
+                sixthSource, ZipSourceConfiguration<T6>.ThrowOnShort,
+                seventhSource, ZipSourceConfiguration<T7>.ThrowOnShort,
+                eighthSource, ZipSourceConfiguration<T8>.ThrowOnShort,
+                ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input 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 input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
+        /// <typeparam name="T8">Type of elements in eighth input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="seventhSource">The seventh source sequence.</param>
+        /// <param name="eighthSource">The eighth source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            IEnumerable<T6> sixthSource,
+            IEnumerable<T7> seventhSource,
+            IEnumerable<T8> eighthSource,
+            Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> resultSelector)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
+            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
+            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
+            if (sixthSource == null) throw new ArgumentNullException(nameof(sixthSource));
+            if (seventhSource == null) throw new ArgumentNullException(nameof(seventhSource));
+            if (eighthSource == null) throw new ArgumentNullException(nameof(eighthSource));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.PaddingWith(default),
+                secondSource, ZipSourceConfiguration<T2>.PaddingWith(default),
+                thirdSource, ZipSourceConfiguration<T3>.PaddingWith(default),
+                fourthSource, ZipSourceConfiguration<T4>.PaddingWith(default),
+                fifthSource, ZipSourceConfiguration<T5>.PaddingWith(default),
+                sixthSource, ZipSourceConfiguration<T6>.PaddingWith(default),
+                seventhSource, ZipSourceConfiguration<T7>.PaddingWith(default),
+                eighthSource, ZipSourceConfiguration<T8>.PaddingWith(default),
+                resultSelector);
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input 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 input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
+        /// <typeparam name="T8">Type of elements in eighth input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="seventhSource">The seventh source sequence.</param>
+        /// <param name="eighthSource">The eighth source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<(T1, T2, T3, T4, T5, T6, T7, T8)> ZipLongest<T1, T2, T3, T4, T5, T6, T7, T8>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            IEnumerable<T6> sixthSource,
+            IEnumerable<T7> seventhSource,
+            IEnumerable<T8> eighthSource)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
+            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
+            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
+            if (sixthSource == null) throw new ArgumentNullException(nameof(sixthSource));
+            if (seventhSource == null) throw new ArgumentNullException(nameof(seventhSource));
+            if (eighthSource == null) throw new ArgumentNullException(nameof(eighthSource));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.PaddingWith(default),
+                secondSource, ZipSourceConfiguration<T2>.PaddingWith(default),
+                thirdSource, ZipSourceConfiguration<T3>.PaddingWith(default),
+                fourthSource, ZipSourceConfiguration<T4>.PaddingWith(default),
+                fifthSource, ZipSourceConfiguration<T5>.PaddingWith(default),
+                sixthSource, ZipSourceConfiguration<T6>.PaddingWith(default),
+                seventhSource, ZipSourceConfiguration<T7>.PaddingWith(default),
+                eighthSource, ZipSourceConfiguration<T8>.PaddingWith(default),
+                ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
+        /// <typeparam name="T8">Type of elements in eighth input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="seventhSource">The seventh source sequence.</param>
+        /// <param name="eighthSource">The eighth source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            IEnumerable<T6> sixthSource,
+            IEnumerable<T7> seventhSource,
+            IEnumerable<T8> eighthSource,
+            Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> resultSelector)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
+            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
+            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
+            if (sixthSource == null) throw new ArgumentNullException(nameof(sixthSource));
+            if (seventhSource == null) throw new ArgumentNullException(nameof(seventhSource));
+            if (eighthSource == null) throw new ArgumentNullException(nameof(eighthSource));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.StopOnShort,
+                secondSource, ZipSourceConfiguration<T2>.StopOnShort,
+                thirdSource, ZipSourceConfiguration<T3>.StopOnShort,
+                fourthSource, ZipSourceConfiguration<T4>.StopOnShort,
+                fifthSource, ZipSourceConfiguration<T5>.StopOnShort,
+                sixthSource, ZipSourceConfiguration<T6>.StopOnShort,
+                seventhSource, ZipSourceConfiguration<T7>.StopOnShort,
+                eighthSource, ZipSourceConfiguration<T8>.StopOnShort,
+                resultSelector);
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
+        /// <typeparam name="T8">Type of elements in eighth input sequence.</typeparam>
+        /// <param name="firstSource">The first source sequence.</param>
+        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="seventhSource">The seventh source sequence.</param>
+        /// <param name="eighthSource">The eighth source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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, T5, T6, T7, T8)> ZipShortest<T1, T2, T3, T4, T5, T6, T7, T8>(
+            this IEnumerable<T1> firstSource,
+            IEnumerable<T2> secondSource,
+            IEnumerable<T3> thirdSource,
+            IEnumerable<T4> fourthSource,
+            IEnumerable<T5> fifthSource,
+            IEnumerable<T6> sixthSource,
+            IEnumerable<T7> seventhSource,
+            IEnumerable<T8> eighthSource)
+        {
+            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
+            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
+            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
+            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
+            if (sixthSource == null) throw new ArgumentNullException(nameof(sixthSource));
+            if (seventhSource == null) throw new ArgumentNullException(nameof(seventhSource));
+            if (eighthSource == null) throw new ArgumentNullException(nameof(eighthSource));
+
+            return CustomZip(
+                firstSource, ZipSourceConfiguration<T1>.StopOnShort,
+                secondSource, ZipSourceConfiguration<T2>.StopOnShort,
+                thirdSource, ZipSourceConfiguration<T3>.StopOnShort,
+                fourthSource, ZipSourceConfiguration<T4>.StopOnShort,
+                fifthSource, ZipSourceConfiguration<T5>.StopOnShort,
+                sixthSource, ZipSourceConfiguration<T6>.StopOnShort,
+                seventhSource, ZipSourceConfiguration<T7>.StopOnShort,
+                eighthSource, ZipSourceConfiguration<T8>.StopOnShort,
+                ValueTuple.Create);
+        }
+
+
+        internal static IEnumerable<TResult> CustomZip<T1, T2, TResult>(
+            this IEnumerable<T1> firstSource, ZipSourceConfiguration<T1> firstSourceConfiguration,
+            IEnumerable<T2> secondSource, ZipSourceConfiguration<T2> secondSourceConfiguration,
+            Func<T1, T2, TResult> resultSelector)
+        {
+            using var firstEnumerator = new ZipEnumerator<T1>(firstSource.GetEnumerator(), nameof(firstSource), firstSourceConfiguration);
+            using var secondEnumerator = new ZipEnumerator<T2>(secondSource.GetEnumerator(), nameof(secondSource), secondSourceConfiguration);
+
+            var enumerators = new IZipEnumerator[]
+            {
+                firstEnumerator,
+                secondEnumerator
+            };
+
+            for (;;)
+            {
+                var isEnd = true;
+                IZipEnumerator equiStopper = null;
+
+                foreach (var enumerator in enumerators)
+                {
+                    switch (enumerator.MoveNext())
+                    {
+                        case ZipEnumeratorStatus.AskForStop:
+                            yield break;
+                        case ZipEnumeratorStatus.AskForEquiStop:
+                            if (!isEnd) // there is some sequences ahead
+                            {
+                                enumerator.ThrowToShort();
+                            }
+                            equiStopper = enumerator;
+                            break;
+                        case ZipEnumeratorStatus.Continue:
+                            equiStopper?.ThrowToShort();
+                            isEnd = false;
+                            break;
+                        case ZipEnumeratorStatus.EndOfStream:
+                            break;
+                        default:
+                            throw new ArgumentOutOfRangeException();
+                    }
+                }
+
+                if (isEnd)
+                {
+                    yield break;
+                }
+
+                yield return resultSelector(
+                    firstEnumerator.Current,
+                    secondEnumerator.Current
+                );
+            }
+        }
+
+        internal static IEnumerable<TResult> CustomZip<T1, T2, T3, TResult>(
+            this IEnumerable<T1> firstSource, ZipSourceConfiguration<T1> firstSourceConfiguration,
+            IEnumerable<T2> secondSource, ZipSourceConfiguration<T2> secondSourceConfiguration,
+            IEnumerable<T3> thirdSource, ZipSourceConfiguration<T3> thirdSourceConfiguration,
+            Func<T1, T2, T3, TResult> resultSelector)
+        {
+            using var firstEnumerator = new ZipEnumerator<T1>(firstSource.GetEnumerator(), nameof(firstSource), firstSourceConfiguration);
+            using var secondEnumerator = new ZipEnumerator<T2>(secondSource.GetEnumerator(), nameof(secondSource), secondSourceConfiguration);
+            using var thirdEnumerator = new ZipEnumerator<T3>(thirdSource.GetEnumerator(), nameof(thirdSource), thirdSourceConfiguration);
+
+            var enumerators = new IZipEnumerator[]
+            {
+                firstEnumerator,
+                secondEnumerator,
+                thirdEnumerator
+            };
+
+            for (;;)
+            {
+                var isEnd = true;
+                IZipEnumerator equiStopper = null;
+
+                foreach (var enumerator in enumerators)
+                {
+                    switch (enumerator.MoveNext())
+                    {
+                        case ZipEnumeratorStatus.AskForStop:
+                            yield break;
+                        case ZipEnumeratorStatus.AskForEquiStop:
+                            if (!isEnd) // there is some sequences ahead
+                            {
+                                enumerator.ThrowToShort();
+                            }
+                            equiStopper = enumerator;
+                            break;
+                        case ZipEnumeratorStatus.Continue:
+                            equiStopper?.ThrowToShort();
+                            isEnd = false;
+                            break;
+                        case ZipEnumeratorStatus.EndOfStream:
+                            break;
+                        default:
+                            throw new ArgumentOutOfRangeException();
+                    }
+                }
+
+                if (isEnd)
+                {
+                    yield break;
+                }
+
+                yield return resultSelector(
+                    firstEnumerator.Current,
+                    secondEnumerator.Current,
+                    thirdEnumerator.Current
+                );
+            }
+        }
+
+        internal static IEnumerable<TResult> CustomZip<T1, T2, T3, T4, TResult>(
+            this IEnumerable<T1> firstSource, ZipSourceConfiguration<T1> firstSourceConfiguration,
+            IEnumerable<T2> secondSource, ZipSourceConfiguration<T2> secondSourceConfiguration,
+            IEnumerable<T3> thirdSource, ZipSourceConfiguration<T3> thirdSourceConfiguration,
+            IEnumerable<T4> fourthSource, ZipSourceConfiguration<T4> fourthSourceConfiguration,
+            Func<T1, T2, T3, T4, TResult> resultSelector)
+        {
+            using var firstEnumerator = new ZipEnumerator<T1>(firstSource.GetEnumerator(), nameof(firstSource), firstSourceConfiguration);
+            using var secondEnumerator = new ZipEnumerator<T2>(secondSource.GetEnumerator(), nameof(secondSource), secondSourceConfiguration);
+            using var thirdEnumerator = new ZipEnumerator<T3>(thirdSource.GetEnumerator(), nameof(thirdSource), thirdSourceConfiguration);
+            using var fourthEnumerator = new ZipEnumerator<T4>(fourthSource.GetEnumerator(), nameof(fourthSource), fourthSourceConfiguration);
+
+            var enumerators = new IZipEnumerator[]
+            {
+                firstEnumerator,
+                secondEnumerator,
+                thirdEnumerator,
+                fourthEnumerator
+            };
+
+            for (;;)
+            {
+                var isEnd = true;
+                IZipEnumerator equiStopper = null;
+
+                foreach (var enumerator in enumerators)
+                {
+                    switch (enumerator.MoveNext())
+                    {
+                        case ZipEnumeratorStatus.AskForStop:
+                            yield break;
+                        case ZipEnumeratorStatus.AskForEquiStop:
+                            if (!isEnd) // there is some sequences ahead
+                            {
+                                enumerator.ThrowToShort();
+                            }
+                            equiStopper = enumerator;
+                            break;
+                        case ZipEnumeratorStatus.Continue:
+                            equiStopper?.ThrowToShort();
+                            isEnd = false;
+                            break;
+                        case ZipEnumeratorStatus.EndOfStream:
+                            break;
+                        default:
+                            throw new ArgumentOutOfRangeException();
+                    }
+                }
+
+                if (isEnd)
+                {
+                    yield break;
+                }
+
+                yield return resultSelector(
+                    firstEnumerator.Current,
+                    secondEnumerator.Current,
+                    thirdEnumerator.Current,
+                    fourthEnumerator.Current
+                );
+            }
+        }
+
+        internal static IEnumerable<TResult> CustomZip<T1, T2, T3, T4, T5, TResult>(
+            this IEnumerable<T1> firstSource, ZipSourceConfiguration<T1> firstSourceConfiguration,
+            IEnumerable<T2> secondSource, ZipSourceConfiguration<T2> secondSourceConfiguration,
+            IEnumerable<T3> thirdSource, ZipSourceConfiguration<T3> thirdSourceConfiguration,
+            IEnumerable<T4> fourthSource, ZipSourceConfiguration<T4> fourthSourceConfiguration,
+            IEnumerable<T5> fifthSource, ZipSourceConfiguration<T5> fifthSourceConfiguration,
+            Func<T1, T2, T3, T4, T5, TResult> resultSelector)
+        {
+            using var firstEnumerator = new ZipEnumerator<T1>(firstSource.GetEnumerator(), nameof(firstSource), firstSourceConfiguration);
+            using var secondEnumerator = new ZipEnumerator<T2>(secondSource.GetEnumerator(), nameof(secondSource), secondSourceConfiguration);
+            using var thirdEnumerator = new ZipEnumerator<T3>(thirdSource.GetEnumerator(), nameof(thirdSource), thirdSourceConfiguration);
+            using var fourthEnumerator = new ZipEnumerator<T4>(fourthSource.GetEnumerator(), nameof(fourthSource), fourthSourceConfiguration);
+            using var fifthEnumerator = new ZipEnumerator<T5>(fifthSource.GetEnumerator(), nameof(fifthSource), fifthSourceConfiguration);
+
+            var enumerators = new IZipEnumerator[]
+            {
+                firstEnumerator,
+                secondEnumerator,
+                thirdEnumerator,
+                fourthEnumerator,
+                fifthEnumerator
+            };
+
+            for (;;)
+            {
+                var isEnd = true;
+                IZipEnumerator equiStopper = null;
+
+                foreach (var enumerator in enumerators)
+                {
+                    switch (enumerator.MoveNext())
+                    {
+                        case ZipEnumeratorStatus.AskForStop:
+                            yield break;
+                        case ZipEnumeratorStatus.AskForEquiStop:
+                            if (!isEnd) // there is some sequences ahead
+                            {
+                                enumerator.ThrowToShort();
+                            }
+                            equiStopper = enumerator;
+                            break;
+                        case ZipEnumeratorStatus.Continue:
+                            equiStopper?.ThrowToShort();
+                            isEnd = false;
+                            break;
+                        case ZipEnumeratorStatus.EndOfStream:
+                            break;
+                        default:
+                            throw new ArgumentOutOfRangeException();
+                    }
+                }
+
+                if (isEnd)
+                {
+                    yield break;
+                }
+
+                yield return resultSelector(
+                    firstEnumerator.Current,
+                    secondEnumerator.Current,
+                    thirdEnumerator.Current,
+                    fourthEnumerator.Current,
+                    fifthEnumerator.Current
+                );
+            }
+        }
+
+        internal static IEnumerable<TResult> CustomZip<T1, T2, T3, T4, T5, T6, TResult>(
+            this IEnumerable<T1> firstSource, ZipSourceConfiguration<T1> firstSourceConfiguration,
+            IEnumerable<T2> secondSource, ZipSourceConfiguration<T2> secondSourceConfiguration,
+            IEnumerable<T3> thirdSource, ZipSourceConfiguration<T3> thirdSourceConfiguration,
+            IEnumerable<T4> fourthSource, ZipSourceConfiguration<T4> fourthSourceConfiguration,
+            IEnumerable<T5> fifthSource, ZipSourceConfiguration<T5> fifthSourceConfiguration,
+            IEnumerable<T6> sixthSource, ZipSourceConfiguration<T6> sixthSourceConfiguration,
+            Func<T1, T2, T3, T4, T5, T6, TResult> resultSelector)
+        {
+            using var firstEnumerator = new ZipEnumerator<T1>(firstSource.GetEnumerator(), nameof(firstSource), firstSourceConfiguration);
+            using var secondEnumerator = new ZipEnumerator<T2>(secondSource.GetEnumerator(), nameof(secondSource), secondSourceConfiguration);
+            using var thirdEnumerator = new ZipEnumerator<T3>(thirdSource.GetEnumerator(), nameof(thirdSource), thirdSourceConfiguration);
+            using var fourthEnumerator = new ZipEnumerator<T4>(fourthSource.GetEnumerator(), nameof(fourthSource), fourthSourceConfiguration);
+            using var fifthEnumerator = new ZipEnumerator<T5>(fifthSource.GetEnumerator(), nameof(fifthSource), fifthSourceConfiguration);
+            using var sixthEnumerator = new ZipEnumerator<T6>(sixthSource.GetEnumerator(), nameof(sixthSource), sixthSourceConfiguration);
+
+            var enumerators = new IZipEnumerator[]
+            {
+                firstEnumerator,
+                secondEnumerator,
+                thirdEnumerator,
+                fourthEnumerator,
+                fifthEnumerator,
+                sixthEnumerator
+            };
+
+            for (;;)
+            {
+                var isEnd = true;
+                IZipEnumerator equiStopper = null;
+
+                foreach (var enumerator in enumerators)
+                {
+                    switch (enumerator.MoveNext())
+                    {
+                        case ZipEnumeratorStatus.AskForStop:
+                            yield break;
+                        case ZipEnumeratorStatus.AskForEquiStop:
+                            if (!isEnd) // there is some sequences ahead
+                            {
+                                enumerator.ThrowToShort();
+                            }
+                            equiStopper = enumerator;
+                            break;
+                        case ZipEnumeratorStatus.Continue:
+                            equiStopper?.ThrowToShort();
+                            isEnd = false;
+                            break;
+                        case ZipEnumeratorStatus.EndOfStream:
+                            break;
+                        default:
+                            throw new ArgumentOutOfRangeException();
+                    }
+                }
+
+                if (isEnd)
+                {
+                    yield break;
+                }
+
+                yield return resultSelector(
+                    firstEnumerator.Current,
+                    secondEnumerator.Current,
+                    thirdEnumerator.Current,
+                    fourthEnumerator.Current,
+                    fifthEnumerator.Current,
+                    sixthEnumerator.Current
+                );
+            }
+        }
+
+        internal static IEnumerable<TResult> CustomZip<T1, T2, T3, T4, T5, T6, T7, TResult>(
+            this IEnumerable<T1> firstSource, ZipSourceConfiguration<T1> firstSourceConfiguration,
+            IEnumerable<T2> secondSource, ZipSourceConfiguration<T2> secondSourceConfiguration,
+            IEnumerable<T3> thirdSource, ZipSourceConfiguration<T3> thirdSourceConfiguration,
+            IEnumerable<T4> fourthSource, ZipSourceConfiguration<T4> fourthSourceConfiguration,
+            IEnumerable<T5> fifthSource, ZipSourceConfiguration<T5> fifthSourceConfiguration,
+            IEnumerable<T6> sixthSource, ZipSourceConfiguration<T6> sixthSourceConfiguration,
+            IEnumerable<T7> seventhSource, ZipSourceConfiguration<T7> seventhSourceConfiguration,
+            Func<T1, T2, T3, T4, T5, T6, T7, TResult> resultSelector)
+        {
+            using var firstEnumerator = new ZipEnumerator<T1>(firstSource.GetEnumerator(), nameof(firstSource), firstSourceConfiguration);
+            using var secondEnumerator = new ZipEnumerator<T2>(secondSource.GetEnumerator(), nameof(secondSource), secondSourceConfiguration);
+            using var thirdEnumerator = new ZipEnumerator<T3>(thirdSource.GetEnumerator(), nameof(thirdSource), thirdSourceConfiguration);
+            using var fourthEnumerator = new ZipEnumerator<T4>(fourthSource.GetEnumerator(), nameof(fourthSource), fourthSourceConfiguration);
+            using var fifthEnumerator = new ZipEnumerator<T5>(fifthSource.GetEnumerator(), nameof(fifthSource), fifthSourceConfiguration);
+            using var sixthEnumerator = new ZipEnumerator<T6>(sixthSource.GetEnumerator(), nameof(sixthSource), sixthSourceConfiguration);
+            using var seventhEnumerator = new ZipEnumerator<T7>(seventhSource.GetEnumerator(), nameof(seventhSource), seventhSourceConfiguration);
+
+            var enumerators = new IZipEnumerator[]
+            {
+                firstEnumerator,
+                secondEnumerator,
+                thirdEnumerator,
+                fourthEnumerator,
+                fifthEnumerator,
+                sixthEnumerator,
+                seventhEnumerator
+            };
+
+            for (;;)
+            {
+                var isEnd = true;
+                IZipEnumerator equiStopper = null;
+
+                foreach (var enumerator in enumerators)
+                {
+                    switch (enumerator.MoveNext())
+                    {
+                        case ZipEnumeratorStatus.AskForStop:
+                            yield break;
+                        case ZipEnumeratorStatus.AskForEquiStop:
+                            if (!isEnd) // there is some sequences ahead
+                            {
+                                enumerator.ThrowToShort();
+                            }
+                            equiStopper = enumerator;
+                            break;
+                        case ZipEnumeratorStatus.Continue:
+                            equiStopper?.ThrowToShort();
+                            isEnd = false;
+                            break;
+                        case ZipEnumeratorStatus.EndOfStream:
+                            break;
+                        default:
+                            throw new ArgumentOutOfRangeException();
+                    }
+                }
+
+                if (isEnd)
+                {
+                    yield break;
+                }
+
+                yield return resultSelector(
+                    firstEnumerator.Current,
+                    secondEnumerator.Current,
+                    thirdEnumerator.Current,
+                    fourthEnumerator.Current,
+                    fifthEnumerator.Current,
+                    sixthEnumerator.Current,
+                    seventhEnumerator.Current
+                );
+            }
+        }
+
+        internal static IEnumerable<TResult> CustomZip<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(
+            this IEnumerable<T1> firstSource, ZipSourceConfiguration<T1> firstSourceConfiguration,
+            IEnumerable<T2> secondSource, ZipSourceConfiguration<T2> secondSourceConfiguration,
+            IEnumerable<T3> thirdSource, ZipSourceConfiguration<T3> thirdSourceConfiguration,
+            IEnumerable<T4> fourthSource, ZipSourceConfiguration<T4> fourthSourceConfiguration,
+            IEnumerable<T5> fifthSource, ZipSourceConfiguration<T5> fifthSourceConfiguration,
+            IEnumerable<T6> sixthSource, ZipSourceConfiguration<T6> sixthSourceConfiguration,
+            IEnumerable<T7> seventhSource, ZipSourceConfiguration<T7> seventhSourceConfiguration,
+            IEnumerable<T8> eighthSource, ZipSourceConfiguration<T8> eighthSourceConfiguration,
+            Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> resultSelector)
+        {
+            using var firstEnumerator = new ZipEnumerator<T1>(firstSource.GetEnumerator(), nameof(firstSource), firstSourceConfiguration);
+            using var secondEnumerator = new ZipEnumerator<T2>(secondSource.GetEnumerator(), nameof(secondSource), secondSourceConfiguration);
+            using var thirdEnumerator = new ZipEnumerator<T3>(thirdSource.GetEnumerator(), nameof(thirdSource), thirdSourceConfiguration);
+            using var fourthEnumerator = new ZipEnumerator<T4>(fourthSource.GetEnumerator(), nameof(fourthSource), fourthSourceConfiguration);
+            using var fifthEnumerator = new ZipEnumerator<T5>(fifthSource.GetEnumerator(), nameof(fifthSource), fifthSourceConfiguration);
+            using var sixthEnumerator = new ZipEnumerator<T6>(sixthSource.GetEnumerator(), nameof(sixthSource), sixthSourceConfiguration);
+            using var seventhEnumerator = new ZipEnumerator<T7>(seventhSource.GetEnumerator(), nameof(seventhSource), seventhSourceConfiguration);
+            using var eighthEnumerator = new ZipEnumerator<T8>(eighthSource.GetEnumerator(), nameof(eighthSource), eighthSourceConfiguration);
+
+            var enumerators = new IZipEnumerator[]
+            {
+                firstEnumerator,
+                secondEnumerator,
+                thirdEnumerator,
+                fourthEnumerator,
+                fifthEnumerator,
+                sixthEnumerator,
+                seventhEnumerator,
+                eighthEnumerator
+            };
+
+            for (;;)
+            {
+                var isEnd = true;
+                IZipEnumerator equiStopper = null;
+
+                foreach (var enumerator in enumerators)
+                {
+                    switch (enumerator.MoveNext())
+                    {
+                        case ZipEnumeratorStatus.AskForStop:
+                            yield break;
+                        case ZipEnumeratorStatus.AskForEquiStop:
+                            if (!isEnd) // there is some sequences ahead
+                            {
+                                enumerator.ThrowToShort();
+                            }
+                            equiStopper = enumerator;
+                            break;
+                        case ZipEnumeratorStatus.Continue:
+                            equiStopper?.ThrowToShort();
+                            isEnd = false;
+                            break;
+                        case ZipEnumeratorStatus.EndOfStream:
+                            break;
+                        default:
+                            throw new ArgumentOutOfRangeException();
+                    }
+                }
+
+                if (isEnd)
+                {
+                    yield break;
+                }
+
+                yield return resultSelector(
+                    firstEnumerator.Current,
+                    secondEnumerator.Current,
+                    thirdEnumerator.Current,
+                    fourthEnumerator.Current,
+                    fifthEnumerator.Current,
+                    sixthEnumerator.Current,
+                    seventhEnumerator.Current,
+                    eighthEnumerator.Current
+                );
+            }
+        }
+
+    }
+
+    internal interface IZipEnumerator
+    {
+        ZipEnumeratorStatus MoveNext();
+        void ThrowToShort();
+    }
+
+    internal class ZipEnumerator<T> : IZipEnumerator, IDisposable
+    {
+        private readonly ZipSourceConfiguration<T> _configuration;
+        private readonly string _name;
+        private IEnumerator<T> _source;
+
+        public ZipEnumerator(IEnumerator<T> source, string name, ZipSourceConfiguration<T> configuration)
+        {
+            _source = source;
+            _name = name;
+            _configuration = configuration;
+        }
+
+        public T Current => _source == null ? _configuration.PaddingValue : _source.Current;
+
+        public void Dispose() => _source?.Dispose();
+
+        public ZipEnumeratorStatus MoveNext()
+        {
+            if (_source?.MoveNext() == false)
+            {
+                _source.Dispose();
+                _source = null;
+            }
+
+            if (_source != null)
+            {
+                return ZipEnumeratorStatus.Continue;
+            }
+
+            switch (_configuration.Behavior)
+            {
+                case ZipEnumeratorBehavior.StopOnShort:
+                    return ZipEnumeratorStatus.AskForStop;
+                case ZipEnumeratorBehavior.Padding:
+                    return ZipEnumeratorStatus.EndOfStream;
+                case ZipEnumeratorBehavior.ThrowOnShort:
+                    return ZipEnumeratorStatus.AskForEquiStop;
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+        }
+
+        public void Reset() => _source.Reset();
+
+        public void ThrowToShort() => throw new InvalidOperationException($"{_name} sequence too short.");
+    }
+
+    internal enum ZipEnumeratorBehavior
+    {
+        StopOnShort,
+        ThrowOnShort,
+        Padding
+    }
+
+    internal enum ZipEnumeratorStatus
+    {
+        AskForStop,
+        AskForEquiStop,
+        Continue,
+        EndOfStream
+    }
+
+    internal class ZipSourceConfiguration<T>
+    {
+        public static ZipSourceConfiguration<T> StopOnShort { get; } = new ZipSourceConfiguration<T>(ZipEnumeratorBehavior.StopOnShort, default);
+        public static ZipSourceConfiguration<T> ThrowOnShort { get; } = new ZipSourceConfiguration<T>(ZipEnumeratorBehavior.ThrowOnShort, default);
+        public static ZipSourceConfiguration<T> PaddingWith(T paddingValue) => new ZipSourceConfiguration<T>(ZipEnumeratorBehavior.Padding, paddingValue);
+
+        ZipSourceConfiguration(ZipEnumeratorBehavior behavior, T paddingValue)
+        {
+            Behavior = behavior;
+            PaddingValue = paddingValue;
+        }
+
+        public ZipEnumeratorBehavior Behavior { get; }
+        public T PaddingValue { get; }
+    }
+}
diff --git a/MoreLinq/Zip.g.tt b/MoreLinq/Zip.g.tt
new file mode 100644
index 000000000..e58e9b54d
--- /dev/null
+++ b/MoreLinq/Zip.g.tt
@@ -0,0 +1,458 @@
+<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ output extension=".cs" #>
+<#@ assembly name="System.Core" #>
+<#@ assembly name="System.Collections" #>
+<#@ import namespace="System.Globalization" #>
+<#@ import namespace="System.Linq" #>
+#region License and Terms
+// MoreLINQ - Extensions to LINQ to Objects
+// Copyright (c) 2019 Pierre Lando. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#endregion
+
+<#
+    var overloads =
+        from args in new[]
+        {
+            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" },
+            }
+        }
+        select args.Select((a, i) => new
+        {
+            a.Ordinal,
+            a.Arity,
+            Count = i + 1,
+            Number = (i + 1).ToString(CultureInfo.InvariantCulture),
+        })
+        into args
+        select args.ToList() into args
+        from a in args.Skip(1)
+        select new
+        {
+            a.Arity,
+            a.Count,
+            Arguments = args.Take(a.Count)
+                            .Select(aa => new { aa.Number, Num = aa.Count, aa.Ordinal })
+                            .ToList(),
+            Types = string.Join(", ", Enumerable.Range(1, a.Count).Select(i => $"T{i}")),
+        };
+#>
+namespace MoreLinq
+{
+    using System;
+    using System.Collections.Generic;
+
+    static partial class MoreEnumerable
+    {
+<#  foreach (var o in overloads)
+    {
+#>
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+<# foreach (var arg in o.Arguments) { #>
+        /// <typeparam name="T<#= arg.Number #>">Type of elements in <#= arg.Ordinal #> input sequence.</typeparam>
+<#} #>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+<# foreach (var arg in o.Arguments) { #>
+        /// <param name="<#= arg.Ordinal #>Source">The <#= arg.Ordinal #> source sequence.</param>
+<#} #>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<TResult> EquiZip<<#= o.Types#>, TResult>(
+<# foreach (var arg in o.Arguments) { #>
+            <#= arg.Num == 1 ? "this " : "" #>IEnumerable<T<#= arg.Number #>> <#= arg.Ordinal #>Source,
+<#}#>
+            Func<<#= o.Types#>, TResult> resultSelector)
+        {
+<# foreach (var arg in o.Arguments) { #>
+            if (<#= arg.Ordinal #>Source == null) throw new ArgumentNullException(nameof(<#= arg.Ordinal #>Source));
+<#} #>
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return CustomZip(
+<# foreach (var arg in o.Arguments) { #>
+                <#= arg.Ordinal #>Source, ZipSourceConfiguration<T<#= arg.Number #>>.ThrowOnShort,
+<#}#>
+                resultSelector);
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+<# foreach (var arg in o.Arguments) { #>
+        /// <typeparam name="T<#= arg.Number #>">Type of elements in <#= arg.Ordinal #> input sequence.</typeparam>
+<#} #>
+<# foreach (var arg in o.Arguments) { #>
+        /// <param name="<#= arg.Ordinal #>Source">The <#= arg.Ordinal #> source sequence.</param>
+<#} #>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<(<#= o.Types#>)> EquiZip<<#= o.Types#>>(
+<# foreach (var arg in o.Arguments) { #>
+            <#= arg.Num == 1 ? "this " : "" #>IEnumerable<T<#= arg.Number #>> <#= arg.Ordinal #>Source<#= arg.Num < o.Count ? "," : ")" #>
+<#}#>
+        {
+<# foreach (var arg in o.Arguments) { #>
+            if (<#= arg.Ordinal #>Source == null) throw new ArgumentNullException(nameof(<#= arg.Ordinal #>Source));
+<#} #>
+
+            return CustomZip(
+<# foreach (var arg in o.Arguments) { #>
+                <#= arg.Ordinal #>Source, ZipSourceConfiguration<T<#= arg.Number #>>.ThrowOnShort,
+<#}#>
+                ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input 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>
+<# foreach (var arg in o.Arguments) { #>
+        /// <typeparam name="T<#= arg.Number #>">Type of elements in <#= arg.Ordinal #> input sequence.</typeparam>
+<#} #>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+<# foreach (var arg in o.Arguments) { #>
+        /// <param name="<#= arg.Ordinal #>Source">The <#= arg.Ordinal #> source sequence.</param>
+<#} #>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<TResult> ZipLongest<<#= o.Types#>, TResult>(
+<# foreach (var arg in o.Arguments) { #>
+            <#= arg.Num == 1 ? "this " : "" #>IEnumerable<T<#= arg.Number #>> <#= arg.Ordinal #>Source,
+<#}#>
+            Func<<#= o.Types#>, TResult> resultSelector)
+        {
+<# foreach (var arg in o.Arguments) { #>
+            if (<#= arg.Ordinal #>Source == null) throw new ArgumentNullException(nameof(<#= arg.Ordinal #>Source));
+<#} #>
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return CustomZip(
+<# foreach (var arg in o.Arguments) { #>
+                <#= arg.Ordinal #>Source, ZipSourceConfiguration<T<#= arg.Number #>>.PaddingWith(default),
+<#}#>
+                resultSelector);
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input 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>
+<# foreach (var arg in o.Arguments) { #>
+        /// <typeparam name="T<#= arg.Number #>">Type of elements in <#= arg.Ordinal #> input sequence.</typeparam>
+<#} #>
+<# foreach (var arg in o.Arguments) { #>
+        /// <param name="<#= arg.Ordinal #>Source">The <#= arg.Ordinal #> source sequence.</param>
+<#} #>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+        public static IEnumerable<(<#= o.Types#>)> ZipLongest<<#= o.Types#>>(
+<# foreach (var arg in o.Arguments) { #>
+            <#= arg.Num == 1 ? "this " : "" #>IEnumerable<T<#= arg.Number #>> <#= arg.Ordinal #>Source<#= arg.Num < o.Count ? "," : ")" #>
+<#}#>
+        {
+<# foreach (var arg in o.Arguments) { #>
+            if (<#= arg.Ordinal #>Source == null) throw new ArgumentNullException(nameof(<#= arg.Ordinal #>Source));
+<#} #>
+
+            return CustomZip(
+<# foreach (var arg in o.Arguments) { #>
+                <#= arg.Ordinal #>Source, ZipSourceConfiguration<T<#= arg.Number #>>.PaddingWith(default),
+<#}#>
+                ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+<# foreach (var arg in o.Arguments) { #>
+        /// <typeparam name="T<#= arg.Number #>">Type of elements in <#= arg.Ordinal #> input sequence.</typeparam>
+<#} #>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+<# foreach (var arg in o.Arguments) { #>
+        /// <param name="<#= arg.Ordinal #>Source">The <#= arg.Ordinal #> source sequence.</param>
+<#} #>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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<TResult> ZipShortest<<#= o.Types#>, TResult>(
+<# foreach (var arg in o.Arguments) { #>
+            <#= arg.Num == 1 ? "this " : "" #>IEnumerable<T<#= arg.Number #>> <#= arg.Ordinal #>Source,
+<#}#>
+            Func<<#= o.Types#>, TResult> resultSelector)
+        {
+<# foreach (var arg in o.Arguments) { #>
+            if (<#= arg.Ordinal #>Source == null) throw new ArgumentNullException(nameof(<#= arg.Ordinal #>Source));
+<#} #>
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return CustomZip(
+<# foreach (var arg in o.Arguments) { #>
+                <#= arg.Ordinal #>Source, ZipSourceConfiguration<T<#= arg.Number #>>.StopOnShort,
+<#}#>
+                resultSelector);
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+<# foreach (var arg in o.Arguments) { #>
+        /// <typeparam name="T<#= arg.Number #>">Type of elements in <#= arg.Ordinal #> input sequence.</typeparam>
+<#} #>
+<# foreach (var arg in o.Arguments) { #>
+        /// <param name="<#= arg.Ordinal #>Source">The <#= arg.Ordinal #> source sequence.</param>
+<#} #>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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<(<#= o.Types#>)> ZipShortest<<#= o.Types#>>(
+<# foreach (var arg in o.Arguments) { #>
+            <#= arg.Num == 1 ? "this " : "" #>IEnumerable<T<#= arg.Number #>> <#= arg.Ordinal #>Source<#= arg.Num < o.Count ? "," : ")" #>
+<#}#>
+        {
+<# foreach (var arg in o.Arguments) { #>
+            if (<#= arg.Ordinal #>Source == null) throw new ArgumentNullException(nameof(<#= arg.Ordinal #>Source));
+<#} #>
+
+            return CustomZip(
+<# foreach (var arg in o.Arguments) { #>
+                <#= arg.Ordinal #>Source, ZipSourceConfiguration<T<#= arg.Number #>>.StopOnShort,
+<#}#>
+                ValueTuple.Create);
+        }
+
+<#  } #>
+
+<#  foreach (var o in overloads)
+    {
+#>
+        internal static IEnumerable<TResult> CustomZip<<#= o.Types#>, TResult>(
+<# foreach (var arg in o.Arguments) { #>
+            <#= arg.Num == 1 ? "this " : "" #>IEnumerable<T<#= arg.Number #>> <#= arg.Ordinal #>Source, ZipSourceConfiguration<T<#= arg.Number #>> <#= arg.Ordinal #>SourceConfiguration,
+<#}#>
+            Func<<#= o.Types#>, TResult> resultSelector)
+        {
+<# foreach (var arg in o.Arguments) { #>
+            using var <#= arg.Ordinal #>Enumerator = new ZipEnumerator<T<#= arg.Number #>>(<#= arg.Ordinal #>Source.GetEnumerator(), nameof(<#= arg.Ordinal #>Source), <#= arg.Ordinal #>SourceConfiguration);
+<#} #>
+
+            var enumerators = new IZipEnumerator[]
+            {
+<# foreach (var arg in o.Arguments) { #>
+                <#= arg.Ordinal #>Enumerator<#= arg.Num < o.Count ? "," : "" #>
+<#}#>
+            };
+
+            for (;;)
+            {
+                var isEnd = true;
+                IZipEnumerator equiStopper = null;
+
+                foreach (var enumerator in enumerators)
+                {
+                    switch (enumerator.MoveNext())
+                    {
+                        case ZipEnumeratorStatus.AskForStop:
+                            yield break;
+                        case ZipEnumeratorStatus.AskForEquiStop:
+                            if (!isEnd) // there is some sequences ahead
+                            {
+                                enumerator.ThrowToShort();
+                            }
+                            equiStopper = enumerator;
+                            break;
+                        case ZipEnumeratorStatus.Continue:
+                            equiStopper?.ThrowToShort();
+                            isEnd = false;
+                            break;
+                        case ZipEnumeratorStatus.EndOfStream:
+                            break;
+                        default:
+                            throw new ArgumentOutOfRangeException();
+                    }
+                }
+
+                if (isEnd)
+                {
+                    yield break;
+                }
+
+                yield return resultSelector(
+<# foreach (var arg in o.Arguments) { #>
+                    <#= arg.Ordinal #>Enumerator.Current<#= arg.Num < o.Count ? "," : "" #>
+<#}#>
+                );
+            }
+        }
+
+<#  } #>
+    }
+
+    internal interface IZipEnumerator
+    {
+        ZipEnumeratorStatus MoveNext();
+        void ThrowToShort();
+    }
+
+    internal class ZipEnumerator<T> : IZipEnumerator, IDisposable
+    {
+        private readonly ZipSourceConfiguration<T> _configuration;
+        private readonly string _name;
+        private IEnumerator<T> _source;
+
+        public ZipEnumerator(IEnumerator<T> source, string name, ZipSourceConfiguration<T> configuration)
+        {
+            _source = source;
+            _name = name;
+            _configuration = configuration;
+        }
+
+        public T Current => _source == null ? _configuration.PaddingValue : _source.Current;
+
+        public void Dispose() => _source?.Dispose();
+
+        public ZipEnumeratorStatus MoveNext()
+        {
+            if (_source?.MoveNext() == false)
+            {
+                _source.Dispose();
+                _source = null;
+            }
+
+            if (_source != null)
+            {
+                return ZipEnumeratorStatus.Continue;
+            }
+
+            switch (_configuration.Behavior)
+            {
+                case ZipEnumeratorBehavior.StopOnShort:
+                    return ZipEnumeratorStatus.AskForStop;
+                case ZipEnumeratorBehavior.Padding:
+                    return ZipEnumeratorStatus.EndOfStream;
+                case ZipEnumeratorBehavior.ThrowOnShort:
+                    return ZipEnumeratorStatus.AskForEquiStop;
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+        }
+
+        public void Reset() => _source.Reset();
+
+        public void ThrowToShort() => throw new InvalidOperationException($"{_name} sequence too short.");
+    }
+
+    internal enum ZipEnumeratorBehavior
+    {
+        StopOnShort,
+        ThrowOnShort,
+        Padding
+    }
+
+    internal enum ZipEnumeratorStatus
+    {
+        AskForStop,
+        AskForEquiStop,
+        Continue,
+        EndOfStream
+    }
+
+    internal class ZipSourceConfiguration<T>
+    {
+        public static ZipSourceConfiguration<T> StopOnShort { get; } = new ZipSourceConfiguration<T>(ZipEnumeratorBehavior.StopOnShort, default);
+        public static ZipSourceConfiguration<T> ThrowOnShort { get; } = new ZipSourceConfiguration<T>(ZipEnumeratorBehavior.ThrowOnShort, default);
+        public static ZipSourceConfiguration<T> PaddingWith(T paddingValue) => new ZipSourceConfiguration<T>(ZipEnumeratorBehavior.Padding, paddingValue);
+
+        ZipSourceConfiguration(ZipEnumeratorBehavior behavior, T paddingValue)
+        {
+            Behavior = behavior;
+            PaddingValue = paddingValue;
+        }
+
+        public ZipEnumeratorBehavior Behavior { get; }
+        public T PaddingValue { get; }
+    }
+}
diff --git a/MoreLinq/ZipImpl.cs b/MoreLinq/ZipImpl.cs
deleted file mode 100644
index 2005660cb..000000000
--- a/MoreLinq/ZipImpl.cs
+++ /dev/null
@@ -1,97 +0,0 @@
-#region License and Terms
-// MoreLINQ - Extensions to LINQ to Objects
-// Copyright (c) 2018 Leandro F. Vieira (leandromoh). All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-#endregion
-
-namespace MoreLinq
-{
-    using System;
-    using System.Collections.Generic;
-    using System.Collections;
-
-    static partial class MoreEnumerable
-    {
-        delegate TResult Folder<in T, out TResult>(params T[] args);
-
-        static IEnumerable<TResult> ZipImpl<T1, T2, T3, T4, TResult>(
-            IEnumerable<T1> s1,
-            IEnumerable<T2> s2,
-            IEnumerable<T3> s3,
-            IEnumerable<T4> s4,
-            Func<T1, T2, T3, T4, TResult> resultSelector,
-            int limit,
-            Folder<IEnumerator, Exception> errorSelector = null)
-        {
-            IEnumerator<T1> e1 = null;
-            IEnumerator<T2> e2 = null;
-            IEnumerator<T3> e3 = null;
-            IEnumerator<T4> e4 = null;
-            var terminations = 0;
-
-            try
-            {
-                e1 = s1 .GetEnumerator();
-                e2 = s2 .GetEnumerator();
-                e3 = s3?.GetEnumerator();
-                e4 = s4?.GetEnumerator();
-
-                while (true)
-                {
-                    var n = 0;
-                    var v1 = Read(ref e1, ++n);
-                    var v2 = Read(ref e2, ++n);
-                    var v3 = Read(ref e3, ++n);
-                    var v4 = Read(ref e4, ++n);
-
-                    if (terminations <= limit)
-                        yield return resultSelector(v1, v2, v3, v4);
-                    else
-                        yield break;
-                }
-            }
-            finally
-            {
-                e1?.Dispose();
-                e2?.Dispose();
-                e3?.Dispose();
-                e4?.Dispose();
-            }
-
-            T Read<T>(ref IEnumerator<T> e, int n)
-            {
-                if (e == null || terminations > limit)
-                    return default;
-
-                T value;
-                if (e.MoveNext())
-                {
-                    value = e.Current;
-                }
-                else
-                {
-                    e.Dispose();
-                    e = null;
-                    terminations++;
-                    value = default;
-                }
-
-                if (errorSelector != null && terminations > 0 && terminations < n)
-                    throw errorSelector(e1, e2, e3, e4);
-
-                return value;
-            }
-        }
-    }
-}
diff --git a/MoreLinq/ZipLongest.cs b/MoreLinq/ZipLongest.cs
deleted file mode 100644
index ec5a240e6..000000000
--- a/MoreLinq/ZipLongest.cs
+++ /dev/null
@@ -1,169 +0,0 @@
-#region License and Terms
-// MoreLINQ - Extensions to LINQ to Objects
-// Copyright (c) 2008 Jonathan Skeet. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-#endregion
-
-namespace MoreLinq
-{
-    using System;
-    using System.Collections.Generic;
-
-    static partial class MoreEnumerable
-    {
-        /// <summary>
-        /// Returns a projection 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>
-        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="first">The first sequence.</param>
-        /// <param name="second">The second sequence.</param>
-        /// <param name="resultSelector">
-        /// Function to apply to each pair of elements.</param>
-        /// <returns>
-        /// A sequence that contains elements of the two input sequences,
-        /// combined by <paramref name="resultSelector"/>.
-        /// </returns>
-        /// <example>
-        /// <code><![CDATA[
-        /// var numbers = { 1, 2, 3 };
-        /// var letters = { "A", "B", "C", "D" };
-        /// var zipped = numbers.ZipLongest(letters, (n, l) => n + l);
-        /// ]]></code>
-        /// The <c>zipped</c> variable, when iterated over, will yield "1A",
-        /// "2B", "3C", "0D" in turn.
-        /// </example>
-        /// <remarks>
-        /// This operator uses deferred execution and streams its results.
-        /// </remarks>
-
-        public static IEnumerable<TResult> ZipLongest<TFirst, TSecond, TResult>(
-            this IEnumerable<TFirst> first,
-            IEnumerable<TSecond> second,
-            Func<TFirst, TSecond, TResult> resultSelector)
-        {
-            if (first == null) throw new ArgumentNullException(nameof(first));
-            if (second == null) throw new ArgumentNullException(nameof(second));
-            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
-
-            return ZipImpl<TFirst, TSecond, object, object, TResult>(first, second, null, null, (a, b, c, d) => resultSelector(a, b), 1);
-        }
-
-        /// <summary>
-        /// Returns a projection 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="TResult">Type of elements in result 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="resultSelector">
-        /// Function to apply to each triplet of elements.</param>
-        /// <returns>
-        /// A sequence that contains elements of the three input sequences,
-        /// combined by <paramref name="resultSelector"/>.
-        /// </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, (n, l, c) => n + l + c);
-        /// ]]></code>
-        /// The <c>zipped</c> variable, when iterated over, will yield "1Aa",
-        /// "2Bb", "3Cc", "0Dd", "0e" in turn.
-        /// </example>
-        /// <remarks>
-        /// This operator uses deferred execution and streams its results.
-        /// </remarks>
-
-        public static IEnumerable<TResult> ZipLongest<T1, T2, T3, TResult>(
-            this IEnumerable<T1> first,
-            IEnumerable<T2> second,
-            IEnumerable<T3> third,
-            Func<T1, T2, T3, TResult> resultSelector)
-        {
-            if (first == null) throw new ArgumentNullException(nameof(first));
-            if (second == null) throw new ArgumentNullException(nameof(second));
-            if (third == null) throw new ArgumentNullException(nameof(third));
-            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
-
-            return ZipImpl<T1, T2, T3, object, TResult>(first, second, third, null, (a, b, c, d) => resultSelector(a, b, c), 2);
-        }
-
-        /// <summary>
-        /// Returns a projection 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>
-        /// <typeparam name="TResult">Type of elements in result 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>
-        /// <param name="resultSelector">
-        /// Function to apply to each quadruplet of elements.</param>
-        /// <returns>
-        /// A sequence that contains elements of the four input sequences,
-        /// combined by <paramref name="resultSelector"/>.
-        /// </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, (n, l, c, f) => n + l + c + f);
-        /// ]]></code>
-        /// The <c>zipped</c> variable, when iterated over, will yield "1AaTrue",
-        /// "2BbFalse", "3CcTrue", "0DdFalse", "0eTrue", "0\0False" in turn.
-        /// </example>
-        /// <remarks>
-        /// This operator uses deferred execution and streams its results.
-        /// </remarks>
-
-        public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, TResult>(
-            this IEnumerable<T1> first,
-            IEnumerable<T2> second,
-            IEnumerable<T3> third,
-            IEnumerable<T4> fourth,
-            Func<T1, T2, T3, T4, TResult> resultSelector)
-        {
-            if (first == null) throw new ArgumentNullException(nameof(first));
-            if (second == null) throw new ArgumentNullException(nameof(second));
-            if (third == null) throw new ArgumentNullException(nameof(third));
-            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
-            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
-
-            return ZipImpl(first, second, third, fourth, resultSelector, 3);
-        }
-    }
-}
diff --git a/MoreLinq/ZipShortest.cs b/MoreLinq/ZipShortest.cs
deleted file mode 100644
index 06920e2df..000000000
--- a/MoreLinq/ZipShortest.cs
+++ /dev/null
@@ -1,185 +0,0 @@
-#region License and Terms
-// MoreLINQ - Extensions to LINQ to Objects
-// Copyright (c) 2008 Jonathan Skeet. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-#endregion
-
-namespace MoreLinq
-{
-    using System;
-    using System.Collections.Generic;
-
-    static partial class MoreEnumerable
-    {
-        /// <summary>
-        /// 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.
-        /// </summary>
-        /// <typeparam name="TFirst">Type of elements in first sequence.</typeparam>
-        /// <typeparam name="TSecond">Type of elements in second sequence.</typeparam>
-        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="first">The first sequence.</param>
-        /// <param name="second">The second sequence.</param>
-        /// <param name="resultSelector">
-        /// Function to apply to each pair of elements.</param>
-        /// <returns>
-        /// A projection of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <example>
-        /// <code><![CDATA[
-        /// var numbers = new[] { 1, 2, 3 };
-        /// var letters = new[] { "A", "B", "C", "D" };
-        /// var zipped = numbers.ZipShortest(letters, (n, l) => n + l);
-        /// ]]></code>
-        /// The <c>zipped</c> variable, when iterated over, will yield "1A", "2B", "3C", 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<TResult> ZipShortest<TFirst, TSecond, TResult>(
-            this IEnumerable<TFirst> first,
-            IEnumerable<TSecond> second,
-            Func<TFirst, TSecond, TResult> resultSelector)
-        {
-            if (first == null) throw new ArgumentNullException(nameof(first));
-            if (second == null) throw new ArgumentNullException(nameof(second));
-            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
-
-            return ZipImpl<TFirst, TSecond, object, object, TResult>(first, second, null, null, (a, b, c, d) => resultSelector(a, b));
-        }
-
-        /// <summary>
-        /// 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.
-        /// </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="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="first">First sequence</param>
-        /// <param name="second">Second sequence</param>
-        /// <param name="third">Third sequence</param>
-        /// <param name="resultSelector">
-        /// Function to apply to each triplet of elements.</param>
-        /// <returns>
-        /// A projection of tuples, where each tuple contains the N-th element
-        /// from each of the argument 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, (n, l, c) => c + n + l);
-        /// ]]></code>
-        /// The <c>zipped</c> variable, when iterated over, will yield
-        /// "98A", "100B", "102C", 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<TResult> ZipShortest<T1, T2, T3, TResult>(
-            this IEnumerable<T1> first,
-            IEnumerable<T2> second,
-            IEnumerable<T3> third,
-            Func<T1, T2, T3, TResult> resultSelector)
-        {
-            if (first == null) throw new ArgumentNullException(nameof(first));
-            if (second == null) throw new ArgumentNullException(nameof(second));
-            if (third == null) throw new ArgumentNullException(nameof(third));
-            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
-
-            return ZipImpl<T1, T2, T3, object, TResult>(first, second, third, null, (a, b, c, _) => resultSelector(a, b, c));
-        }
-
-        /// <summary>
-        /// 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.
-        /// </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>
-        /// <typeparam name="TResult">Type of elements in result 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>
-        /// <param name="resultSelector">
-        /// Function to apply to each quadruplet of elements.</param>
-        /// <returns>
-        /// A projection of tuples, where each tuple contains the N-th element
-        /// from each of the argument 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, (n, l, c, f) => n + l + c + f);
-        /// ]]></code>
-        /// The <c>zipped</c> variable, when iterated over, will yield
-        /// "1AaTrue", "2BbFalse" 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<TResult> ZipShortest<T1, T2, T3, T4, TResult>(
-            this IEnumerable<T1> first,
-            IEnumerable<T2> second,
-            IEnumerable<T3> third,
-            IEnumerable<T4> fourth,
-            Func<T1, T2, T3, T4, TResult> resultSelector)
-        {
-            if (first == null) throw new ArgumentNullException(nameof(first));
-            if (second == null) throw new ArgumentNullException(nameof(second));
-            if (third == null) throw new ArgumentNullException(nameof(third));
-            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
-            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
-
-            return ZipImpl(first, second, third, fourth, resultSelector);
-        }
-
-        static IEnumerable<TResult> ZipImpl<T1, T2, T3, T4, TResult>(
-            IEnumerable<T1> s1, IEnumerable<T2> s2,
-            IEnumerable<T3> s3, IEnumerable<T4> s4,
-            Func<T1, T2, T3, T4, TResult> resultSelector)
-        {
-            return ZipImpl(s1, s2, s3, s4, resultSelector, 0);
-        }
-    }
-}
diff --git a/README.md b/README.md
index d6923b81d..e643b9193 100644
--- a/README.md
+++ b/README.md
@@ -222,7 +222,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 14 overloads.
 
 ### Exactly
 
@@ -717,7 +717,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 14 overloads.
 
 ### ZipShortest
 
@@ -725,7 +725,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 14 overloads.
 
 
 ## Experimental Operators

From 2dd59ad1fc1e0b792007049ad1ebab7c341e680f Mon Sep 17 00:00:00 2001
From: Orace <pierre.lando@gmail.com>
Date: Mon, 4 Nov 2019 18:24:30 +0100
Subject: [PATCH 02/11] code factorisartion in CustomZip

---
 MoreLinq/Zip.g.cs | 317 +++++++---------------------------------------
 MoreLinq/Zip.g.tt |  73 +++++------
 2 files changed, 79 insertions(+), 311 deletions(-)

diff --git a/MoreLinq/Zip.g.cs b/MoreLinq/Zip.g.cs
index c2ace5253..8fcaf1ff2 100644
--- a/MoreLinq/Zip.g.cs
+++ b/MoreLinq/Zip.g.cs
@@ -2110,53 +2110,16 @@ internal static IEnumerable<TResult> CustomZip<T1, T2, TResult>(
             using var firstEnumerator = new ZipEnumerator<T1>(firstSource.GetEnumerator(), nameof(firstSource), firstSourceConfiguration);
             using var secondEnumerator = new ZipEnumerator<T2>(secondSource.GetEnumerator(), nameof(secondSource), secondSourceConfiguration);
 
-            var enumerators = new IZipEnumerator[]
-            {
+            while (MoveNext(
                 firstEnumerator,
-                secondEnumerator
-            };
-
-            for (;;)
+                secondEnumerator))
             {
-                var isEnd = true;
-                IZipEnumerator equiStopper = null;
-
-                foreach (var enumerator in enumerators)
-                {
-                    switch (enumerator.MoveNext())
-                    {
-                        case ZipEnumeratorStatus.AskForStop:
-                            yield break;
-                        case ZipEnumeratorStatus.AskForEquiStop:
-                            if (!isEnd) // there is some sequences ahead
-                            {
-                                enumerator.ThrowToShort();
-                            }
-                            equiStopper = enumerator;
-                            break;
-                        case ZipEnumeratorStatus.Continue:
-                            equiStopper?.ThrowToShort();
-                            isEnd = false;
-                            break;
-                        case ZipEnumeratorStatus.EndOfStream:
-                            break;
-                        default:
-                            throw new ArgumentOutOfRangeException();
-                    }
-                }
-
-                if (isEnd)
-                {
-                    yield break;
-                }
-
                 yield return resultSelector(
                     firstEnumerator.Current,
                     secondEnumerator.Current
                 );
             }
         }
-
         internal static IEnumerable<TResult> CustomZip<T1, T2, T3, TResult>(
             this IEnumerable<T1> firstSource, ZipSourceConfiguration<T1> firstSourceConfiguration,
             IEnumerable<T2> secondSource, ZipSourceConfiguration<T2> secondSourceConfiguration,
@@ -2167,47 +2130,11 @@ internal static IEnumerable<TResult> CustomZip<T1, T2, T3, TResult>(
             using var secondEnumerator = new ZipEnumerator<T2>(secondSource.GetEnumerator(), nameof(secondSource), secondSourceConfiguration);
             using var thirdEnumerator = new ZipEnumerator<T3>(thirdSource.GetEnumerator(), nameof(thirdSource), thirdSourceConfiguration);
 
-            var enumerators = new IZipEnumerator[]
-            {
+            while (MoveNext(
                 firstEnumerator,
                 secondEnumerator,
-                thirdEnumerator
-            };
-
-            for (;;)
+                thirdEnumerator))
             {
-                var isEnd = true;
-                IZipEnumerator equiStopper = null;
-
-                foreach (var enumerator in enumerators)
-                {
-                    switch (enumerator.MoveNext())
-                    {
-                        case ZipEnumeratorStatus.AskForStop:
-                            yield break;
-                        case ZipEnumeratorStatus.AskForEquiStop:
-                            if (!isEnd) // there is some sequences ahead
-                            {
-                                enumerator.ThrowToShort();
-                            }
-                            equiStopper = enumerator;
-                            break;
-                        case ZipEnumeratorStatus.Continue:
-                            equiStopper?.ThrowToShort();
-                            isEnd = false;
-                            break;
-                        case ZipEnumeratorStatus.EndOfStream:
-                            break;
-                        default:
-                            throw new ArgumentOutOfRangeException();
-                    }
-                }
-
-                if (isEnd)
-                {
-                    yield break;
-                }
-
                 yield return resultSelector(
                     firstEnumerator.Current,
                     secondEnumerator.Current,
@@ -2215,7 +2142,6 @@ internal static IEnumerable<TResult> CustomZip<T1, T2, T3, TResult>(
                 );
             }
         }
-
         internal static IEnumerable<TResult> CustomZip<T1, T2, T3, T4, TResult>(
             this IEnumerable<T1> firstSource, ZipSourceConfiguration<T1> firstSourceConfiguration,
             IEnumerable<T2> secondSource, ZipSourceConfiguration<T2> secondSourceConfiguration,
@@ -2228,48 +2154,12 @@ internal static IEnumerable<TResult> CustomZip<T1, T2, T3, T4, TResult>(
             using var thirdEnumerator = new ZipEnumerator<T3>(thirdSource.GetEnumerator(), nameof(thirdSource), thirdSourceConfiguration);
             using var fourthEnumerator = new ZipEnumerator<T4>(fourthSource.GetEnumerator(), nameof(fourthSource), fourthSourceConfiguration);
 
-            var enumerators = new IZipEnumerator[]
-            {
+            while (MoveNext(
                 firstEnumerator,
                 secondEnumerator,
                 thirdEnumerator,
-                fourthEnumerator
-            };
-
-            for (;;)
+                fourthEnumerator))
             {
-                var isEnd = true;
-                IZipEnumerator equiStopper = null;
-
-                foreach (var enumerator in enumerators)
-                {
-                    switch (enumerator.MoveNext())
-                    {
-                        case ZipEnumeratorStatus.AskForStop:
-                            yield break;
-                        case ZipEnumeratorStatus.AskForEquiStop:
-                            if (!isEnd) // there is some sequences ahead
-                            {
-                                enumerator.ThrowToShort();
-                            }
-                            equiStopper = enumerator;
-                            break;
-                        case ZipEnumeratorStatus.Continue:
-                            equiStopper?.ThrowToShort();
-                            isEnd = false;
-                            break;
-                        case ZipEnumeratorStatus.EndOfStream:
-                            break;
-                        default:
-                            throw new ArgumentOutOfRangeException();
-                    }
-                }
-
-                if (isEnd)
-                {
-                    yield break;
-                }
-
                 yield return resultSelector(
                     firstEnumerator.Current,
                     secondEnumerator.Current,
@@ -2278,7 +2168,6 @@ internal static IEnumerable<TResult> CustomZip<T1, T2, T3, T4, TResult>(
                 );
             }
         }
-
         internal static IEnumerable<TResult> CustomZip<T1, T2, T3, T4, T5, TResult>(
             this IEnumerable<T1> firstSource, ZipSourceConfiguration<T1> firstSourceConfiguration,
             IEnumerable<T2> secondSource, ZipSourceConfiguration<T2> secondSourceConfiguration,
@@ -2293,49 +2182,13 @@ internal static IEnumerable<TResult> CustomZip<T1, T2, T3, T4, T5, TResult>(
             using var fourthEnumerator = new ZipEnumerator<T4>(fourthSource.GetEnumerator(), nameof(fourthSource), fourthSourceConfiguration);
             using var fifthEnumerator = new ZipEnumerator<T5>(fifthSource.GetEnumerator(), nameof(fifthSource), fifthSourceConfiguration);
 
-            var enumerators = new IZipEnumerator[]
-            {
+            while (MoveNext(
                 firstEnumerator,
                 secondEnumerator,
                 thirdEnumerator,
                 fourthEnumerator,
-                fifthEnumerator
-            };
-
-            for (;;)
+                fifthEnumerator))
             {
-                var isEnd = true;
-                IZipEnumerator equiStopper = null;
-
-                foreach (var enumerator in enumerators)
-                {
-                    switch (enumerator.MoveNext())
-                    {
-                        case ZipEnumeratorStatus.AskForStop:
-                            yield break;
-                        case ZipEnumeratorStatus.AskForEquiStop:
-                            if (!isEnd) // there is some sequences ahead
-                            {
-                                enumerator.ThrowToShort();
-                            }
-                            equiStopper = enumerator;
-                            break;
-                        case ZipEnumeratorStatus.Continue:
-                            equiStopper?.ThrowToShort();
-                            isEnd = false;
-                            break;
-                        case ZipEnumeratorStatus.EndOfStream:
-                            break;
-                        default:
-                            throw new ArgumentOutOfRangeException();
-                    }
-                }
-
-                if (isEnd)
-                {
-                    yield break;
-                }
-
                 yield return resultSelector(
                     firstEnumerator.Current,
                     secondEnumerator.Current,
@@ -2345,7 +2198,6 @@ internal static IEnumerable<TResult> CustomZip<T1, T2, T3, T4, T5, TResult>(
                 );
             }
         }
-
         internal static IEnumerable<TResult> CustomZip<T1, T2, T3, T4, T5, T6, TResult>(
             this IEnumerable<T1> firstSource, ZipSourceConfiguration<T1> firstSourceConfiguration,
             IEnumerable<T2> secondSource, ZipSourceConfiguration<T2> secondSourceConfiguration,
@@ -2362,50 +2214,14 @@ internal static IEnumerable<TResult> CustomZip<T1, T2, T3, T4, T5, T6, TResult>(
             using var fifthEnumerator = new ZipEnumerator<T5>(fifthSource.GetEnumerator(), nameof(fifthSource), fifthSourceConfiguration);
             using var sixthEnumerator = new ZipEnumerator<T6>(sixthSource.GetEnumerator(), nameof(sixthSource), sixthSourceConfiguration);
 
-            var enumerators = new IZipEnumerator[]
-            {
+            while (MoveNext(
                 firstEnumerator,
                 secondEnumerator,
                 thirdEnumerator,
                 fourthEnumerator,
                 fifthEnumerator,
-                sixthEnumerator
-            };
-
-            for (;;)
+                sixthEnumerator))
             {
-                var isEnd = true;
-                IZipEnumerator equiStopper = null;
-
-                foreach (var enumerator in enumerators)
-                {
-                    switch (enumerator.MoveNext())
-                    {
-                        case ZipEnumeratorStatus.AskForStop:
-                            yield break;
-                        case ZipEnumeratorStatus.AskForEquiStop:
-                            if (!isEnd) // there is some sequences ahead
-                            {
-                                enumerator.ThrowToShort();
-                            }
-                            equiStopper = enumerator;
-                            break;
-                        case ZipEnumeratorStatus.Continue:
-                            equiStopper?.ThrowToShort();
-                            isEnd = false;
-                            break;
-                        case ZipEnumeratorStatus.EndOfStream:
-                            break;
-                        default:
-                            throw new ArgumentOutOfRangeException();
-                    }
-                }
-
-                if (isEnd)
-                {
-                    yield break;
-                }
-
                 yield return resultSelector(
                     firstEnumerator.Current,
                     secondEnumerator.Current,
@@ -2416,7 +2232,6 @@ internal static IEnumerable<TResult> CustomZip<T1, T2, T3, T4, T5, T6, TResult>(
                 );
             }
         }
-
         internal static IEnumerable<TResult> CustomZip<T1, T2, T3, T4, T5, T6, T7, TResult>(
             this IEnumerable<T1> firstSource, ZipSourceConfiguration<T1> firstSourceConfiguration,
             IEnumerable<T2> secondSource, ZipSourceConfiguration<T2> secondSourceConfiguration,
@@ -2435,51 +2250,15 @@ internal static IEnumerable<TResult> CustomZip<T1, T2, T3, T4, T5, T6, T7, TResu
             using var sixthEnumerator = new ZipEnumerator<T6>(sixthSource.GetEnumerator(), nameof(sixthSource), sixthSourceConfiguration);
             using var seventhEnumerator = new ZipEnumerator<T7>(seventhSource.GetEnumerator(), nameof(seventhSource), seventhSourceConfiguration);
 
-            var enumerators = new IZipEnumerator[]
-            {
+            while (MoveNext(
                 firstEnumerator,
                 secondEnumerator,
                 thirdEnumerator,
                 fourthEnumerator,
                 fifthEnumerator,
                 sixthEnumerator,
-                seventhEnumerator
-            };
-
-            for (;;)
+                seventhEnumerator))
             {
-                var isEnd = true;
-                IZipEnumerator equiStopper = null;
-
-                foreach (var enumerator in enumerators)
-                {
-                    switch (enumerator.MoveNext())
-                    {
-                        case ZipEnumeratorStatus.AskForStop:
-                            yield break;
-                        case ZipEnumeratorStatus.AskForEquiStop:
-                            if (!isEnd) // there is some sequences ahead
-                            {
-                                enumerator.ThrowToShort();
-                            }
-                            equiStopper = enumerator;
-                            break;
-                        case ZipEnumeratorStatus.Continue:
-                            equiStopper?.ThrowToShort();
-                            isEnd = false;
-                            break;
-                        case ZipEnumeratorStatus.EndOfStream:
-                            break;
-                        default:
-                            throw new ArgumentOutOfRangeException();
-                    }
-                }
-
-                if (isEnd)
-                {
-                    yield break;
-                }
-
                 yield return resultSelector(
                     firstEnumerator.Current,
                     secondEnumerator.Current,
@@ -2491,7 +2270,6 @@ internal static IEnumerable<TResult> CustomZip<T1, T2, T3, T4, T5, T6, T7, TResu
                 );
             }
         }
-
         internal static IEnumerable<TResult> CustomZip<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(
             this IEnumerable<T1> firstSource, ZipSourceConfiguration<T1> firstSourceConfiguration,
             IEnumerable<T2> secondSource, ZipSourceConfiguration<T2> secondSourceConfiguration,
@@ -2512,8 +2290,7 @@ internal static IEnumerable<TResult> CustomZip<T1, T2, T3, T4, T5, T6, T7, T8, T
             using var seventhEnumerator = new ZipEnumerator<T7>(seventhSource.GetEnumerator(), nameof(seventhSource), seventhSourceConfiguration);
             using var eighthEnumerator = new ZipEnumerator<T8>(eighthSource.GetEnumerator(), nameof(eighthSource), eighthSourceConfiguration);
 
-            var enumerators = new IZipEnumerator[]
-            {
+            while (MoveNext(
                 firstEnumerator,
                 secondEnumerator,
                 thirdEnumerator,
@@ -2521,43 +2298,8 @@ internal static IEnumerable<TResult> CustomZip<T1, T2, T3, T4, T5, T6, T7, T8, T
                 fifthEnumerator,
                 sixthEnumerator,
                 seventhEnumerator,
-                eighthEnumerator
-            };
-
-            for (;;)
+                eighthEnumerator))
             {
-                var isEnd = true;
-                IZipEnumerator equiStopper = null;
-
-                foreach (var enumerator in enumerators)
-                {
-                    switch (enumerator.MoveNext())
-                    {
-                        case ZipEnumeratorStatus.AskForStop:
-                            yield break;
-                        case ZipEnumeratorStatus.AskForEquiStop:
-                            if (!isEnd) // there is some sequences ahead
-                            {
-                                enumerator.ThrowToShort();
-                            }
-                            equiStopper = enumerator;
-                            break;
-                        case ZipEnumeratorStatus.Continue:
-                            equiStopper?.ThrowToShort();
-                            isEnd = false;
-                            break;
-                        case ZipEnumeratorStatus.EndOfStream:
-                            break;
-                        default:
-                            throw new ArgumentOutOfRangeException();
-                    }
-                }
-
-                if (isEnd)
-                {
-                    yield break;
-                }
-
                 yield return resultSelector(
                     firstEnumerator.Current,
                     secondEnumerator.Current,
@@ -2571,6 +2313,37 @@ internal static IEnumerable<TResult> CustomZip<T1, T2, T3, T4, T5, T6, T7, T8, T
             }
         }
 
+        private static bool MoveNext(params IZipEnumerator[] enumerators)
+        {
+            var hasNext = false;
+            IZipEnumerator equiStopper = null;
+
+            foreach (var enumerator in enumerators)
+            {
+                switch (enumerator.MoveNext())
+                {
+                    case ZipEnumeratorStatus.AskForStop:
+                        return false;
+                    case ZipEnumeratorStatus.AskForEquiStop:
+                        if (hasNext) // there is some sequences ahead
+                        {
+                            enumerator.ThrowToShort();
+                        }
+                        equiStopper = enumerator;
+                        break;
+                    case ZipEnumeratorStatus.Continue:
+                        equiStopper?.ThrowToShort();
+                        hasNext = true;
+                        break;
+                    case ZipEnumeratorStatus.EndOfStream:
+                        break;
+                    default:
+                        throw new ArgumentOutOfRangeException();
+                }
+            }
+
+            return hasNext;
+        }
     }
 
     internal interface IZipEnumerator
diff --git a/MoreLinq/Zip.g.tt b/MoreLinq/Zip.g.tt
index e58e9b54d..933d92fab 100644
--- a/MoreLinq/Zip.g.tt
+++ b/MoreLinq/Zip.g.tt
@@ -319,47 +319,11 @@ namespace MoreLinq
             using var <#= arg.Ordinal #>Enumerator = new ZipEnumerator<T<#= arg.Number #>>(<#= arg.Ordinal #>Source.GetEnumerator(), nameof(<#= arg.Ordinal #>Source), <#= arg.Ordinal #>SourceConfiguration);
 <#} #>
 
-            var enumerators = new IZipEnumerator[]
-            {
+            while (MoveNext(
 <# foreach (var arg in o.Arguments) { #>
-                <#= arg.Ordinal #>Enumerator<#= arg.Num < o.Count ? "," : "" #>
+                <#= arg.Ordinal #>Enumerator<#= arg.Num < o.Count ? "," : "))" #>
 <#}#>
-            };
-
-            for (;;)
             {
-                var isEnd = true;
-                IZipEnumerator equiStopper = null;
-
-                foreach (var enumerator in enumerators)
-                {
-                    switch (enumerator.MoveNext())
-                    {
-                        case ZipEnumeratorStatus.AskForStop:
-                            yield break;
-                        case ZipEnumeratorStatus.AskForEquiStop:
-                            if (!isEnd) // there is some sequences ahead
-                            {
-                                enumerator.ThrowToShort();
-                            }
-                            equiStopper = enumerator;
-                            break;
-                        case ZipEnumeratorStatus.Continue:
-                            equiStopper?.ThrowToShort();
-                            isEnd = false;
-                            break;
-                        case ZipEnumeratorStatus.EndOfStream:
-                            break;
-                        default:
-                            throw new ArgumentOutOfRangeException();
-                    }
-                }
-
-                if (isEnd)
-                {
-                    yield break;
-                }
-
                 yield return resultSelector(
 <# foreach (var arg in o.Arguments) { #>
                     <#= arg.Ordinal #>Enumerator.Current<#= arg.Num < o.Count ? "," : "" #>
@@ -367,8 +331,39 @@ namespace MoreLinq
                 );
             }
         }
-
 <#  } #>
+
+        private static bool MoveNext(params IZipEnumerator[] enumerators)
+        {
+            var hasNext = false;
+            IZipEnumerator equiStopper = null;
+
+            foreach (var enumerator in enumerators)
+            {
+                switch (enumerator.MoveNext())
+                {
+                    case ZipEnumeratorStatus.AskForStop:
+                        return false;
+                    case ZipEnumeratorStatus.AskForEquiStop:
+                        if (hasNext) // there is some sequences ahead
+                        {
+                            enumerator.ThrowToShort();
+                        }
+                        equiStopper = enumerator;
+                        break;
+                    case ZipEnumeratorStatus.Continue:
+                        equiStopper?.ThrowToShort();
+                        hasNext = true;
+                        break;
+                    case ZipEnumeratorStatus.EndOfStream:
+                        break;
+                    default:
+                        throw new ArgumentOutOfRangeException();
+                }
+            }
+
+            return hasNext;
+        }
     }
 
     internal interface IZipEnumerator

From 57011783fcf28d5d4307cc46b46fb40f9a29bcf6 Mon Sep 17 00:00:00 2001
From: Orace <pierre.lando@gmail.com>
Date: Tue, 5 Nov 2019 09:25:21 +0100
Subject: [PATCH 03/11] KISS for Zip

---
 MoreLinq/Zip.g.cs | 1488 +++++++++++++++++++++++----------------------
 MoreLinq/Zip.g.tt |  256 +++-----
 2 files changed, 860 insertions(+), 884 deletions(-)

diff --git a/MoreLinq/Zip.g.cs b/MoreLinq/Zip.g.cs
index 8fcaf1ff2..5136c03e3 100644
--- a/MoreLinq/Zip.g.cs
+++ b/MoreLinq/Zip.g.cs
@@ -52,10 +52,39 @@ public static IEnumerable<TResult> EquiZip<T1, T2, TResult>(
             if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.ThrowOnShort,
-                secondSource, ZipSourceConfiguration<T2>.ThrowOnShort,
-                resultSelector);
+            return _(); IEnumerable<TResult> _()
+            {
+                using var e1 = firstSource.GetEnumerator();
+                using var e2 = secondSource.GetEnumerator();
+
+                for (;;)
+                {
+                    if (e1.MoveNext())
+                    {
+                        if (e2.MoveNext())
+                        {
+                            yield return resultSelector(e1.Current,e2.Current);
+                        }
+                        else
+                        {
+                            break;
+                        }
+                    }
+                    else
+                    {
+                        if (e2.MoveNext())
+                        {
+                            break;
+                        }
+                        else
+                        {
+                            yield break;
+                        }
+                    }
+                }
+
+                throw new InvalidOperationException($"Sequences differ in length.");
+            }
         }
 
         /// <summary>
@@ -80,12 +109,9 @@ public static IEnumerable<TResult> EquiZip<T1, T2, TResult>(
             this IEnumerable<T1> firstSource,
             IEnumerable<T2> secondSource)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
-
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.ThrowOnShort,
-                secondSource, ZipSourceConfiguration<T2>.ThrowOnShort,
+            return EquiZip(
+                firstSource,
+                secondSource,
                 ValueTuple.Create);
         }
 
@@ -118,10 +144,32 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, TResult>(
             if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.PaddingWith(default),
-                secondSource, ZipSourceConfiguration<T2>.PaddingWith(default),
-                resultSelector);
+            return _(); IEnumerable<TResult> _()
+            {
+                IEnumerator<T1> e1 = null;
+                IEnumerator<T2> e2 = null;
+
+                try
+                {
+                    e1 = firstSource.GetEnumerator();
+                    e2 = secondSource.GetEnumerator();
+
+                    var v1 = default(T1);
+                    var v2 = default(T2);
+
+                    while (
+                        ZipHelper.MoveNextOrDefault<T1>(ref e1, ref v1) | 
+                        ZipHelper.MoveNextOrDefault<T2>(ref e2, ref v2))
+                    {
+                        yield return resultSelector(v1,v2);
+                    }
+                }
+                finally
+                {
+                    e1?.Dispose();
+                    e2?.Dispose();
+                }
+            }
         }
 
         /// <summary>
@@ -145,12 +193,9 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, TResult>(
             this IEnumerable<T1> firstSource,
             IEnumerable<T2> secondSource)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
-
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.PaddingWith(default),
-                secondSource, ZipSourceConfiguration<T2>.PaddingWith(default),
+            return ZipLongest(
+                firstSource,
+                secondSource,
                 ValueTuple.Create);
         }
 
@@ -188,10 +233,16 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, TResult>(
             if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.StopOnShort,
-                secondSource, ZipSourceConfiguration<T2>.StopOnShort,
-                resultSelector);
+            return _(); IEnumerable<TResult> _()
+            {
+                using var e1 = firstSource.GetEnumerator();
+                using var e2 = secondSource.GetEnumerator();
+
+                while (e1.MoveNext() && e2.MoveNext())
+                {
+                    yield return resultSelector(e1.Current,e2.Current);
+                }
+            }
         }
 
         /// <summary>
@@ -220,12 +271,9 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, TResult>(
             this IEnumerable<T1> firstSource,
             IEnumerable<T2> secondSource)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
-
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.StopOnShort,
-                secondSource, ZipSourceConfiguration<T2>.StopOnShort,
+            return ZipShortest(
+                firstSource,
+                secondSource,
                 ValueTuple.Create);
         }
 
@@ -263,11 +311,40 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, TResult>(
             if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.ThrowOnShort,
-                secondSource, ZipSourceConfiguration<T2>.ThrowOnShort,
-                thirdSource, ZipSourceConfiguration<T3>.ThrowOnShort,
-                resultSelector);
+            return _(); IEnumerable<TResult> _()
+            {
+                using var e1 = firstSource.GetEnumerator();
+                using var e2 = secondSource.GetEnumerator();
+                using var e3 = thirdSource.GetEnumerator();
+
+                for (;;)
+                {
+                    if (e1.MoveNext())
+                    {
+                        if (e2.MoveNext() && e3.MoveNext())
+                        {
+                            yield return resultSelector(e1.Current,e2.Current,e3.Current);
+                        }
+                        else
+                        {
+                            break;
+                        }
+                    }
+                    else
+                    {
+                        if (e2.MoveNext() || e3.MoveNext())
+                        {
+                            break;
+                        }
+                        else
+                        {
+                            yield break;
+                        }
+                    }
+                }
+
+                throw new InvalidOperationException($"Sequences differ in length.");
+            }
         }
 
         /// <summary>
@@ -295,14 +372,10 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, TResult>(
             IEnumerable<T2> secondSource,
             IEnumerable<T3> thirdSource)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
-            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
-
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.ThrowOnShort,
-                secondSource, ZipSourceConfiguration<T2>.ThrowOnShort,
-                thirdSource, ZipSourceConfiguration<T3>.ThrowOnShort,
+            return EquiZip(
+                firstSource,
+                secondSource,
+                thirdSource,
                 ValueTuple.Create);
         }
 
@@ -339,11 +412,37 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, TResult>(
             if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.PaddingWith(default),
-                secondSource, ZipSourceConfiguration<T2>.PaddingWith(default),
-                thirdSource, ZipSourceConfiguration<T3>.PaddingWith(default),
-                resultSelector);
+            return _(); IEnumerable<TResult> _()
+            {
+                IEnumerator<T1> e1 = null;
+                IEnumerator<T2> e2 = null;
+                IEnumerator<T3> e3 = null;
+
+                try
+                {
+                    e1 = firstSource.GetEnumerator();
+                    e2 = secondSource.GetEnumerator();
+                    e3 = thirdSource.GetEnumerator();
+
+                    var v1 = default(T1);
+                    var v2 = default(T2);
+                    var v3 = default(T3);
+
+                    while (
+                        ZipHelper.MoveNextOrDefault<T1>(ref e1, ref v1) | 
+                        ZipHelper.MoveNextOrDefault<T2>(ref e2, ref v2) | 
+                        ZipHelper.MoveNextOrDefault<T3>(ref e3, ref v3))
+                    {
+                        yield return resultSelector(v1,v2,v3);
+                    }
+                }
+                finally
+                {
+                    e1?.Dispose();
+                    e2?.Dispose();
+                    e3?.Dispose();
+                }
+            }
         }
 
         /// <summary>
@@ -370,14 +469,10 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, TResult>(
             IEnumerable<T2> secondSource,
             IEnumerable<T3> thirdSource)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
-            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
-
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.PaddingWith(default),
-                secondSource, ZipSourceConfiguration<T2>.PaddingWith(default),
-                thirdSource, ZipSourceConfiguration<T3>.PaddingWith(default),
+            return ZipLongest(
+                firstSource,
+                secondSource,
+                thirdSource,
                 ValueTuple.Create);
         }
 
@@ -419,11 +514,17 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, TResult>(
             if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.StopOnShort,
-                secondSource, ZipSourceConfiguration<T2>.StopOnShort,
-                thirdSource, ZipSourceConfiguration<T3>.StopOnShort,
-                resultSelector);
+            return _(); IEnumerable<TResult> _()
+            {
+                using var e1 = firstSource.GetEnumerator();
+                using var e2 = secondSource.GetEnumerator();
+                using var e3 = thirdSource.GetEnumerator();
+
+                while (e1.MoveNext() && e2.MoveNext() && e3.MoveNext())
+                {
+                    yield return resultSelector(e1.Current,e2.Current,e3.Current);
+                }
+            }
         }
 
         /// <summary>
@@ -455,14 +556,10 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, TResult>(
             IEnumerable<T2> secondSource,
             IEnumerable<T3> thirdSource)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
-            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
-
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.StopOnShort,
-                secondSource, ZipSourceConfiguration<T2>.StopOnShort,
-                thirdSource, ZipSourceConfiguration<T3>.StopOnShort,
+            return ZipShortest(
+                firstSource,
+                secondSource,
+                thirdSource,
                 ValueTuple.Create);
         }
 
@@ -504,12 +601,41 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, TResult>(
             if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.ThrowOnShort,
-                secondSource, ZipSourceConfiguration<T2>.ThrowOnShort,
-                thirdSource, ZipSourceConfiguration<T3>.ThrowOnShort,
-                fourthSource, ZipSourceConfiguration<T4>.ThrowOnShort,
-                resultSelector);
+            return _(); IEnumerable<TResult> _()
+            {
+                using var e1 = firstSource.GetEnumerator();
+                using var e2 = secondSource.GetEnumerator();
+                using var e3 = thirdSource.GetEnumerator();
+                using var e4 = fourthSource.GetEnumerator();
+
+                for (;;)
+                {
+                    if (e1.MoveNext())
+                    {
+                        if (e2.MoveNext() && e3.MoveNext() && e4.MoveNext())
+                        {
+                            yield return resultSelector(e1.Current,e2.Current,e3.Current,e4.Current);
+                        }
+                        else
+                        {
+                            break;
+                        }
+                    }
+                    else
+                    {
+                        if (e2.MoveNext() || e3.MoveNext() || e4.MoveNext())
+                        {
+                            break;
+                        }
+                        else
+                        {
+                            yield break;
+                        }
+                    }
+                }
+
+                throw new InvalidOperationException($"Sequences differ in length.");
+            }
         }
 
         /// <summary>
@@ -540,16 +666,11 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, TResult>(
             IEnumerable<T3> thirdSource,
             IEnumerable<T4> fourthSource)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
-            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
-            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
-
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.ThrowOnShort,
-                secondSource, ZipSourceConfiguration<T2>.ThrowOnShort,
-                thirdSource, ZipSourceConfiguration<T3>.ThrowOnShort,
-                fourthSource, ZipSourceConfiguration<T4>.ThrowOnShort,
+            return EquiZip(
+                firstSource,
+                secondSource,
+                thirdSource,
+                fourthSource,
                 ValueTuple.Create);
         }
 
@@ -590,12 +711,42 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, TResult>(
             if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.PaddingWith(default),
-                secondSource, ZipSourceConfiguration<T2>.PaddingWith(default),
-                thirdSource, ZipSourceConfiguration<T3>.PaddingWith(default),
-                fourthSource, ZipSourceConfiguration<T4>.PaddingWith(default),
-                resultSelector);
+            return _(); IEnumerable<TResult> _()
+            {
+                IEnumerator<T1> e1 = null;
+                IEnumerator<T2> e2 = null;
+                IEnumerator<T3> e3 = null;
+                IEnumerator<T4> e4 = null;
+
+                try
+                {
+                    e1 = firstSource.GetEnumerator();
+                    e2 = secondSource.GetEnumerator();
+                    e3 = thirdSource.GetEnumerator();
+                    e4 = fourthSource.GetEnumerator();
+
+                    var v1 = default(T1);
+                    var v2 = default(T2);
+                    var v3 = default(T3);
+                    var v4 = default(T4);
+
+                    while (
+                        ZipHelper.MoveNextOrDefault<T1>(ref e1, ref v1) | 
+                        ZipHelper.MoveNextOrDefault<T2>(ref e2, ref v2) | 
+                        ZipHelper.MoveNextOrDefault<T3>(ref e3, ref v3) | 
+                        ZipHelper.MoveNextOrDefault<T4>(ref e4, ref v4))
+                    {
+                        yield return resultSelector(v1,v2,v3,v4);
+                    }
+                }
+                finally
+                {
+                    e1?.Dispose();
+                    e2?.Dispose();
+                    e3?.Dispose();
+                    e4?.Dispose();
+                }
+            }
         }
 
         /// <summary>
@@ -625,16 +776,11 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, TResult>(
             IEnumerable<T3> thirdSource,
             IEnumerable<T4> fourthSource)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
-            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
-            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
-
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.PaddingWith(default),
-                secondSource, ZipSourceConfiguration<T2>.PaddingWith(default),
-                thirdSource, ZipSourceConfiguration<T3>.PaddingWith(default),
-                fourthSource, ZipSourceConfiguration<T4>.PaddingWith(default),
+            return ZipLongest(
+                firstSource,
+                secondSource,
+                thirdSource,
+                fourthSource,
                 ValueTuple.Create);
         }
 
@@ -680,12 +826,18 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, TResult>(
             if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.StopOnShort,
-                secondSource, ZipSourceConfiguration<T2>.StopOnShort,
-                thirdSource, ZipSourceConfiguration<T3>.StopOnShort,
-                fourthSource, ZipSourceConfiguration<T4>.StopOnShort,
-                resultSelector);
+            return _(); IEnumerable<TResult> _()
+            {
+                using var e1 = firstSource.GetEnumerator();
+                using var e2 = secondSource.GetEnumerator();
+                using var e3 = thirdSource.GetEnumerator();
+                using var e4 = fourthSource.GetEnumerator();
+
+                while (e1.MoveNext() && e2.MoveNext() && e3.MoveNext() && e4.MoveNext())
+                {
+                    yield return resultSelector(e1.Current,e2.Current,e3.Current,e4.Current);
+                }
+            }
         }
 
         /// <summary>
@@ -720,16 +872,11 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, TResult>(
             IEnumerable<T3> thirdSource,
             IEnumerable<T4> fourthSource)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
-            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
-            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
-
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.StopOnShort,
-                secondSource, ZipSourceConfiguration<T2>.StopOnShort,
-                thirdSource, ZipSourceConfiguration<T3>.StopOnShort,
-                fourthSource, ZipSourceConfiguration<T4>.StopOnShort,
+            return ZipShortest(
+                firstSource,
+                secondSource,
+                thirdSource,
+                fourthSource,
                 ValueTuple.Create);
         }
 
@@ -775,13 +922,42 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, TResult>(
             if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.ThrowOnShort,
-                secondSource, ZipSourceConfiguration<T2>.ThrowOnShort,
-                thirdSource, ZipSourceConfiguration<T3>.ThrowOnShort,
-                fourthSource, ZipSourceConfiguration<T4>.ThrowOnShort,
-                fifthSource, ZipSourceConfiguration<T5>.ThrowOnShort,
-                resultSelector);
+            return _(); IEnumerable<TResult> _()
+            {
+                using var e1 = firstSource.GetEnumerator();
+                using var e2 = secondSource.GetEnumerator();
+                using var e3 = thirdSource.GetEnumerator();
+                using var e4 = fourthSource.GetEnumerator();
+                using var e5 = fifthSource.GetEnumerator();
+
+                for (;;)
+                {
+                    if (e1.MoveNext())
+                    {
+                        if (e2.MoveNext() && e3.MoveNext() && e4.MoveNext() && e5.MoveNext())
+                        {
+                            yield return resultSelector(e1.Current,e2.Current,e3.Current,e4.Current,e5.Current);
+                        }
+                        else
+                        {
+                            break;
+                        }
+                    }
+                    else
+                    {
+                        if (e2.MoveNext() || e3.MoveNext() || e4.MoveNext() || e5.MoveNext())
+                        {
+                            break;
+                        }
+                        else
+                        {
+                            yield break;
+                        }
+                    }
+                }
+
+                throw new InvalidOperationException($"Sequences differ in length.");
+            }
         }
 
         /// <summary>
@@ -815,18 +991,12 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, TResult>(
             IEnumerable<T4> fourthSource,
             IEnumerable<T5> fifthSource)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
-            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
-            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
-            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
-
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.ThrowOnShort,
-                secondSource, ZipSourceConfiguration<T2>.ThrowOnShort,
-                thirdSource, ZipSourceConfiguration<T3>.ThrowOnShort,
-                fourthSource, ZipSourceConfiguration<T4>.ThrowOnShort,
-                fifthSource, ZipSourceConfiguration<T5>.ThrowOnShort,
+            return EquiZip(
+                firstSource,
+                secondSource,
+                thirdSource,
+                fourthSource,
+                fifthSource,
                 ValueTuple.Create);
         }
 
@@ -871,13 +1041,47 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, TResult>(
             if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.PaddingWith(default),
-                secondSource, ZipSourceConfiguration<T2>.PaddingWith(default),
-                thirdSource, ZipSourceConfiguration<T3>.PaddingWith(default),
-                fourthSource, ZipSourceConfiguration<T4>.PaddingWith(default),
-                fifthSource, ZipSourceConfiguration<T5>.PaddingWith(default),
-                resultSelector);
+            return _(); IEnumerable<TResult> _()
+            {
+                IEnumerator<T1> e1 = null;
+                IEnumerator<T2> e2 = null;
+                IEnumerator<T3> e3 = null;
+                IEnumerator<T4> e4 = null;
+                IEnumerator<T5> e5 = null;
+
+                try
+                {
+                    e1 = firstSource.GetEnumerator();
+                    e2 = secondSource.GetEnumerator();
+                    e3 = thirdSource.GetEnumerator();
+                    e4 = fourthSource.GetEnumerator();
+                    e5 = fifthSource.GetEnumerator();
+
+                    var v1 = default(T1);
+                    var v2 = default(T2);
+                    var v3 = default(T3);
+                    var v4 = default(T4);
+                    var v5 = default(T5);
+
+                    while (
+                        ZipHelper.MoveNextOrDefault<T1>(ref e1, ref v1) | 
+                        ZipHelper.MoveNextOrDefault<T2>(ref e2, ref v2) | 
+                        ZipHelper.MoveNextOrDefault<T3>(ref e3, ref v3) | 
+                        ZipHelper.MoveNextOrDefault<T4>(ref e4, ref v4) | 
+                        ZipHelper.MoveNextOrDefault<T5>(ref e5, ref v5))
+                    {
+                        yield return resultSelector(v1,v2,v3,v4,v5);
+                    }
+                }
+                finally
+                {
+                    e1?.Dispose();
+                    e2?.Dispose();
+                    e3?.Dispose();
+                    e4?.Dispose();
+                    e5?.Dispose();
+                }
+            }
         }
 
         /// <summary>
@@ -910,18 +1114,12 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, TResult>(
             IEnumerable<T4> fourthSource,
             IEnumerable<T5> fifthSource)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
-            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
-            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
-            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
-
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.PaddingWith(default),
-                secondSource, ZipSourceConfiguration<T2>.PaddingWith(default),
-                thirdSource, ZipSourceConfiguration<T3>.PaddingWith(default),
-                fourthSource, ZipSourceConfiguration<T4>.PaddingWith(default),
-                fifthSource, ZipSourceConfiguration<T5>.PaddingWith(default),
+            return ZipLongest(
+                firstSource,
+                secondSource,
+                thirdSource,
+                fourthSource,
+                fifthSource,
                 ValueTuple.Create);
         }
 
@@ -971,13 +1169,19 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, TResult>(
             if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.StopOnShort,
-                secondSource, ZipSourceConfiguration<T2>.StopOnShort,
-                thirdSource, ZipSourceConfiguration<T3>.StopOnShort,
-                fourthSource, ZipSourceConfiguration<T4>.StopOnShort,
-                fifthSource, ZipSourceConfiguration<T5>.StopOnShort,
-                resultSelector);
+            return _(); IEnumerable<TResult> _()
+            {
+                using var e1 = firstSource.GetEnumerator();
+                using var e2 = secondSource.GetEnumerator();
+                using var e3 = thirdSource.GetEnumerator();
+                using var e4 = fourthSource.GetEnumerator();
+                using var e5 = fifthSource.GetEnumerator();
+
+                while (e1.MoveNext() && e2.MoveNext() && e3.MoveNext() && e4.MoveNext() && e5.MoveNext())
+                {
+                    yield return resultSelector(e1.Current,e2.Current,e3.Current,e4.Current,e5.Current);
+                }
+            }
         }
 
         /// <summary>
@@ -1015,18 +1219,12 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, TResult>(
             IEnumerable<T4> fourthSource,
             IEnumerable<T5> fifthSource)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
-            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
-            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
-            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
-
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.StopOnShort,
-                secondSource, ZipSourceConfiguration<T2>.StopOnShort,
-                thirdSource, ZipSourceConfiguration<T3>.StopOnShort,
-                fourthSource, ZipSourceConfiguration<T4>.StopOnShort,
-                fifthSource, ZipSourceConfiguration<T5>.StopOnShort,
+            return ZipShortest(
+                firstSource,
+                secondSource,
+                thirdSource,
+                fourthSource,
+                fifthSource,
                 ValueTuple.Create);
         }
 
@@ -1076,14 +1274,43 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, TResult>(
             if (sixthSource == null) throw new ArgumentNullException(nameof(sixthSource));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.ThrowOnShort,
-                secondSource, ZipSourceConfiguration<T2>.ThrowOnShort,
-                thirdSource, ZipSourceConfiguration<T3>.ThrowOnShort,
-                fourthSource, ZipSourceConfiguration<T4>.ThrowOnShort,
-                fifthSource, ZipSourceConfiguration<T5>.ThrowOnShort,
-                sixthSource, ZipSourceConfiguration<T6>.ThrowOnShort,
-                resultSelector);
+            return _(); IEnumerable<TResult> _()
+            {
+                using var e1 = firstSource.GetEnumerator();
+                using var e2 = secondSource.GetEnumerator();
+                using var e3 = thirdSource.GetEnumerator();
+                using var e4 = fourthSource.GetEnumerator();
+                using var e5 = fifthSource.GetEnumerator();
+                using var e6 = sixthSource.GetEnumerator();
+
+                for (;;)
+                {
+                    if (e1.MoveNext())
+                    {
+                        if (e2.MoveNext() && e3.MoveNext() && e4.MoveNext() && e5.MoveNext() && e6.MoveNext())
+                        {
+                            yield return resultSelector(e1.Current,e2.Current,e3.Current,e4.Current,e5.Current,e6.Current);
+                        }
+                        else
+                        {
+                            break;
+                        }
+                    }
+                    else
+                    {
+                        if (e2.MoveNext() || e3.MoveNext() || e4.MoveNext() || e5.MoveNext() || e6.MoveNext())
+                        {
+                            break;
+                        }
+                        else
+                        {
+                            yield break;
+                        }
+                    }
+                }
+
+                throw new InvalidOperationException($"Sequences differ in length.");
+            }
         }
 
         /// <summary>
@@ -1120,20 +1347,13 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, TResult>(
             IEnumerable<T5> fifthSource,
             IEnumerable<T6> sixthSource)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
-            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
-            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
-            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
-            if (sixthSource == null) throw new ArgumentNullException(nameof(sixthSource));
-
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.ThrowOnShort,
-                secondSource, ZipSourceConfiguration<T2>.ThrowOnShort,
-                thirdSource, ZipSourceConfiguration<T3>.ThrowOnShort,
-                fourthSource, ZipSourceConfiguration<T4>.ThrowOnShort,
-                fifthSource, ZipSourceConfiguration<T5>.ThrowOnShort,
-                sixthSource, ZipSourceConfiguration<T6>.ThrowOnShort,
+            return EquiZip(
+                firstSource,
+                secondSource,
+                thirdSource,
+                fourthSource,
+                fifthSource,
+                sixthSource,
                 ValueTuple.Create);
         }
 
@@ -1182,14 +1402,52 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, TResult>(
             if (sixthSource == null) throw new ArgumentNullException(nameof(sixthSource));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.PaddingWith(default),
-                secondSource, ZipSourceConfiguration<T2>.PaddingWith(default),
-                thirdSource, ZipSourceConfiguration<T3>.PaddingWith(default),
-                fourthSource, ZipSourceConfiguration<T4>.PaddingWith(default),
-                fifthSource, ZipSourceConfiguration<T5>.PaddingWith(default),
-                sixthSource, ZipSourceConfiguration<T6>.PaddingWith(default),
-                resultSelector);
+            return _(); IEnumerable<TResult> _()
+            {
+                IEnumerator<T1> e1 = null;
+                IEnumerator<T2> e2 = null;
+                IEnumerator<T3> e3 = null;
+                IEnumerator<T4> e4 = null;
+                IEnumerator<T5> e5 = null;
+                IEnumerator<T6> e6 = null;
+
+                try
+                {
+                    e1 = firstSource.GetEnumerator();
+                    e2 = secondSource.GetEnumerator();
+                    e3 = thirdSource.GetEnumerator();
+                    e4 = fourthSource.GetEnumerator();
+                    e5 = fifthSource.GetEnumerator();
+                    e6 = sixthSource.GetEnumerator();
+
+                    var v1 = default(T1);
+                    var v2 = default(T2);
+                    var v3 = default(T3);
+                    var v4 = default(T4);
+                    var v5 = default(T5);
+                    var v6 = default(T6);
+
+                    while (
+                        ZipHelper.MoveNextOrDefault<T1>(ref e1, ref v1) | 
+                        ZipHelper.MoveNextOrDefault<T2>(ref e2, ref v2) | 
+                        ZipHelper.MoveNextOrDefault<T3>(ref e3, ref v3) | 
+                        ZipHelper.MoveNextOrDefault<T4>(ref e4, ref v4) | 
+                        ZipHelper.MoveNextOrDefault<T5>(ref e5, ref v5) | 
+                        ZipHelper.MoveNextOrDefault<T6>(ref e6, ref v6))
+                    {
+                        yield return resultSelector(v1,v2,v3,v4,v5,v6);
+                    }
+                }
+                finally
+                {
+                    e1?.Dispose();
+                    e2?.Dispose();
+                    e3?.Dispose();
+                    e4?.Dispose();
+                    e5?.Dispose();
+                    e6?.Dispose();
+                }
+            }
         }
 
         /// <summary>
@@ -1225,20 +1483,13 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, TResult>(
             IEnumerable<T5> fifthSource,
             IEnumerable<T6> sixthSource)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
-            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
-            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
-            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
-            if (sixthSource == null) throw new ArgumentNullException(nameof(sixthSource));
-
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.PaddingWith(default),
-                secondSource, ZipSourceConfiguration<T2>.PaddingWith(default),
-                thirdSource, ZipSourceConfiguration<T3>.PaddingWith(default),
-                fourthSource, ZipSourceConfiguration<T4>.PaddingWith(default),
-                fifthSource, ZipSourceConfiguration<T5>.PaddingWith(default),
-                sixthSource, ZipSourceConfiguration<T6>.PaddingWith(default),
+            return ZipLongest(
+                firstSource,
+                secondSource,
+                thirdSource,
+                fourthSource,
+                fifthSource,
+                sixthSource,
                 ValueTuple.Create);
         }
 
@@ -1292,14 +1543,20 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, TResult>(
             if (sixthSource == null) throw new ArgumentNullException(nameof(sixthSource));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.StopOnShort,
-                secondSource, ZipSourceConfiguration<T2>.StopOnShort,
-                thirdSource, ZipSourceConfiguration<T3>.StopOnShort,
-                fourthSource, ZipSourceConfiguration<T4>.StopOnShort,
-                fifthSource, ZipSourceConfiguration<T5>.StopOnShort,
-                sixthSource, ZipSourceConfiguration<T6>.StopOnShort,
-                resultSelector);
+            return _(); IEnumerable<TResult> _()
+            {
+                using var e1 = firstSource.GetEnumerator();
+                using var e2 = secondSource.GetEnumerator();
+                using var e3 = thirdSource.GetEnumerator();
+                using var e4 = fourthSource.GetEnumerator();
+                using var e5 = fifthSource.GetEnumerator();
+                using var e6 = sixthSource.GetEnumerator();
+
+                while (e1.MoveNext() && e2.MoveNext() && e3.MoveNext() && e4.MoveNext() && e5.MoveNext() && e6.MoveNext())
+                {
+                    yield return resultSelector(e1.Current,e2.Current,e3.Current,e4.Current,e5.Current,e6.Current);
+                }
+            }
         }
 
         /// <summary>
@@ -1340,20 +1597,13 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, TResult>(
             IEnumerable<T5> fifthSource,
             IEnumerable<T6> sixthSource)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
-            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
-            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
-            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
-            if (sixthSource == null) throw new ArgumentNullException(nameof(sixthSource));
-
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.StopOnShort,
-                secondSource, ZipSourceConfiguration<T2>.StopOnShort,
-                thirdSource, ZipSourceConfiguration<T3>.StopOnShort,
-                fourthSource, ZipSourceConfiguration<T4>.StopOnShort,
-                fifthSource, ZipSourceConfiguration<T5>.StopOnShort,
-                sixthSource, ZipSourceConfiguration<T6>.StopOnShort,
+            return ZipShortest(
+                firstSource,
+                secondSource,
+                thirdSource,
+                fourthSource,
+                fifthSource,
+                sixthSource,
                 ValueTuple.Create);
         }
 
@@ -1407,15 +1657,44 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, T7, TResult>(
             if (seventhSource == null) throw new ArgumentNullException(nameof(seventhSource));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.ThrowOnShort,
-                secondSource, ZipSourceConfiguration<T2>.ThrowOnShort,
-                thirdSource, ZipSourceConfiguration<T3>.ThrowOnShort,
-                fourthSource, ZipSourceConfiguration<T4>.ThrowOnShort,
-                fifthSource, ZipSourceConfiguration<T5>.ThrowOnShort,
-                sixthSource, ZipSourceConfiguration<T6>.ThrowOnShort,
-                seventhSource, ZipSourceConfiguration<T7>.ThrowOnShort,
-                resultSelector);
+            return _(); IEnumerable<TResult> _()
+            {
+                using var e1 = firstSource.GetEnumerator();
+                using var e2 = secondSource.GetEnumerator();
+                using var e3 = thirdSource.GetEnumerator();
+                using var e4 = fourthSource.GetEnumerator();
+                using var e5 = fifthSource.GetEnumerator();
+                using var e6 = sixthSource.GetEnumerator();
+                using var e7 = seventhSource.GetEnumerator();
+
+                for (;;)
+                {
+                    if (e1.MoveNext())
+                    {
+                        if (e2.MoveNext() && e3.MoveNext() && e4.MoveNext() && e5.MoveNext() && e6.MoveNext() && e7.MoveNext())
+                        {
+                            yield return resultSelector(e1.Current,e2.Current,e3.Current,e4.Current,e5.Current,e6.Current,e7.Current);
+                        }
+                        else
+                        {
+                            break;
+                        }
+                    }
+                    else
+                    {
+                        if (e2.MoveNext() || e3.MoveNext() || e4.MoveNext() || e5.MoveNext() || e6.MoveNext() || e7.MoveNext())
+                        {
+                            break;
+                        }
+                        else
+                        {
+                            yield break;
+                        }
+                    }
+                }
+
+                throw new InvalidOperationException($"Sequences differ in length.");
+            }
         }
 
         /// <summary>
@@ -1455,22 +1734,14 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, T7, TResult>(
             IEnumerable<T6> sixthSource,
             IEnumerable<T7> seventhSource)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
-            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
-            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
-            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
-            if (sixthSource == null) throw new ArgumentNullException(nameof(sixthSource));
-            if (seventhSource == null) throw new ArgumentNullException(nameof(seventhSource));
-
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.ThrowOnShort,
-                secondSource, ZipSourceConfiguration<T2>.ThrowOnShort,
-                thirdSource, ZipSourceConfiguration<T3>.ThrowOnShort,
-                fourthSource, ZipSourceConfiguration<T4>.ThrowOnShort,
-                fifthSource, ZipSourceConfiguration<T5>.ThrowOnShort,
-                sixthSource, ZipSourceConfiguration<T6>.ThrowOnShort,
-                seventhSource, ZipSourceConfiguration<T7>.ThrowOnShort,
+            return EquiZip(
+                firstSource,
+                secondSource,
+                thirdSource,
+                fourthSource,
+                fifthSource,
+                sixthSource,
+                seventhSource,
                 ValueTuple.Create);
         }
 
@@ -1523,15 +1794,57 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, T7, TResul
             if (seventhSource == null) throw new ArgumentNullException(nameof(seventhSource));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.PaddingWith(default),
-                secondSource, ZipSourceConfiguration<T2>.PaddingWith(default),
-                thirdSource, ZipSourceConfiguration<T3>.PaddingWith(default),
-                fourthSource, ZipSourceConfiguration<T4>.PaddingWith(default),
-                fifthSource, ZipSourceConfiguration<T5>.PaddingWith(default),
-                sixthSource, ZipSourceConfiguration<T6>.PaddingWith(default),
-                seventhSource, ZipSourceConfiguration<T7>.PaddingWith(default),
-                resultSelector);
+            return _(); IEnumerable<TResult> _()
+            {
+                IEnumerator<T1> e1 = null;
+                IEnumerator<T2> e2 = null;
+                IEnumerator<T3> e3 = null;
+                IEnumerator<T4> e4 = null;
+                IEnumerator<T5> e5 = null;
+                IEnumerator<T6> e6 = null;
+                IEnumerator<T7> e7 = null;
+
+                try
+                {
+                    e1 = firstSource.GetEnumerator();
+                    e2 = secondSource.GetEnumerator();
+                    e3 = thirdSource.GetEnumerator();
+                    e4 = fourthSource.GetEnumerator();
+                    e5 = fifthSource.GetEnumerator();
+                    e6 = sixthSource.GetEnumerator();
+                    e7 = seventhSource.GetEnumerator();
+
+                    var v1 = default(T1);
+                    var v2 = default(T2);
+                    var v3 = default(T3);
+                    var v4 = default(T4);
+                    var v5 = default(T5);
+                    var v6 = default(T6);
+                    var v7 = default(T7);
+
+                    while (
+                        ZipHelper.MoveNextOrDefault<T1>(ref e1, ref v1) | 
+                        ZipHelper.MoveNextOrDefault<T2>(ref e2, ref v2) | 
+                        ZipHelper.MoveNextOrDefault<T3>(ref e3, ref v3) | 
+                        ZipHelper.MoveNextOrDefault<T4>(ref e4, ref v4) | 
+                        ZipHelper.MoveNextOrDefault<T5>(ref e5, ref v5) | 
+                        ZipHelper.MoveNextOrDefault<T6>(ref e6, ref v6) | 
+                        ZipHelper.MoveNextOrDefault<T7>(ref e7, ref v7))
+                    {
+                        yield return resultSelector(v1,v2,v3,v4,v5,v6,v7);
+                    }
+                }
+                finally
+                {
+                    e1?.Dispose();
+                    e2?.Dispose();
+                    e3?.Dispose();
+                    e4?.Dispose();
+                    e5?.Dispose();
+                    e6?.Dispose();
+                    e7?.Dispose();
+                }
+            }
         }
 
         /// <summary>
@@ -1570,22 +1883,14 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, T7, TResul
             IEnumerable<T6> sixthSource,
             IEnumerable<T7> seventhSource)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
-            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
-            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
-            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
-            if (sixthSource == null) throw new ArgumentNullException(nameof(sixthSource));
-            if (seventhSource == null) throw new ArgumentNullException(nameof(seventhSource));
-
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.PaddingWith(default),
-                secondSource, ZipSourceConfiguration<T2>.PaddingWith(default),
-                thirdSource, ZipSourceConfiguration<T3>.PaddingWith(default),
-                fourthSource, ZipSourceConfiguration<T4>.PaddingWith(default),
-                fifthSource, ZipSourceConfiguration<T5>.PaddingWith(default),
-                sixthSource, ZipSourceConfiguration<T6>.PaddingWith(default),
-                seventhSource, ZipSourceConfiguration<T7>.PaddingWith(default),
+            return ZipLongest(
+                firstSource,
+                secondSource,
+                thirdSource,
+                fourthSource,
+                fifthSource,
+                sixthSource,
+                seventhSource,
                 ValueTuple.Create);
         }
 
@@ -1643,15 +1948,21 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, T7, TResu
             if (seventhSource == null) throw new ArgumentNullException(nameof(seventhSource));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.StopOnShort,
-                secondSource, ZipSourceConfiguration<T2>.StopOnShort,
-                thirdSource, ZipSourceConfiguration<T3>.StopOnShort,
-                fourthSource, ZipSourceConfiguration<T4>.StopOnShort,
-                fifthSource, ZipSourceConfiguration<T5>.StopOnShort,
-                sixthSource, ZipSourceConfiguration<T6>.StopOnShort,
-                seventhSource, ZipSourceConfiguration<T7>.StopOnShort,
-                resultSelector);
+            return _(); IEnumerable<TResult> _()
+            {
+                using var e1 = firstSource.GetEnumerator();
+                using var e2 = secondSource.GetEnumerator();
+                using var e3 = thirdSource.GetEnumerator();
+                using var e4 = fourthSource.GetEnumerator();
+                using var e5 = fifthSource.GetEnumerator();
+                using var e6 = sixthSource.GetEnumerator();
+                using var e7 = seventhSource.GetEnumerator();
+
+                while (e1.MoveNext() && e2.MoveNext() && e3.MoveNext() && e4.MoveNext() && e5.MoveNext() && e6.MoveNext() && e7.MoveNext())
+                {
+                    yield return resultSelector(e1.Current,e2.Current,e3.Current,e4.Current,e5.Current,e6.Current,e7.Current);
+                }
+            }
         }
 
         /// <summary>
@@ -1695,22 +2006,14 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, T7, TResu
             IEnumerable<T6> sixthSource,
             IEnumerable<T7> seventhSource)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
-            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
-            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
-            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
-            if (sixthSource == null) throw new ArgumentNullException(nameof(sixthSource));
-            if (seventhSource == null) throw new ArgumentNullException(nameof(seventhSource));
-
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.StopOnShort,
-                secondSource, ZipSourceConfiguration<T2>.StopOnShort,
-                thirdSource, ZipSourceConfiguration<T3>.StopOnShort,
-                fourthSource, ZipSourceConfiguration<T4>.StopOnShort,
-                fifthSource, ZipSourceConfiguration<T5>.StopOnShort,
-                sixthSource, ZipSourceConfiguration<T6>.StopOnShort,
-                seventhSource, ZipSourceConfiguration<T7>.StopOnShort,
+            return ZipShortest(
+                firstSource,
+                secondSource,
+                thirdSource,
+                fourthSource,
+                fifthSource,
+                sixthSource,
+                seventhSource,
                 ValueTuple.Create);
         }
 
@@ -1768,16 +2071,45 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, T7, T8, TResu
             if (eighthSource == null) throw new ArgumentNullException(nameof(eighthSource));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.ThrowOnShort,
-                secondSource, ZipSourceConfiguration<T2>.ThrowOnShort,
-                thirdSource, ZipSourceConfiguration<T3>.ThrowOnShort,
-                fourthSource, ZipSourceConfiguration<T4>.ThrowOnShort,
-                fifthSource, ZipSourceConfiguration<T5>.ThrowOnShort,
-                sixthSource, ZipSourceConfiguration<T6>.ThrowOnShort,
-                seventhSource, ZipSourceConfiguration<T7>.ThrowOnShort,
-                eighthSource, ZipSourceConfiguration<T8>.ThrowOnShort,
-                resultSelector);
+            return _(); IEnumerable<TResult> _()
+            {
+                using var e1 = firstSource.GetEnumerator();
+                using var e2 = secondSource.GetEnumerator();
+                using var e3 = thirdSource.GetEnumerator();
+                using var e4 = fourthSource.GetEnumerator();
+                using var e5 = fifthSource.GetEnumerator();
+                using var e6 = sixthSource.GetEnumerator();
+                using var e7 = seventhSource.GetEnumerator();
+                using var e8 = eighthSource.GetEnumerator();
+
+                for (;;)
+                {
+                    if (e1.MoveNext())
+                    {
+                        if (e2.MoveNext() && e3.MoveNext() && e4.MoveNext() && e5.MoveNext() && e6.MoveNext() && e7.MoveNext() && e8.MoveNext())
+                        {
+                            yield return resultSelector(e1.Current,e2.Current,e3.Current,e4.Current,e5.Current,e6.Current,e7.Current,e8.Current);
+                        }
+                        else
+                        {
+                            break;
+                        }
+                    }
+                    else
+                    {
+                        if (e2.MoveNext() || e3.MoveNext() || e4.MoveNext() || e5.MoveNext() || e6.MoveNext() || e7.MoveNext() || e8.MoveNext())
+                        {
+                            break;
+                        }
+                        else
+                        {
+                            yield break;
+                        }
+                    }
+                }
+
+                throw new InvalidOperationException($"Sequences differ in length.");
+            }
         }
 
         /// <summary>
@@ -1820,24 +2152,15 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, T7, T8, TResu
             IEnumerable<T7> seventhSource,
             IEnumerable<T8> eighthSource)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
-            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
-            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
-            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
-            if (sixthSource == null) throw new ArgumentNullException(nameof(sixthSource));
-            if (seventhSource == null) throw new ArgumentNullException(nameof(seventhSource));
-            if (eighthSource == null) throw new ArgumentNullException(nameof(eighthSource));
-
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.ThrowOnShort,
-                secondSource, ZipSourceConfiguration<T2>.ThrowOnShort,
-                thirdSource, ZipSourceConfiguration<T3>.ThrowOnShort,
-                fourthSource, ZipSourceConfiguration<T4>.ThrowOnShort,
-                fifthSource, ZipSourceConfiguration<T5>.ThrowOnShort,
-                sixthSource, ZipSourceConfiguration<T6>.ThrowOnShort,
-                seventhSource, ZipSourceConfiguration<T7>.ThrowOnShort,
-                eighthSource, ZipSourceConfiguration<T8>.ThrowOnShort,
+            return EquiZip(
+                firstSource,
+                secondSource,
+                thirdSource,
+                fourthSource,
+                fifthSource,
+                sixthSource,
+                seventhSource,
+                eighthSource,
                 ValueTuple.Create);
         }
 
@@ -1894,16 +2217,62 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, T7, T8, TR
             if (eighthSource == null) throw new ArgumentNullException(nameof(eighthSource));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.PaddingWith(default),
-                secondSource, ZipSourceConfiguration<T2>.PaddingWith(default),
-                thirdSource, ZipSourceConfiguration<T3>.PaddingWith(default),
-                fourthSource, ZipSourceConfiguration<T4>.PaddingWith(default),
-                fifthSource, ZipSourceConfiguration<T5>.PaddingWith(default),
-                sixthSource, ZipSourceConfiguration<T6>.PaddingWith(default),
-                seventhSource, ZipSourceConfiguration<T7>.PaddingWith(default),
-                eighthSource, ZipSourceConfiguration<T8>.PaddingWith(default),
-                resultSelector);
+            return _(); IEnumerable<TResult> _()
+            {
+                IEnumerator<T1> e1 = null;
+                IEnumerator<T2> e2 = null;
+                IEnumerator<T3> e3 = null;
+                IEnumerator<T4> e4 = null;
+                IEnumerator<T5> e5 = null;
+                IEnumerator<T6> e6 = null;
+                IEnumerator<T7> e7 = null;
+                IEnumerator<T8> e8 = null;
+
+                try
+                {
+                    e1 = firstSource.GetEnumerator();
+                    e2 = secondSource.GetEnumerator();
+                    e3 = thirdSource.GetEnumerator();
+                    e4 = fourthSource.GetEnumerator();
+                    e5 = fifthSource.GetEnumerator();
+                    e6 = sixthSource.GetEnumerator();
+                    e7 = seventhSource.GetEnumerator();
+                    e8 = eighthSource.GetEnumerator();
+
+                    var v1 = default(T1);
+                    var v2 = default(T2);
+                    var v3 = default(T3);
+                    var v4 = default(T4);
+                    var v5 = default(T5);
+                    var v6 = default(T6);
+                    var v7 = default(T7);
+                    var v8 = default(T8);
+
+                    while (
+                        ZipHelper.MoveNextOrDefault<T1>(ref e1, ref v1) | 
+                        ZipHelper.MoveNextOrDefault<T2>(ref e2, ref v2) | 
+                        ZipHelper.MoveNextOrDefault<T3>(ref e3, ref v3) | 
+                        ZipHelper.MoveNextOrDefault<T4>(ref e4, ref v4) | 
+                        ZipHelper.MoveNextOrDefault<T5>(ref e5, ref v5) | 
+                        ZipHelper.MoveNextOrDefault<T6>(ref e6, ref v6) | 
+                        ZipHelper.MoveNextOrDefault<T7>(ref e7, ref v7) | 
+                        ZipHelper.MoveNextOrDefault<T8>(ref e8, ref v8))
+                    {
+                        yield return resultSelector(v1,v2,v3,v4,v5,v6,v7,v8);
+                    }
+                }
+                finally
+                {
+                    e1?.Dispose();
+                    e2?.Dispose();
+                    e3?.Dispose();
+                    e4?.Dispose();
+                    e5?.Dispose();
+                    e6?.Dispose();
+                    e7?.Dispose();
+                    e8?.Dispose();
+                }
+            }
         }
 
         /// <summary>
@@ -1945,24 +2314,15 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, T7, T8, TR
             IEnumerable<T7> seventhSource,
             IEnumerable<T8> eighthSource)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
-            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
-            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
-            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
-            if (sixthSource == null) throw new ArgumentNullException(nameof(sixthSource));
-            if (seventhSource == null) throw new ArgumentNullException(nameof(seventhSource));
-            if (eighthSource == null) throw new ArgumentNullException(nameof(eighthSource));
-
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.PaddingWith(default),
-                secondSource, ZipSourceConfiguration<T2>.PaddingWith(default),
-                thirdSource, ZipSourceConfiguration<T3>.PaddingWith(default),
-                fourthSource, ZipSourceConfiguration<T4>.PaddingWith(default),
-                fifthSource, ZipSourceConfiguration<T5>.PaddingWith(default),
-                sixthSource, ZipSourceConfiguration<T6>.PaddingWith(default),
-                seventhSource, ZipSourceConfiguration<T7>.PaddingWith(default),
-                eighthSource, ZipSourceConfiguration<T8>.PaddingWith(default),
+            return ZipLongest(
+                firstSource,
+                secondSource,
+                thirdSource,
+                fourthSource,
+                fifthSource,
+                sixthSource,
+                seventhSource,
+                eighthSource,
                 ValueTuple.Create);
         }
 
@@ -2024,16 +2384,22 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, T7, T8, T
             if (eighthSource == null) throw new ArgumentNullException(nameof(eighthSource));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.StopOnShort,
-                secondSource, ZipSourceConfiguration<T2>.StopOnShort,
-                thirdSource, ZipSourceConfiguration<T3>.StopOnShort,
-                fourthSource, ZipSourceConfiguration<T4>.StopOnShort,
-                fifthSource, ZipSourceConfiguration<T5>.StopOnShort,
-                sixthSource, ZipSourceConfiguration<T6>.StopOnShort,
-                seventhSource, ZipSourceConfiguration<T7>.StopOnShort,
-                eighthSource, ZipSourceConfiguration<T8>.StopOnShort,
-                resultSelector);
+            return _(); IEnumerable<TResult> _()
+            {
+                using var e1 = firstSource.GetEnumerator();
+                using var e2 = secondSource.GetEnumerator();
+                using var e3 = thirdSource.GetEnumerator();
+                using var e4 = fourthSource.GetEnumerator();
+                using var e5 = fifthSource.GetEnumerator();
+                using var e6 = sixthSource.GetEnumerator();
+                using var e7 = seventhSource.GetEnumerator();
+                using var e8 = eighthSource.GetEnumerator();
+
+                while (e1.MoveNext() && e2.MoveNext() && e3.MoveNext() && e4.MoveNext() && e5.MoveNext() && e6.MoveNext() && e7.MoveNext() && e8.MoveNext())
+                {
+                    yield return resultSelector(e1.Current,e2.Current,e3.Current,e4.Current,e5.Current,e6.Current,e7.Current,e8.Current);
+                }
+            }
         }
 
         /// <summary>
@@ -2080,354 +2446,38 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, T7, T8, T
             IEnumerable<T7> seventhSource,
             IEnumerable<T8> eighthSource)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
-            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
-            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
-            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
-            if (sixthSource == null) throw new ArgumentNullException(nameof(sixthSource));
-            if (seventhSource == null) throw new ArgumentNullException(nameof(seventhSource));
-            if (eighthSource == null) throw new ArgumentNullException(nameof(eighthSource));
-
-            return CustomZip(
-                firstSource, ZipSourceConfiguration<T1>.StopOnShort,
-                secondSource, ZipSourceConfiguration<T2>.StopOnShort,
-                thirdSource, ZipSourceConfiguration<T3>.StopOnShort,
-                fourthSource, ZipSourceConfiguration<T4>.StopOnShort,
-                fifthSource, ZipSourceConfiguration<T5>.StopOnShort,
-                sixthSource, ZipSourceConfiguration<T6>.StopOnShort,
-                seventhSource, ZipSourceConfiguration<T7>.StopOnShort,
-                eighthSource, ZipSourceConfiguration<T8>.StopOnShort,
+            return ZipShortest(
+                firstSource,
+                secondSource,
+                thirdSource,
+                fourthSource,
+                fifthSource,
+                sixthSource,
+                seventhSource,
+                eighthSource,
                 ValueTuple.Create);
         }
 
-
-        internal static IEnumerable<TResult> CustomZip<T1, T2, TResult>(
-            this IEnumerable<T1> firstSource, ZipSourceConfiguration<T1> firstSourceConfiguration,
-            IEnumerable<T2> secondSource, ZipSourceConfiguration<T2> secondSourceConfiguration,
-            Func<T1, T2, TResult> resultSelector)
-        {
-            using var firstEnumerator = new ZipEnumerator<T1>(firstSource.GetEnumerator(), nameof(firstSource), firstSourceConfiguration);
-            using var secondEnumerator = new ZipEnumerator<T2>(secondSource.GetEnumerator(), nameof(secondSource), secondSourceConfiguration);
-
-            while (MoveNext(
-                firstEnumerator,
-                secondEnumerator))
-            {
-                yield return resultSelector(
-                    firstEnumerator.Current,
-                    secondEnumerator.Current
-                );
-            }
-        }
-        internal static IEnumerable<TResult> CustomZip<T1, T2, T3, TResult>(
-            this IEnumerable<T1> firstSource, ZipSourceConfiguration<T1> firstSourceConfiguration,
-            IEnumerable<T2> secondSource, ZipSourceConfiguration<T2> secondSourceConfiguration,
-            IEnumerable<T3> thirdSource, ZipSourceConfiguration<T3> thirdSourceConfiguration,
-            Func<T1, T2, T3, TResult> resultSelector)
-        {
-            using var firstEnumerator = new ZipEnumerator<T1>(firstSource.GetEnumerator(), nameof(firstSource), firstSourceConfiguration);
-            using var secondEnumerator = new ZipEnumerator<T2>(secondSource.GetEnumerator(), nameof(secondSource), secondSourceConfiguration);
-            using var thirdEnumerator = new ZipEnumerator<T3>(thirdSource.GetEnumerator(), nameof(thirdSource), thirdSourceConfiguration);
-
-            while (MoveNext(
-                firstEnumerator,
-                secondEnumerator,
-                thirdEnumerator))
-            {
-                yield return resultSelector(
-                    firstEnumerator.Current,
-                    secondEnumerator.Current,
-                    thirdEnumerator.Current
-                );
-            }
-        }
-        internal static IEnumerable<TResult> CustomZip<T1, T2, T3, T4, TResult>(
-            this IEnumerable<T1> firstSource, ZipSourceConfiguration<T1> firstSourceConfiguration,
-            IEnumerable<T2> secondSource, ZipSourceConfiguration<T2> secondSourceConfiguration,
-            IEnumerable<T3> thirdSource, ZipSourceConfiguration<T3> thirdSourceConfiguration,
-            IEnumerable<T4> fourthSource, ZipSourceConfiguration<T4> fourthSourceConfiguration,
-            Func<T1, T2, T3, T4, TResult> resultSelector)
-        {
-            using var firstEnumerator = new ZipEnumerator<T1>(firstSource.GetEnumerator(), nameof(firstSource), firstSourceConfiguration);
-            using var secondEnumerator = new ZipEnumerator<T2>(secondSource.GetEnumerator(), nameof(secondSource), secondSourceConfiguration);
-            using var thirdEnumerator = new ZipEnumerator<T3>(thirdSource.GetEnumerator(), nameof(thirdSource), thirdSourceConfiguration);
-            using var fourthEnumerator = new ZipEnumerator<T4>(fourthSource.GetEnumerator(), nameof(fourthSource), fourthSourceConfiguration);
-
-            while (MoveNext(
-                firstEnumerator,
-                secondEnumerator,
-                thirdEnumerator,
-                fourthEnumerator))
-            {
-                yield return resultSelector(
-                    firstEnumerator.Current,
-                    secondEnumerator.Current,
-                    thirdEnumerator.Current,
-                    fourthEnumerator.Current
-                );
-            }
-        }
-        internal static IEnumerable<TResult> CustomZip<T1, T2, T3, T4, T5, TResult>(
-            this IEnumerable<T1> firstSource, ZipSourceConfiguration<T1> firstSourceConfiguration,
-            IEnumerable<T2> secondSource, ZipSourceConfiguration<T2> secondSourceConfiguration,
-            IEnumerable<T3> thirdSource, ZipSourceConfiguration<T3> thirdSourceConfiguration,
-            IEnumerable<T4> fourthSource, ZipSourceConfiguration<T4> fourthSourceConfiguration,
-            IEnumerable<T5> fifthSource, ZipSourceConfiguration<T5> fifthSourceConfiguration,
-            Func<T1, T2, T3, T4, T5, TResult> resultSelector)
-        {
-            using var firstEnumerator = new ZipEnumerator<T1>(firstSource.GetEnumerator(), nameof(firstSource), firstSourceConfiguration);
-            using var secondEnumerator = new ZipEnumerator<T2>(secondSource.GetEnumerator(), nameof(secondSource), secondSourceConfiguration);
-            using var thirdEnumerator = new ZipEnumerator<T3>(thirdSource.GetEnumerator(), nameof(thirdSource), thirdSourceConfiguration);
-            using var fourthEnumerator = new ZipEnumerator<T4>(fourthSource.GetEnumerator(), nameof(fourthSource), fourthSourceConfiguration);
-            using var fifthEnumerator = new ZipEnumerator<T5>(fifthSource.GetEnumerator(), nameof(fifthSource), fifthSourceConfiguration);
-
-            while (MoveNext(
-                firstEnumerator,
-                secondEnumerator,
-                thirdEnumerator,
-                fourthEnumerator,
-                fifthEnumerator))
-            {
-                yield return resultSelector(
-                    firstEnumerator.Current,
-                    secondEnumerator.Current,
-                    thirdEnumerator.Current,
-                    fourthEnumerator.Current,
-                    fifthEnumerator.Current
-                );
-            }
-        }
-        internal static IEnumerable<TResult> CustomZip<T1, T2, T3, T4, T5, T6, TResult>(
-            this IEnumerable<T1> firstSource, ZipSourceConfiguration<T1> firstSourceConfiguration,
-            IEnumerable<T2> secondSource, ZipSourceConfiguration<T2> secondSourceConfiguration,
-            IEnumerable<T3> thirdSource, ZipSourceConfiguration<T3> thirdSourceConfiguration,
-            IEnumerable<T4> fourthSource, ZipSourceConfiguration<T4> fourthSourceConfiguration,
-            IEnumerable<T5> fifthSource, ZipSourceConfiguration<T5> fifthSourceConfiguration,
-            IEnumerable<T6> sixthSource, ZipSourceConfiguration<T6> sixthSourceConfiguration,
-            Func<T1, T2, T3, T4, T5, T6, TResult> resultSelector)
-        {
-            using var firstEnumerator = new ZipEnumerator<T1>(firstSource.GetEnumerator(), nameof(firstSource), firstSourceConfiguration);
-            using var secondEnumerator = new ZipEnumerator<T2>(secondSource.GetEnumerator(), nameof(secondSource), secondSourceConfiguration);
-            using var thirdEnumerator = new ZipEnumerator<T3>(thirdSource.GetEnumerator(), nameof(thirdSource), thirdSourceConfiguration);
-            using var fourthEnumerator = new ZipEnumerator<T4>(fourthSource.GetEnumerator(), nameof(fourthSource), fourthSourceConfiguration);
-            using var fifthEnumerator = new ZipEnumerator<T5>(fifthSource.GetEnumerator(), nameof(fifthSource), fifthSourceConfiguration);
-            using var sixthEnumerator = new ZipEnumerator<T6>(sixthSource.GetEnumerator(), nameof(sixthSource), sixthSourceConfiguration);
-
-            while (MoveNext(
-                firstEnumerator,
-                secondEnumerator,
-                thirdEnumerator,
-                fourthEnumerator,
-                fifthEnumerator,
-                sixthEnumerator))
-            {
-                yield return resultSelector(
-                    firstEnumerator.Current,
-                    secondEnumerator.Current,
-                    thirdEnumerator.Current,
-                    fourthEnumerator.Current,
-                    fifthEnumerator.Current,
-                    sixthEnumerator.Current
-                );
-            }
-        }
-        internal static IEnumerable<TResult> CustomZip<T1, T2, T3, T4, T5, T6, T7, TResult>(
-            this IEnumerable<T1> firstSource, ZipSourceConfiguration<T1> firstSourceConfiguration,
-            IEnumerable<T2> secondSource, ZipSourceConfiguration<T2> secondSourceConfiguration,
-            IEnumerable<T3> thirdSource, ZipSourceConfiguration<T3> thirdSourceConfiguration,
-            IEnumerable<T4> fourthSource, ZipSourceConfiguration<T4> fourthSourceConfiguration,
-            IEnumerable<T5> fifthSource, ZipSourceConfiguration<T5> fifthSourceConfiguration,
-            IEnumerable<T6> sixthSource, ZipSourceConfiguration<T6> sixthSourceConfiguration,
-            IEnumerable<T7> seventhSource, ZipSourceConfiguration<T7> seventhSourceConfiguration,
-            Func<T1, T2, T3, T4, T5, T6, T7, TResult> resultSelector)
-        {
-            using var firstEnumerator = new ZipEnumerator<T1>(firstSource.GetEnumerator(), nameof(firstSource), firstSourceConfiguration);
-            using var secondEnumerator = new ZipEnumerator<T2>(secondSource.GetEnumerator(), nameof(secondSource), secondSourceConfiguration);
-            using var thirdEnumerator = new ZipEnumerator<T3>(thirdSource.GetEnumerator(), nameof(thirdSource), thirdSourceConfiguration);
-            using var fourthEnumerator = new ZipEnumerator<T4>(fourthSource.GetEnumerator(), nameof(fourthSource), fourthSourceConfiguration);
-            using var fifthEnumerator = new ZipEnumerator<T5>(fifthSource.GetEnumerator(), nameof(fifthSource), fifthSourceConfiguration);
-            using var sixthEnumerator = new ZipEnumerator<T6>(sixthSource.GetEnumerator(), nameof(sixthSource), sixthSourceConfiguration);
-            using var seventhEnumerator = new ZipEnumerator<T7>(seventhSource.GetEnumerator(), nameof(seventhSource), seventhSourceConfiguration);
-
-            while (MoveNext(
-                firstEnumerator,
-                secondEnumerator,
-                thirdEnumerator,
-                fourthEnumerator,
-                fifthEnumerator,
-                sixthEnumerator,
-                seventhEnumerator))
-            {
-                yield return resultSelector(
-                    firstEnumerator.Current,
-                    secondEnumerator.Current,
-                    thirdEnumerator.Current,
-                    fourthEnumerator.Current,
-                    fifthEnumerator.Current,
-                    sixthEnumerator.Current,
-                    seventhEnumerator.Current
-                );
-            }
-        }
-        internal static IEnumerable<TResult> CustomZip<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(
-            this IEnumerable<T1> firstSource, ZipSourceConfiguration<T1> firstSourceConfiguration,
-            IEnumerable<T2> secondSource, ZipSourceConfiguration<T2> secondSourceConfiguration,
-            IEnumerable<T3> thirdSource, ZipSourceConfiguration<T3> thirdSourceConfiguration,
-            IEnumerable<T4> fourthSource, ZipSourceConfiguration<T4> fourthSourceConfiguration,
-            IEnumerable<T5> fifthSource, ZipSourceConfiguration<T5> fifthSourceConfiguration,
-            IEnumerable<T6> sixthSource, ZipSourceConfiguration<T6> sixthSourceConfiguration,
-            IEnumerable<T7> seventhSource, ZipSourceConfiguration<T7> seventhSourceConfiguration,
-            IEnumerable<T8> eighthSource, ZipSourceConfiguration<T8> eighthSourceConfiguration,
-            Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> resultSelector)
-        {
-            using var firstEnumerator = new ZipEnumerator<T1>(firstSource.GetEnumerator(), nameof(firstSource), firstSourceConfiguration);
-            using var secondEnumerator = new ZipEnumerator<T2>(secondSource.GetEnumerator(), nameof(secondSource), secondSourceConfiguration);
-            using var thirdEnumerator = new ZipEnumerator<T3>(thirdSource.GetEnumerator(), nameof(thirdSource), thirdSourceConfiguration);
-            using var fourthEnumerator = new ZipEnumerator<T4>(fourthSource.GetEnumerator(), nameof(fourthSource), fourthSourceConfiguration);
-            using var fifthEnumerator = new ZipEnumerator<T5>(fifthSource.GetEnumerator(), nameof(fifthSource), fifthSourceConfiguration);
-            using var sixthEnumerator = new ZipEnumerator<T6>(sixthSource.GetEnumerator(), nameof(sixthSource), sixthSourceConfiguration);
-            using var seventhEnumerator = new ZipEnumerator<T7>(seventhSource.GetEnumerator(), nameof(seventhSource), seventhSourceConfiguration);
-            using var eighthEnumerator = new ZipEnumerator<T8>(eighthSource.GetEnumerator(), nameof(eighthSource), eighthSourceConfiguration);
-
-            while (MoveNext(
-                firstEnumerator,
-                secondEnumerator,
-                thirdEnumerator,
-                fourthEnumerator,
-                fifthEnumerator,
-                sixthEnumerator,
-                seventhEnumerator,
-                eighthEnumerator))
-            {
-                yield return resultSelector(
-                    firstEnumerator.Current,
-                    secondEnumerator.Current,
-                    thirdEnumerator.Current,
-                    fourthEnumerator.Current,
-                    fifthEnumerator.Current,
-                    sixthEnumerator.Current,
-                    seventhEnumerator.Current,
-                    eighthEnumerator.Current
-                );
-            }
-        }
-
-        private static bool MoveNext(params IZipEnumerator[] enumerators)
+        static class ZipHelper
         {
-            var hasNext = false;
-            IZipEnumerator equiStopper = null;
-
-            foreach (var enumerator in enumerators)
+            public static bool MoveNextOrDefault<T>(ref IEnumerator<T> enumerator, ref T value)
             {
-                switch (enumerator.MoveNext())
+                if (enumerator == null)
                 {
-                    case ZipEnumeratorStatus.AskForStop:
-                        return false;
-                    case ZipEnumeratorStatus.AskForEquiStop:
-                        if (hasNext) // there is some sequences ahead
-                        {
-                            enumerator.ThrowToShort();
-                        }
-                        equiStopper = enumerator;
-                        break;
-                    case ZipEnumeratorStatus.Continue:
-                        equiStopper?.ThrowToShort();
-                        hasNext = true;
-                        break;
-                    case ZipEnumeratorStatus.EndOfStream:
-                        break;
-                    default:
-                        throw new ArgumentOutOfRangeException();
+                    return false;
                 }
-            }
-
-            return hasNext;
-        }
-    }
-
-    internal interface IZipEnumerator
-    {
-        ZipEnumeratorStatus MoveNext();
-        void ThrowToShort();
-    }
-
-    internal class ZipEnumerator<T> : IZipEnumerator, IDisposable
-    {
-        private readonly ZipSourceConfiguration<T> _configuration;
-        private readonly string _name;
-        private IEnumerator<T> _source;
 
-        public ZipEnumerator(IEnumerator<T> source, string name, ZipSourceConfiguration<T> configuration)
-        {
-            _source = source;
-            _name = name;
-            _configuration = configuration;
-        }
-
-        public T Current => _source == null ? _configuration.PaddingValue : _source.Current;
-
-        public void Dispose() => _source?.Dispose();
-
-        public ZipEnumeratorStatus MoveNext()
-        {
-            if (_source?.MoveNext() == false)
-            {
-                _source.Dispose();
-                _source = null;
-            }
-
-            if (_source != null)
-            {
-                return ZipEnumeratorStatus.Continue;
-            }
+                if (enumerator.MoveNext())
+                {
+                    value = enumerator.Current;
+                    return true;
+                }
 
-            switch (_configuration.Behavior)
-            {
-                case ZipEnumeratorBehavior.StopOnShort:
-                    return ZipEnumeratorStatus.AskForStop;
-                case ZipEnumeratorBehavior.Padding:
-                    return ZipEnumeratorStatus.EndOfStream;
-                case ZipEnumeratorBehavior.ThrowOnShort:
-                    return ZipEnumeratorStatus.AskForEquiStop;
-                default:
-                    throw new ArgumentOutOfRangeException();
+                enumerator.Dispose();
+                enumerator = null;
+                value = default;
+                return false;
             }
         }
-
-        public void Reset() => _source.Reset();
-
-        public void ThrowToShort() => throw new InvalidOperationException($"{_name} sequence too short.");
-    }
-
-    internal enum ZipEnumeratorBehavior
-    {
-        StopOnShort,
-        ThrowOnShort,
-        Padding
-    }
-
-    internal enum ZipEnumeratorStatus
-    {
-        AskForStop,
-        AskForEquiStop,
-        Continue,
-        EndOfStream
-    }
-
-    internal class ZipSourceConfiguration<T>
-    {
-        public static ZipSourceConfiguration<T> StopOnShort { get; } = new ZipSourceConfiguration<T>(ZipEnumeratorBehavior.StopOnShort, default);
-        public static ZipSourceConfiguration<T> ThrowOnShort { get; } = new ZipSourceConfiguration<T>(ZipEnumeratorBehavior.ThrowOnShort, default);
-        public static ZipSourceConfiguration<T> PaddingWith(T paddingValue) => new ZipSourceConfiguration<T>(ZipEnumeratorBehavior.Padding, paddingValue);
-
-        ZipSourceConfiguration(ZipEnumeratorBehavior behavior, T paddingValue)
-        {
-            Behavior = behavior;
-            PaddingValue = paddingValue;
-        }
-
-        public ZipEnumeratorBehavior Behavior { get; }
-        public T PaddingValue { get; }
     }
 }
diff --git a/MoreLinq/Zip.g.tt b/MoreLinq/Zip.g.tt
index 933d92fab..fb16b1369 100644
--- a/MoreLinq/Zip.g.tt
+++ b/MoreLinq/Zip.g.tt
@@ -101,11 +101,40 @@ namespace MoreLinq
 <#} #>
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
-            return CustomZip(
+            return _(); IEnumerable<TResult> _()
+            {
 <# foreach (var arg in o.Arguments) { #>
-                <#= arg.Ordinal #>Source, ZipSourceConfiguration<T<#= arg.Number #>>.ThrowOnShort,
-<#}#>
-                resultSelector);
+                using var e<#= arg.Number #> = <#= arg.Ordinal #>Source.GetEnumerator();
+<#} #>
+
+                for (;;)
+                {
+                    if (e<#= o.Arguments.First().Number #>.MoveNext())
+                    {
+                        if (<# foreach (var arg in o.Arguments.Skip(1)) { #>e<#= arg.Number #>.MoveNext()<#= arg.Num < o.Count ? " && " : "" #><#}#>)
+                        {
+                            yield return resultSelector(<# foreach (var arg in o.Arguments) { #>e<#= arg.Number #>.Current<#= arg.Num < o.Count ? "," : "" #><#}#>);
+                        }
+                        else
+                        {
+                            break;
+                        }
+                    }
+                    else
+                    {
+                        if (<# foreach (var arg in o.Arguments.Skip(1)) { #>e<#= arg.Number #>.MoveNext()<#= arg.Num < o.Count ? " || " : "" #><#}#>)
+                        {
+                            break;
+                        }
+                        else
+                        {
+                            yield break;
+                        }
+                    }
+                }
+
+                throw new InvalidOperationException($"Sequences differ in length.");
+            }
         }
 
         /// <summary>
@@ -133,13 +162,9 @@ namespace MoreLinq
             <#= arg.Num == 1 ? "this " : "" #>IEnumerable<T<#= arg.Number #>> <#= arg.Ordinal #>Source<#= arg.Num < o.Count ? "," : ")" #>
 <#}#>
         {
+            return EquiZip(
 <# foreach (var arg in o.Arguments) { #>
-            if (<#= arg.Ordinal #>Source == null) throw new ArgumentNullException(nameof(<#= arg.Ordinal #>Source));
-<#} #>
-
-            return CustomZip(
-<# foreach (var arg in o.Arguments) { #>
-                <#= arg.Ordinal #>Source, ZipSourceConfiguration<T<#= arg.Number #>>.ThrowOnShort,
+                <#= arg.Ordinal #>Source,
 <#}#>
                 ValueTuple.Create);
         }
@@ -177,11 +202,37 @@ namespace MoreLinq
 <#} #>
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
-            return CustomZip(
+            return _(); IEnumerable<TResult> _()
+            {
+<# foreach (var arg in o.Arguments) { #>
+                IEnumerator<T<#= arg.Number #>> e<#= arg.Number #> = null;
+<#} #>
+
+                try
+                {
 <# foreach (var arg in o.Arguments) { #>
-                <#= arg.Ordinal #>Source, ZipSourceConfiguration<T<#= arg.Number #>>.PaddingWith(default),
+                    e<#= arg.Number #> = <#= arg.Ordinal #>Source.GetEnumerator();
+<#} #>
+
+<# foreach (var arg in o.Arguments) { #>
+                    var v<#= arg.Number #> = default(T<#= arg.Number #>);
+<#} #>
+
+                    while (
+<# foreach (var arg in o.Arguments) { #>
+                        ZipHelper.MoveNextOrDefault<T<#= arg.Number #>>(ref e<#= arg.Number #>, ref v<#= arg.Number #>)<#= arg.Num < o.Count ? " | " : ")" #>
 <#}#>
-                resultSelector);
+                    {
+                        yield return resultSelector(<# foreach (var arg in o.Arguments) { #>v<#= arg.Number #><#= arg.Num < o.Count ? "," : "" #><#}#>);
+                    }
+                }
+                finally
+                {
+<# foreach (var arg in o.Arguments) { #>
+                    e<#= arg.Number #>?.Dispose();
+<#} #>
+                }
+            }
         }
 
         /// <summary>
@@ -208,13 +259,9 @@ namespace MoreLinq
             <#= arg.Num == 1 ? "this " : "" #>IEnumerable<T<#= arg.Number #>> <#= arg.Ordinal #>Source<#= arg.Num < o.Count ? "," : ")" #>
 <#}#>
         {
+            return ZipLongest(
 <# foreach (var arg in o.Arguments) { #>
-            if (<#= arg.Ordinal #>Source == null) throw new ArgumentNullException(nameof(<#= arg.Ordinal #>Source));
-<#} #>
-
-            return CustomZip(
-<# foreach (var arg in o.Arguments) { #>
-                <#= arg.Ordinal #>Source, ZipSourceConfiguration<T<#= arg.Number #>>.PaddingWith(default),
+                <#= arg.Ordinal #>Source,
 <#}#>
                 ValueTuple.Create);
         }
@@ -257,11 +304,17 @@ namespace MoreLinq
 <#} #>
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
-            return CustomZip(
+            return _(); IEnumerable<TResult> _()
+            {
 <# foreach (var arg in o.Arguments) { #>
-                <#= arg.Ordinal #>Source, ZipSourceConfiguration<T<#= arg.Number #>>.StopOnShort,
-<#}#>
-                resultSelector);
+                using var e<#= arg.Number #> = <#= arg.Ordinal #>Source.GetEnumerator();
+<#} #>
+
+                while (<# foreach (var arg in o.Arguments) { #>e<#= arg.Number #>.MoveNext()<#= arg.Num < o.Count ? " && " : "" #><#}#>)
+                {
+                    yield return resultSelector(<# foreach (var arg in o.Arguments) { #>e<#= arg.Number #>.Current<#= arg.Num < o.Count ? "," : "" #><#}#>);
+                }
+            }
         }
 
         /// <summary>
@@ -293,161 +346,34 @@ namespace MoreLinq
             <#= arg.Num == 1 ? "this " : "" #>IEnumerable<T<#= arg.Number #>> <#= arg.Ordinal #>Source<#= arg.Num < o.Count ? "," : ")" #>
 <#}#>
         {
+            return ZipShortest(
 <# foreach (var arg in o.Arguments) { #>
-            if (<#= arg.Ordinal #>Source == null) throw new ArgumentNullException(nameof(<#= arg.Ordinal #>Source));
-<#} #>
-
-            return CustomZip(
-<# foreach (var arg in o.Arguments) { #>
-                <#= arg.Ordinal #>Source, ZipSourceConfiguration<T<#= arg.Number #>>.StopOnShort,
+                <#= arg.Ordinal #>Source,
 <#}#>
                 ValueTuple.Create);
         }
 
 <#  } #>
-
-<#  foreach (var o in overloads)
-    {
-#>
-        internal static IEnumerable<TResult> CustomZip<<#= o.Types#>, TResult>(
-<# foreach (var arg in o.Arguments) { #>
-            <#= arg.Num == 1 ? "this " : "" #>IEnumerable<T<#= arg.Number #>> <#= arg.Ordinal #>Source, ZipSourceConfiguration<T<#= arg.Number #>> <#= arg.Ordinal #>SourceConfiguration,
-<#}#>
-            Func<<#= o.Types#>, TResult> resultSelector)
-        {
-<# foreach (var arg in o.Arguments) { #>
-            using var <#= arg.Ordinal #>Enumerator = new ZipEnumerator<T<#= arg.Number #>>(<#= arg.Ordinal #>Source.GetEnumerator(), nameof(<#= arg.Ordinal #>Source), <#= arg.Ordinal #>SourceConfiguration);
-<#} #>
-
-            while (MoveNext(
-<# foreach (var arg in o.Arguments) { #>
-                <#= arg.Ordinal #>Enumerator<#= arg.Num < o.Count ? "," : "))" #>
-<#}#>
-            {
-                yield return resultSelector(
-<# foreach (var arg in o.Arguments) { #>
-                    <#= arg.Ordinal #>Enumerator.Current<#= arg.Num < o.Count ? "," : "" #>
-<#}#>
-                );
-            }
-        }
-<#  } #>
-
-        private static bool MoveNext(params IZipEnumerator[] enumerators)
+        static class ZipHelper
         {
-            var hasNext = false;
-            IZipEnumerator equiStopper = null;
-
-            foreach (var enumerator in enumerators)
+            public static bool MoveNextOrDefault<T>(ref IEnumerator<T> enumerator, ref T value)
             {
-                switch (enumerator.MoveNext())
+                if (enumerator == null)
                 {
-                    case ZipEnumeratorStatus.AskForStop:
-                        return false;
-                    case ZipEnumeratorStatus.AskForEquiStop:
-                        if (hasNext) // there is some sequences ahead
-                        {
-                            enumerator.ThrowToShort();
-                        }
-                        equiStopper = enumerator;
-                        break;
-                    case ZipEnumeratorStatus.Continue:
-                        equiStopper?.ThrowToShort();
-                        hasNext = true;
-                        break;
-                    case ZipEnumeratorStatus.EndOfStream:
-                        break;
-                    default:
-                        throw new ArgumentOutOfRangeException();
+                    return false;
                 }
-            }
-
-            return hasNext;
-        }
-    }
-
-    internal interface IZipEnumerator
-    {
-        ZipEnumeratorStatus MoveNext();
-        void ThrowToShort();
-    }
-
-    internal class ZipEnumerator<T> : IZipEnumerator, IDisposable
-    {
-        private readonly ZipSourceConfiguration<T> _configuration;
-        private readonly string _name;
-        private IEnumerator<T> _source;
-
-        public ZipEnumerator(IEnumerator<T> source, string name, ZipSourceConfiguration<T> configuration)
-        {
-            _source = source;
-            _name = name;
-            _configuration = configuration;
-        }
-
-        public T Current => _source == null ? _configuration.PaddingValue : _source.Current;
-
-        public void Dispose() => _source?.Dispose();
-
-        public ZipEnumeratorStatus MoveNext()
-        {
-            if (_source?.MoveNext() == false)
-            {
-                _source.Dispose();
-                _source = null;
-            }
 
-            if (_source != null)
-            {
-                return ZipEnumeratorStatus.Continue;
-            }
+                if (enumerator.MoveNext())
+                {
+                    value = enumerator.Current;
+                    return true;
+                }
 
-            switch (_configuration.Behavior)
-            {
-                case ZipEnumeratorBehavior.StopOnShort:
-                    return ZipEnumeratorStatus.AskForStop;
-                case ZipEnumeratorBehavior.Padding:
-                    return ZipEnumeratorStatus.EndOfStream;
-                case ZipEnumeratorBehavior.ThrowOnShort:
-                    return ZipEnumeratorStatus.AskForEquiStop;
-                default:
-                    throw new ArgumentOutOfRangeException();
+                enumerator.Dispose();
+                enumerator = null;
+                value = default;
+                return false;
             }
         }
-
-        public void Reset() => _source.Reset();
-
-        public void ThrowToShort() => throw new InvalidOperationException($"{_name} sequence too short.");
-    }
-
-    internal enum ZipEnumeratorBehavior
-    {
-        StopOnShort,
-        ThrowOnShort,
-        Padding
-    }
-
-    internal enum ZipEnumeratorStatus
-    {
-        AskForStop,
-        AskForEquiStop,
-        Continue,
-        EndOfStream
-    }
-
-    internal class ZipSourceConfiguration<T>
-    {
-        public static ZipSourceConfiguration<T> StopOnShort { get; } = new ZipSourceConfiguration<T>(ZipEnumeratorBehavior.StopOnShort, default);
-        public static ZipSourceConfiguration<T> ThrowOnShort { get; } = new ZipSourceConfiguration<T>(ZipEnumeratorBehavior.ThrowOnShort, default);
-        public static ZipSourceConfiguration<T> PaddingWith(T paddingValue) => new ZipSourceConfiguration<T>(ZipEnumeratorBehavior.Padding, paddingValue);
-
-        ZipSourceConfiguration(ZipEnumeratorBehavior behavior, T paddingValue)
-        {
-            Behavior = behavior;
-            PaddingValue = paddingValue;
-        }
-
-        public ZipEnumeratorBehavior Behavior { get; }
-        public T PaddingValue { get; }
     }
 }

From ea231978bf3c76e0950790a02b8dbdfc22d8a2d1 Mon Sep 17 00:00:00 2001
From: Orace <pierre.lando@gmail.com>
Date: Tue, 5 Nov 2019 09:29:01 +0100
Subject: [PATCH 04/11] Fix unexpected trailing whitespace

---
 MoreLinq/Zip.g.cs | 56 +++++++++++++++++++++++------------------------
 MoreLinq/Zip.g.tt |  2 +-
 2 files changed, 29 insertions(+), 29 deletions(-)

diff --git a/MoreLinq/Zip.g.cs b/MoreLinq/Zip.g.cs
index 5136c03e3..e80f3dc2f 100644
--- a/MoreLinq/Zip.g.cs
+++ b/MoreLinq/Zip.g.cs
@@ -158,7 +158,7 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, TResult>(
                     var v2 = default(T2);
 
                     while (
-                        ZipHelper.MoveNextOrDefault<T1>(ref e1, ref v1) | 
+                        ZipHelper.MoveNextOrDefault<T1>(ref e1, ref v1) |
                         ZipHelper.MoveNextOrDefault<T2>(ref e2, ref v2))
                     {
                         yield return resultSelector(v1,v2);
@@ -429,8 +429,8 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, TResult>(
                     var v3 = default(T3);
 
                     while (
-                        ZipHelper.MoveNextOrDefault<T1>(ref e1, ref v1) | 
-                        ZipHelper.MoveNextOrDefault<T2>(ref e2, ref v2) | 
+                        ZipHelper.MoveNextOrDefault<T1>(ref e1, ref v1) |
+                        ZipHelper.MoveNextOrDefault<T2>(ref e2, ref v2) |
                         ZipHelper.MoveNextOrDefault<T3>(ref e3, ref v3))
                     {
                         yield return resultSelector(v1,v2,v3);
@@ -731,9 +731,9 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, TResult>(
                     var v4 = default(T4);
 
                     while (
-                        ZipHelper.MoveNextOrDefault<T1>(ref e1, ref v1) | 
-                        ZipHelper.MoveNextOrDefault<T2>(ref e2, ref v2) | 
-                        ZipHelper.MoveNextOrDefault<T3>(ref e3, ref v3) | 
+                        ZipHelper.MoveNextOrDefault<T1>(ref e1, ref v1) |
+                        ZipHelper.MoveNextOrDefault<T2>(ref e2, ref v2) |
+                        ZipHelper.MoveNextOrDefault<T3>(ref e3, ref v3) |
                         ZipHelper.MoveNextOrDefault<T4>(ref e4, ref v4))
                     {
                         yield return resultSelector(v1,v2,v3,v4);
@@ -1064,10 +1064,10 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, TResult>(
                     var v5 = default(T5);
 
                     while (
-                        ZipHelper.MoveNextOrDefault<T1>(ref e1, ref v1) | 
-                        ZipHelper.MoveNextOrDefault<T2>(ref e2, ref v2) | 
-                        ZipHelper.MoveNextOrDefault<T3>(ref e3, ref v3) | 
-                        ZipHelper.MoveNextOrDefault<T4>(ref e4, ref v4) | 
+                        ZipHelper.MoveNextOrDefault<T1>(ref e1, ref v1) |
+                        ZipHelper.MoveNextOrDefault<T2>(ref e2, ref v2) |
+                        ZipHelper.MoveNextOrDefault<T3>(ref e3, ref v3) |
+                        ZipHelper.MoveNextOrDefault<T4>(ref e4, ref v4) |
                         ZipHelper.MoveNextOrDefault<T5>(ref e5, ref v5))
                     {
                         yield return resultSelector(v1,v2,v3,v4,v5);
@@ -1428,11 +1428,11 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, TResult>(
                     var v6 = default(T6);
 
                     while (
-                        ZipHelper.MoveNextOrDefault<T1>(ref e1, ref v1) | 
-                        ZipHelper.MoveNextOrDefault<T2>(ref e2, ref v2) | 
-                        ZipHelper.MoveNextOrDefault<T3>(ref e3, ref v3) | 
-                        ZipHelper.MoveNextOrDefault<T4>(ref e4, ref v4) | 
-                        ZipHelper.MoveNextOrDefault<T5>(ref e5, ref v5) | 
+                        ZipHelper.MoveNextOrDefault<T1>(ref e1, ref v1) |
+                        ZipHelper.MoveNextOrDefault<T2>(ref e2, ref v2) |
+                        ZipHelper.MoveNextOrDefault<T3>(ref e3, ref v3) |
+                        ZipHelper.MoveNextOrDefault<T4>(ref e4, ref v4) |
+                        ZipHelper.MoveNextOrDefault<T5>(ref e5, ref v5) |
                         ZipHelper.MoveNextOrDefault<T6>(ref e6, ref v6))
                     {
                         yield return resultSelector(v1,v2,v3,v4,v5,v6);
@@ -1823,12 +1823,12 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, T7, TResul
                     var v7 = default(T7);
 
                     while (
-                        ZipHelper.MoveNextOrDefault<T1>(ref e1, ref v1) | 
-                        ZipHelper.MoveNextOrDefault<T2>(ref e2, ref v2) | 
-                        ZipHelper.MoveNextOrDefault<T3>(ref e3, ref v3) | 
-                        ZipHelper.MoveNextOrDefault<T4>(ref e4, ref v4) | 
-                        ZipHelper.MoveNextOrDefault<T5>(ref e5, ref v5) | 
-                        ZipHelper.MoveNextOrDefault<T6>(ref e6, ref v6) | 
+                        ZipHelper.MoveNextOrDefault<T1>(ref e1, ref v1) |
+                        ZipHelper.MoveNextOrDefault<T2>(ref e2, ref v2) |
+                        ZipHelper.MoveNextOrDefault<T3>(ref e3, ref v3) |
+                        ZipHelper.MoveNextOrDefault<T4>(ref e4, ref v4) |
+                        ZipHelper.MoveNextOrDefault<T5>(ref e5, ref v5) |
+                        ZipHelper.MoveNextOrDefault<T6>(ref e6, ref v6) |
                         ZipHelper.MoveNextOrDefault<T7>(ref e7, ref v7))
                     {
                         yield return resultSelector(v1,v2,v3,v4,v5,v6,v7);
@@ -2249,13 +2249,13 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, T7, T8, TR
                     var v8 = default(T8);
 
                     while (
-                        ZipHelper.MoveNextOrDefault<T1>(ref e1, ref v1) | 
-                        ZipHelper.MoveNextOrDefault<T2>(ref e2, ref v2) | 
-                        ZipHelper.MoveNextOrDefault<T3>(ref e3, ref v3) | 
-                        ZipHelper.MoveNextOrDefault<T4>(ref e4, ref v4) | 
-                        ZipHelper.MoveNextOrDefault<T5>(ref e5, ref v5) | 
-                        ZipHelper.MoveNextOrDefault<T6>(ref e6, ref v6) | 
-                        ZipHelper.MoveNextOrDefault<T7>(ref e7, ref v7) | 
+                        ZipHelper.MoveNextOrDefault<T1>(ref e1, ref v1) |
+                        ZipHelper.MoveNextOrDefault<T2>(ref e2, ref v2) |
+                        ZipHelper.MoveNextOrDefault<T3>(ref e3, ref v3) |
+                        ZipHelper.MoveNextOrDefault<T4>(ref e4, ref v4) |
+                        ZipHelper.MoveNextOrDefault<T5>(ref e5, ref v5) |
+                        ZipHelper.MoveNextOrDefault<T6>(ref e6, ref v6) |
+                        ZipHelper.MoveNextOrDefault<T7>(ref e7, ref v7) |
                         ZipHelper.MoveNextOrDefault<T8>(ref e8, ref v8))
                     {
                         yield return resultSelector(v1,v2,v3,v4,v5,v6,v7,v8);
diff --git a/MoreLinq/Zip.g.tt b/MoreLinq/Zip.g.tt
index fb16b1369..e187f183b 100644
--- a/MoreLinq/Zip.g.tt
+++ b/MoreLinq/Zip.g.tt
@@ -220,7 +220,7 @@ namespace MoreLinq
 
                     while (
 <# foreach (var arg in o.Arguments) { #>
-                        ZipHelper.MoveNextOrDefault<T<#= arg.Number #>>(ref e<#= arg.Number #>, ref v<#= arg.Number #>)<#= arg.Num < o.Count ? " | " : ")" #>
+                        ZipHelper.MoveNextOrDefault<T<#= arg.Number #>>(ref e<#= arg.Number #>, ref v<#= arg.Number #>)<#= arg.Num < o.Count ? " |" : ")" #>
 <#}#>
                     {
                         yield return resultSelector(<# foreach (var arg in o.Arguments) { #>v<#= arg.Number #><#= arg.Num < o.Count ? "," : "" #><#}#>);

From 38969b36efc476a842923f5599d692cffec76536 Mon Sep 17 00:00:00 2001
From: Orace <pierre.lando@gmail.com>
Date: Tue, 5 Nov 2019 11:54:25 +0100
Subject: [PATCH 05/11] Typo

---
 MoreLinq/Zip.g.cs | 42 +++++++++++++++++++++---------------------
 MoreLinq/Zip.g.tt |  6 +++---
 2 files changed, 24 insertions(+), 24 deletions(-)

diff --git a/MoreLinq/Zip.g.cs b/MoreLinq/Zip.g.cs
index e80f3dc2f..648dc4814 100644
--- a/MoreLinq/Zip.g.cs
+++ b/MoreLinq/Zip.g.cs
@@ -63,7 +63,7 @@ public static IEnumerable<TResult> EquiZip<T1, T2, TResult>(
                     {
                         if (e2.MoveNext())
                         {
-                            yield return resultSelector(e1.Current,e2.Current);
+                            yield return resultSelector(e1.Current, e2.Current);
                         }
                         else
                         {
@@ -161,7 +161,7 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, TResult>(
                         ZipHelper.MoveNextOrDefault<T1>(ref e1, ref v1) |
                         ZipHelper.MoveNextOrDefault<T2>(ref e2, ref v2))
                     {
-                        yield return resultSelector(v1,v2);
+                        yield return resultSelector(v1, v2);
                     }
                 }
                 finally
@@ -240,7 +240,7 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, TResult>(
 
                 while (e1.MoveNext() && e2.MoveNext())
                 {
-                    yield return resultSelector(e1.Current,e2.Current);
+                    yield return resultSelector(e1.Current, e2.Current);
                 }
             }
         }
@@ -323,7 +323,7 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, TResult>(
                     {
                         if (e2.MoveNext() && e3.MoveNext())
                         {
-                            yield return resultSelector(e1.Current,e2.Current,e3.Current);
+                            yield return resultSelector(e1.Current, e2.Current, e3.Current);
                         }
                         else
                         {
@@ -433,7 +433,7 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, TResult>(
                         ZipHelper.MoveNextOrDefault<T2>(ref e2, ref v2) |
                         ZipHelper.MoveNextOrDefault<T3>(ref e3, ref v3))
                     {
-                        yield return resultSelector(v1,v2,v3);
+                        yield return resultSelector(v1, v2, v3);
                     }
                 }
                 finally
@@ -522,7 +522,7 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, TResult>(
 
                 while (e1.MoveNext() && e2.MoveNext() && e3.MoveNext())
                 {
-                    yield return resultSelector(e1.Current,e2.Current,e3.Current);
+                    yield return resultSelector(e1.Current, e2.Current, e3.Current);
                 }
             }
         }
@@ -614,7 +614,7 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, TResult>(
                     {
                         if (e2.MoveNext() && e3.MoveNext() && e4.MoveNext())
                         {
-                            yield return resultSelector(e1.Current,e2.Current,e3.Current,e4.Current);
+                            yield return resultSelector(e1.Current, e2.Current, e3.Current, e4.Current);
                         }
                         else
                         {
@@ -736,7 +736,7 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, TResult>(
                         ZipHelper.MoveNextOrDefault<T3>(ref e3, ref v3) |
                         ZipHelper.MoveNextOrDefault<T4>(ref e4, ref v4))
                     {
-                        yield return resultSelector(v1,v2,v3,v4);
+                        yield return resultSelector(v1, v2, v3, v4);
                     }
                 }
                 finally
@@ -835,7 +835,7 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, TResult>(
 
                 while (e1.MoveNext() && e2.MoveNext() && e3.MoveNext() && e4.MoveNext())
                 {
-                    yield return resultSelector(e1.Current,e2.Current,e3.Current,e4.Current);
+                    yield return resultSelector(e1.Current, e2.Current, e3.Current, e4.Current);
                 }
             }
         }
@@ -936,7 +936,7 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, TResult>(
                     {
                         if (e2.MoveNext() && e3.MoveNext() && e4.MoveNext() && e5.MoveNext())
                         {
-                            yield return resultSelector(e1.Current,e2.Current,e3.Current,e4.Current,e5.Current);
+                            yield return resultSelector(e1.Current, e2.Current, e3.Current, e4.Current, e5.Current);
                         }
                         else
                         {
@@ -1070,7 +1070,7 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, TResult>(
                         ZipHelper.MoveNextOrDefault<T4>(ref e4, ref v4) |
                         ZipHelper.MoveNextOrDefault<T5>(ref e5, ref v5))
                     {
-                        yield return resultSelector(v1,v2,v3,v4,v5);
+                        yield return resultSelector(v1, v2, v3, v4, v5);
                     }
                 }
                 finally
@@ -1179,7 +1179,7 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, TResult>(
 
                 while (e1.MoveNext() && e2.MoveNext() && e3.MoveNext() && e4.MoveNext() && e5.MoveNext())
                 {
-                    yield return resultSelector(e1.Current,e2.Current,e3.Current,e4.Current,e5.Current);
+                    yield return resultSelector(e1.Current, e2.Current, e3.Current, e4.Current, e5.Current);
                 }
             }
         }
@@ -1289,7 +1289,7 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, TResult>(
                     {
                         if (e2.MoveNext() && e3.MoveNext() && e4.MoveNext() && e5.MoveNext() && e6.MoveNext())
                         {
-                            yield return resultSelector(e1.Current,e2.Current,e3.Current,e4.Current,e5.Current,e6.Current);
+                            yield return resultSelector(e1.Current, e2.Current, e3.Current, e4.Current, e5.Current, e6.Current);
                         }
                         else
                         {
@@ -1435,7 +1435,7 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, TResult>(
                         ZipHelper.MoveNextOrDefault<T5>(ref e5, ref v5) |
                         ZipHelper.MoveNextOrDefault<T6>(ref e6, ref v6))
                     {
-                        yield return resultSelector(v1,v2,v3,v4,v5,v6);
+                        yield return resultSelector(v1, v2, v3, v4, v5, v6);
                     }
                 }
                 finally
@@ -1554,7 +1554,7 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, TResult>(
 
                 while (e1.MoveNext() && e2.MoveNext() && e3.MoveNext() && e4.MoveNext() && e5.MoveNext() && e6.MoveNext())
                 {
-                    yield return resultSelector(e1.Current,e2.Current,e3.Current,e4.Current,e5.Current,e6.Current);
+                    yield return resultSelector(e1.Current, e2.Current, e3.Current, e4.Current, e5.Current, e6.Current);
                 }
             }
         }
@@ -1673,7 +1673,7 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, T7, TResult>(
                     {
                         if (e2.MoveNext() && e3.MoveNext() && e4.MoveNext() && e5.MoveNext() && e6.MoveNext() && e7.MoveNext())
                         {
-                            yield return resultSelector(e1.Current,e2.Current,e3.Current,e4.Current,e5.Current,e6.Current,e7.Current);
+                            yield return resultSelector(e1.Current, e2.Current, e3.Current, e4.Current, e5.Current, e6.Current, e7.Current);
                         }
                         else
                         {
@@ -1831,7 +1831,7 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, T7, TResul
                         ZipHelper.MoveNextOrDefault<T6>(ref e6, ref v6) |
                         ZipHelper.MoveNextOrDefault<T7>(ref e7, ref v7))
                     {
-                        yield return resultSelector(v1,v2,v3,v4,v5,v6,v7);
+                        yield return resultSelector(v1, v2, v3, v4, v5, v6, v7);
                     }
                 }
                 finally
@@ -1960,7 +1960,7 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, T7, TResu
 
                 while (e1.MoveNext() && e2.MoveNext() && e3.MoveNext() && e4.MoveNext() && e5.MoveNext() && e6.MoveNext() && e7.MoveNext())
                 {
-                    yield return resultSelector(e1.Current,e2.Current,e3.Current,e4.Current,e5.Current,e6.Current,e7.Current);
+                    yield return resultSelector(e1.Current, e2.Current, e3.Current, e4.Current, e5.Current, e6.Current, e7.Current);
                 }
             }
         }
@@ -2088,7 +2088,7 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, T7, T8, TResu
                     {
                         if (e2.MoveNext() && e3.MoveNext() && e4.MoveNext() && e5.MoveNext() && e6.MoveNext() && e7.MoveNext() && e8.MoveNext())
                         {
-                            yield return resultSelector(e1.Current,e2.Current,e3.Current,e4.Current,e5.Current,e6.Current,e7.Current,e8.Current);
+                            yield return resultSelector(e1.Current, e2.Current, e3.Current, e4.Current, e5.Current, e6.Current, e7.Current, e8.Current);
                         }
                         else
                         {
@@ -2258,7 +2258,7 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, T7, T8, TR
                         ZipHelper.MoveNextOrDefault<T7>(ref e7, ref v7) |
                         ZipHelper.MoveNextOrDefault<T8>(ref e8, ref v8))
                     {
-                        yield return resultSelector(v1,v2,v3,v4,v5,v6,v7,v8);
+                        yield return resultSelector(v1, v2, v3, v4, v5, v6, v7, v8);
                     }
                 }
                 finally
@@ -2397,7 +2397,7 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, T7, T8, T
 
                 while (e1.MoveNext() && e2.MoveNext() && e3.MoveNext() && e4.MoveNext() && e5.MoveNext() && e6.MoveNext() && e7.MoveNext() && e8.MoveNext())
                 {
-                    yield return resultSelector(e1.Current,e2.Current,e3.Current,e4.Current,e5.Current,e6.Current,e7.Current,e8.Current);
+                    yield return resultSelector(e1.Current, e2.Current, e3.Current, e4.Current, e5.Current, e6.Current, e7.Current, e8.Current);
                 }
             }
         }
diff --git a/MoreLinq/Zip.g.tt b/MoreLinq/Zip.g.tt
index e187f183b..f013e67bb 100644
--- a/MoreLinq/Zip.g.tt
+++ b/MoreLinq/Zip.g.tt
@@ -113,7 +113,7 @@ namespace MoreLinq
                     {
                         if (<# foreach (var arg in o.Arguments.Skip(1)) { #>e<#= arg.Number #>.MoveNext()<#= arg.Num < o.Count ? " && " : "" #><#}#>)
                         {
-                            yield return resultSelector(<# foreach (var arg in o.Arguments) { #>e<#= arg.Number #>.Current<#= arg.Num < o.Count ? "," : "" #><#}#>);
+                            yield return resultSelector(<# foreach (var arg in o.Arguments) { #>e<#= arg.Number #>.Current<#= arg.Num < o.Count ? ", " : "" #><#}#>);
                         }
                         else
                         {
@@ -223,7 +223,7 @@ namespace MoreLinq
                         ZipHelper.MoveNextOrDefault<T<#= arg.Number #>>(ref e<#= arg.Number #>, ref v<#= arg.Number #>)<#= arg.Num < o.Count ? " |" : ")" #>
 <#}#>
                     {
-                        yield return resultSelector(<# foreach (var arg in o.Arguments) { #>v<#= arg.Number #><#= arg.Num < o.Count ? "," : "" #><#}#>);
+                        yield return resultSelector(<# foreach (var arg in o.Arguments) { #>v<#= arg.Number #><#= arg.Num < o.Count ? ", " : "" #><#}#>);
                     }
                 }
                 finally
@@ -312,7 +312,7 @@ namespace MoreLinq
 
                 while (<# foreach (var arg in o.Arguments) { #>e<#= arg.Number #>.MoveNext()<#= arg.Num < o.Count ? " && " : "" #><#}#>)
                 {
-                    yield return resultSelector(<# foreach (var arg in o.Arguments) { #>e<#= arg.Number #>.Current<#= arg.Num < o.Count ? "," : "" #><#}#>);
+                    yield return resultSelector(<# foreach (var arg in o.Arguments) { #>e<#= arg.Number #>.Current<#= arg.Num < o.Count ? ", " : "" #><#}#>);
                 }
             }
         }

From 48720bfd3f894e7a33397adcdcb72012bd87acd4 Mon Sep 17 00:00:00 2001
From: Orace <pierre.lando@gmail.com>
Date: Tue, 5 Nov 2019 22:02:28 +0100
Subject: [PATCH 06/11] Remove non generated code from Zip.g.tt Remove "Source"
 from the name of the Zip method parameters. Typos

---
 MoreLinq/Extensions.g.cs |  931 +++++++++++------------
 MoreLinq/Zip.cs          |   43 ++
 MoreLinq/Zip.g.cs        | 1554 ++++++++++++++++++--------------------
 MoreLinq/Zip.g.tt        |   72 +-
 4 files changed, 1276 insertions(+), 1324 deletions(-)
 create mode 100644 MoreLinq/Zip.cs

diff --git a/MoreLinq/Extensions.g.cs b/MoreLinq/Extensions.g.cs
index acd6a1d69..4b2a4d2e2 100644
--- a/MoreLinq/Extensions.g.cs
+++ b/MoreLinq/Extensions.g.cs
@@ -1332,8 +1332,8 @@ public static partial class EquiZipExtension
         /// </summary>
         /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
         /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -1344,9 +1344,9 @@ public static partial class EquiZipExtension
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
         public static IEnumerable<(T1, T2)> EquiZip<T1, T2>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource)
-            => MoreEnumerable.EquiZip(firstSource, secondSource);
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second)
+            => MoreEnumerable.EquiZip(first, second);
 
         /// <summary>
         /// Returns a sequence of tuples, where each tuple contains the N-th
@@ -1356,9 +1356,9 @@ public static partial class EquiZipExtension
         /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
         /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
         /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -1369,10 +1369,10 @@ public static partial class EquiZipExtension
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
         public static IEnumerable<(T1, T2, T3)> EquiZip<T1, T2, T3>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource)
-            => MoreEnumerable.EquiZip(firstSource, secondSource, thirdSource);
+            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 input sequences. An exception is thrown
@@ -1381,8 +1381,8 @@ public static partial class EquiZipExtension
         /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
         /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -1394,11 +1394,12 @@ public static partial class EquiZipExtension
         /// <remarks>
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
+
         public static IEnumerable<TResult> EquiZip<T1, T2, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
             Func<T1, T2, TResult> resultSelector)
-            => MoreEnumerable.EquiZip(firstSource, secondSource, resultSelector);
+            => MoreEnumerable.EquiZip(first, second, resultSelector);
 
         /// <summary>
         /// Returns a sequence of tuples, where each tuple contains the N-th
@@ -1409,10 +1410,10 @@ public static IEnumerable<TResult> EquiZip<T1, T2, TResult>(
         /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
         /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
         /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -1423,11 +1424,11 @@ public static IEnumerable<TResult> EquiZip<T1, T2, TResult>(
         /// 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> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource)
-            => MoreEnumerable.EquiZip(firstSource, secondSource, thirdSource, fourthSource);
+            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
@@ -1438,9 +1439,9 @@ public static IEnumerable<TResult> EquiZip<T1, T2, TResult>(
         /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
         /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -1452,12 +1453,13 @@ public static IEnumerable<TResult> EquiZip<T1, T2, TResult>(
         /// <remarks>
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
+
         public static IEnumerable<TResult> EquiZip<T1, T2, T3, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
             Func<T1, T2, T3, TResult> resultSelector)
-            => MoreEnumerable.EquiZip(firstSource, secondSource, thirdSource, resultSelector);
+            => MoreEnumerable.EquiZip(first, second, third, resultSelector);
 
         /// <summary>
         /// Returns a sequence of tuples, where each tuple contains the N-th
@@ -1469,11 +1471,11 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, TResult>(
         /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
         /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
         /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -1484,12 +1486,12 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, TResult>(
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
         public static IEnumerable<(T1, T2, T3, T4, T5)> EquiZip<T1, T2, T3, T4, T5>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource)
-            => MoreEnumerable.EquiZip(firstSource, secondSource, thirdSource, fourthSource, fifthSource);
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth)
+            => MoreEnumerable.EquiZip(first, second, third, fourth, fifth);
 
         /// <summary>
         /// Returns a projection of tuples, where each tuple contains the N-th
@@ -1501,10 +1503,10 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, TResult>(
         /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
         /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -1516,13 +1518,14 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, TResult>(
         /// <remarks>
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
+
         public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
             Func<T1, T2, T3, T4, TResult> resultSelector)
-            => MoreEnumerable.EquiZip(firstSource, secondSource, thirdSource, fourthSource, resultSelector);
+            => MoreEnumerable.EquiZip(first, second, third, fourth, resultSelector);
 
         /// <summary>
         /// Returns a sequence of tuples, where each tuple contains the N-th
@@ -1535,12 +1538,12 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, TResult>(
         /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
         /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
         /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
-        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -1551,13 +1554,13 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, TResult>(
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
         public static IEnumerable<(T1, T2, T3, T4, T5, T6)> EquiZip<T1, T2, T3, T4, T5, T6>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
-            IEnumerable<T6> sixthSource)
-            => MoreEnumerable.EquiZip(firstSource, secondSource, thirdSource, fourthSource, fifthSource, sixthSource);
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth,
+            IEnumerable<T6> sixth)
+            => MoreEnumerable.EquiZip(first, second, third, fourth, fifth, sixth);
 
         /// <summary>
         /// Returns a projection of tuples, where each tuple contains the N-th
@@ -1570,11 +1573,11 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, TResult>(
         /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
         /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -1586,14 +1589,15 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, TResult>(
         /// <remarks>
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
+
         public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth,
             Func<T1, T2, T3, T4, T5, TResult> resultSelector)
-            => MoreEnumerable.EquiZip(firstSource, secondSource, thirdSource, fourthSource, fifthSource, resultSelector);
+            => MoreEnumerable.EquiZip(first, second, third, fourth, fifth, resultSelector);
 
         /// <summary>
         /// Returns a sequence of tuples, where each tuple contains the N-th
@@ -1607,13 +1611,13 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, TResult>(
         /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
         /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
         /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
-        /// <param name="sixthSource">The sixth source sequence.</param>
-        /// <param name="seventhSource">The seventh source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <param name="seventh">The seventh source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -1624,14 +1628,14 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, TResult>(
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
         public static IEnumerable<(T1, T2, T3, T4, T5, T6, T7)> EquiZip<T1, T2, T3, T4, T5, T6, T7>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
-            IEnumerable<T6> sixthSource,
-            IEnumerable<T7> seventhSource)
-            => MoreEnumerable.EquiZip(firstSource, secondSource, thirdSource, fourthSource, fifthSource, sixthSource, seventhSource);
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth,
+            IEnumerable<T6> sixth,
+            IEnumerable<T7> seventh)
+            => MoreEnumerable.EquiZip(first, second, third, fourth, fifth, sixth, seventh);
 
         /// <summary>
         /// Returns a projection of tuples, where each tuple contains the N-th
@@ -1645,12 +1649,12 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, TResult>(
         /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
         /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
-        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -1662,15 +1666,16 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, TResult>(
         /// <remarks>
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
+
         public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
-            IEnumerable<T6> sixthSource,
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth,
+            IEnumerable<T6> sixth,
             Func<T1, T2, T3, T4, T5, T6, TResult> resultSelector)
-            => MoreEnumerable.EquiZip(firstSource, secondSource, thirdSource, fourthSource, fifthSource, sixthSource, resultSelector);
+            => MoreEnumerable.EquiZip(first, second, third, fourth, fifth, sixth, resultSelector);
 
         /// <summary>
         /// Returns a sequence of tuples, where each tuple contains the N-th
@@ -1685,14 +1690,14 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, TResult>(
         /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
         /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
         /// <typeparam name="T8">Type of elements in eighth input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
-        /// <param name="sixthSource">The sixth source sequence.</param>
-        /// <param name="seventhSource">The seventh source sequence.</param>
-        /// <param name="eighthSource">The eighth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <param name="seventh">The seventh source sequence.</param>
+        /// <param name="eighth">The eighth source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -1703,15 +1708,15 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, TResult>(
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
         public static IEnumerable<(T1, T2, T3, T4, T5, T6, T7, T8)> EquiZip<T1, T2, T3, T4, T5, T6, T7, T8>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
-            IEnumerable<T6> sixthSource,
-            IEnumerable<T7> seventhSource,
-            IEnumerable<T8> eighthSource)
-            => MoreEnumerable.EquiZip(firstSource, secondSource, thirdSource, fourthSource, fifthSource, sixthSource, seventhSource, eighthSource);
+            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.EquiZip(first, second, third, fourth, fifth, sixth, seventh, eighth);
 
         /// <summary>
         /// Returns a projection of tuples, where each tuple contains the N-th
@@ -1726,13 +1731,13 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, TResult>(
         /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
         /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
-        /// <param name="sixthSource">The sixth source sequence.</param>
-        /// <param name="seventhSource">The seventh source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <param name="seventh">The seventh source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -1744,16 +1749,17 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, TResult>(
         /// <remarks>
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
+
         public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, T7, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
-            IEnumerable<T6> sixthSource,
-            IEnumerable<T7> seventhSource,
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth,
+            IEnumerable<T6> sixth,
+            IEnumerable<T7> seventh,
             Func<T1, T2, T3, T4, T5, T6, T7, TResult> resultSelector)
-            => MoreEnumerable.EquiZip(firstSource, secondSource, thirdSource, fourthSource, fifthSource, sixthSource, seventhSource, resultSelector);
+            => MoreEnumerable.EquiZip(first, second, third, fourth, fifth, sixth, seventh, resultSelector);
 
         /// <summary>
         /// Returns a projection of tuples, where each tuple contains the N-th
@@ -1769,14 +1775,14 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, T7, TResult>(
         /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
         /// <typeparam name="T8">Type of elements in eighth input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
-        /// <param name="sixthSource">The sixth source sequence.</param>
-        /// <param name="seventhSource">The seventh source sequence.</param>
-        /// <param name="eighthSource">The eighth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <param name="seventh">The seventh source sequence.</param>
+        /// <param name="eighth">The eighth source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -1788,17 +1794,18 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, T7, TResult>(
         /// <remarks>
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
+
         public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
-            IEnumerable<T6> sixthSource,
-            IEnumerable<T7> seventhSource,
-            IEnumerable<T8> eighthSource,
+            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,
             Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> resultSelector)
-            => MoreEnumerable.EquiZip(firstSource, secondSource, thirdSource, fourthSource, fifthSource, sixthSource, seventhSource, eighthSource, resultSelector);
+            => MoreEnumerable.EquiZip(first, second, third, fourth, fifth, sixth, seventh, eighth, resultSelector);
 
     }
 
@@ -7150,8 +7157,8 @@ public static partial class ZipLongestExtension
         /// </summary>
         /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
         /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -7159,9 +7166,9 @@ public static partial class ZipLongestExtension
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
         public static IEnumerable<(T1, T2)> ZipLongest<T1, T2>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource)
-            => MoreEnumerable.ZipLongest(firstSource, secondSource);
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second)
+            => MoreEnumerable.ZipLongest(first, second);
 
         /// <summary>
         /// Returns a sequence of tuples, where each tuple contains the N-th
@@ -7173,9 +7180,9 @@ public static partial class ZipLongestExtension
         /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
         /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
         /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -7183,10 +7190,10 @@ public static partial class ZipLongestExtension
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
         public static IEnumerable<(T1, T2, T3)> ZipLongest<T1, T2, T3>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource)
-            => MoreEnumerable.ZipLongest(firstSource, secondSource, thirdSource);
+            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
@@ -7198,8 +7205,8 @@ public static partial class ZipLongestExtension
         /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
         /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -7209,10 +7216,10 @@ public static partial class ZipLongestExtension
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
         public static IEnumerable<TResult> ZipLongest<T1, T2, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
             Func<T1, T2, TResult> resultSelector)
-            => MoreEnumerable.ZipLongest(firstSource, secondSource, resultSelector);
+            => MoreEnumerable.ZipLongest(first, second, resultSelector);
 
         /// <summary>
         /// Returns a sequence of tuples, where each tuple contains the N-th
@@ -7225,10 +7232,10 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, TResult>(
         /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
         /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
         /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -7236,11 +7243,11 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, TResult>(
         /// 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> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource)
-            => MoreEnumerable.ZipLongest(firstSource, secondSource, thirdSource, fourthSource);
+            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
@@ -7253,9 +7260,9 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, TResult>(
         /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
         /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -7265,11 +7272,11 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, TResult>(
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
         public static IEnumerable<TResult> ZipLongest<T1, T2, T3, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
             Func<T1, T2, T3, TResult> resultSelector)
-            => MoreEnumerable.ZipLongest(firstSource, secondSource, thirdSource, resultSelector);
+            => MoreEnumerable.ZipLongest(first, second, third, resultSelector);
 
         /// <summary>
         /// Returns a sequence of tuples, where each tuple contains the N-th
@@ -7283,11 +7290,11 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, TResult>(
         /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
         /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
         /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -7295,12 +7302,12 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, TResult>(
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
         public static IEnumerable<(T1, T2, T3, T4, T5)> ZipLongest<T1, T2, T3, T4, T5>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource)
-            => MoreEnumerable.ZipLongest(firstSource, secondSource, thirdSource, fourthSource, fifthSource);
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth)
+            => MoreEnumerable.ZipLongest(first, second, third, fourth, fifth);
 
         /// <summary>
         /// Returns a projection of tuples, where each tuple contains the N-th
@@ -7314,10 +7321,10 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, TResult>(
         /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
         /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -7327,12 +7334,12 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, TResult>(
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
         public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
             Func<T1, T2, T3, T4, TResult> resultSelector)
-            => MoreEnumerable.ZipLongest(firstSource, secondSource, thirdSource, fourthSource, resultSelector);
+            => MoreEnumerable.ZipLongest(first, second, third, fourth, resultSelector);
 
         /// <summary>
         /// Returns a sequence of tuples, where each tuple contains the N-th
@@ -7347,12 +7354,12 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, TResult>(
         /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
         /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
         /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
-        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -7360,13 +7367,13 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, TResult>(
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
         public static IEnumerable<(T1, T2, T3, T4, T5, T6)> ZipLongest<T1, T2, T3, T4, T5, T6>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
-            IEnumerable<T6> sixthSource)
-            => MoreEnumerable.ZipLongest(firstSource, secondSource, thirdSource, fourthSource, fifthSource, sixthSource);
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth,
+            IEnumerable<T6> sixth)
+            => MoreEnumerable.ZipLongest(first, second, third, fourth, fifth, sixth);
 
         /// <summary>
         /// Returns a projection of tuples, where each tuple contains the N-th
@@ -7381,11 +7388,11 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, TResult>(
         /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
         /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -7395,13 +7402,13 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, TResult>(
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
         public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth,
             Func<T1, T2, T3, T4, T5, TResult> resultSelector)
-            => MoreEnumerable.ZipLongest(firstSource, secondSource, thirdSource, fourthSource, fifthSource, resultSelector);
+            => MoreEnumerable.ZipLongest(first, second, third, fourth, fifth, resultSelector);
 
         /// <summary>
         /// Returns a sequence of tuples, where each tuple contains the N-th
@@ -7417,13 +7424,13 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, TResult>(
         /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
         /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
         /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
-        /// <param name="sixthSource">The sixth source sequence.</param>
-        /// <param name="seventhSource">The seventh source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <param name="seventh">The seventh source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -7431,14 +7438,14 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, TResult>(
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
         public static IEnumerable<(T1, T2, T3, T4, T5, T6, T7)> ZipLongest<T1, T2, T3, T4, T5, T6, T7>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
-            IEnumerable<T6> sixthSource,
-            IEnumerable<T7> seventhSource)
-            => MoreEnumerable.ZipLongest(firstSource, secondSource, thirdSource, fourthSource, fifthSource, sixthSource, seventhSource);
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth,
+            IEnumerable<T6> sixth,
+            IEnumerable<T7> seventh)
+            => MoreEnumerable.ZipLongest(first, second, third, fourth, fifth, sixth, seventh);
 
         /// <summary>
         /// Returns a projection of tuples, where each tuple contains the N-th
@@ -7454,12 +7461,12 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, TResult>(
         /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
         /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
-        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -7469,14 +7476,14 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, TResult>(
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
         public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
-            IEnumerable<T6> sixthSource,
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth,
+            IEnumerable<T6> sixth,
             Func<T1, T2, T3, T4, T5, T6, TResult> resultSelector)
-            => MoreEnumerable.ZipLongest(firstSource, secondSource, thirdSource, fourthSource, fifthSource, sixthSource, resultSelector);
+            => MoreEnumerable.ZipLongest(first, second, third, fourth, fifth, sixth, resultSelector);
 
         /// <summary>
         /// Returns a sequence of tuples, where each tuple contains the N-th
@@ -7493,14 +7500,14 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, TResult>(
         /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
         /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
         /// <typeparam name="T8">Type of elements in eighth input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
-        /// <param name="sixthSource">The sixth source sequence.</param>
-        /// <param name="seventhSource">The seventh source sequence.</param>
-        /// <param name="eighthSource">The eighth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <param name="seventh">The seventh source sequence.</param>
+        /// <param name="eighth">The eighth source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -7508,15 +7515,15 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, TResult>(
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
         public static IEnumerable<(T1, T2, T3, T4, T5, T6, T7, T8)> ZipLongest<T1, T2, T3, T4, T5, T6, T7, T8>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
-            IEnumerable<T6> sixthSource,
-            IEnumerable<T7> seventhSource,
-            IEnumerable<T8> eighthSource)
-            => MoreEnumerable.ZipLongest(firstSource, secondSource, thirdSource, fourthSource, fifthSource, sixthSource, seventhSource, eighthSource);
+            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.ZipLongest(first, second, third, fourth, fifth, sixth, seventh, eighth);
 
         /// <summary>
         /// Returns a projection of tuples, where each tuple contains the N-th
@@ -7533,13 +7540,13 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, TResult>(
         /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
         /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
-        /// <param name="sixthSource">The sixth source sequence.</param>
-        /// <param name="seventhSource">The seventh source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <param name="seventh">The seventh source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -7549,15 +7556,15 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, TResult>(
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
         public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, T7, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
-            IEnumerable<T6> sixthSource,
-            IEnumerable<T7> seventhSource,
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth,
+            IEnumerable<T6> sixth,
+            IEnumerable<T7> seventh,
             Func<T1, T2, T3, T4, T5, T6, T7, TResult> resultSelector)
-            => MoreEnumerable.ZipLongest(firstSource, secondSource, thirdSource, fourthSource, fifthSource, sixthSource, seventhSource, resultSelector);
+            => MoreEnumerable.ZipLongest(first, second, third, fourth, fifth, sixth, seventh, resultSelector);
 
         /// <summary>
         /// Returns a projection of tuples, where each tuple contains the N-th
@@ -7575,14 +7582,14 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, T7, TResul
         /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
         /// <typeparam name="T8">Type of elements in eighth input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
-        /// <param name="sixthSource">The sixth source sequence.</param>
-        /// <param name="seventhSource">The seventh source sequence.</param>
-        /// <param name="eighthSource">The eighth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <param name="seventh">The seventh source sequence.</param>
+        /// <param name="eighth">The eighth source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -7592,16 +7599,16 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, T7, TResul
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
         public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
-            IEnumerable<T6> sixthSource,
-            IEnumerable<T7> seventhSource,
-            IEnumerable<T8> eighthSource,
+            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,
             Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> resultSelector)
-            => MoreEnumerable.ZipLongest(firstSource, secondSource, thirdSource, fourthSource, fifthSource, sixthSource, seventhSource, eighthSource, resultSelector);
+            => MoreEnumerable.ZipLongest(first, second, third, fourth, fifth, sixth, seventh, eighth, resultSelector);
 
     }
 
@@ -7618,8 +7625,8 @@ public static partial class ZipShortestExtension
         /// </summary>
         /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
         /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -7634,9 +7641,9 @@ public static partial class ZipShortestExtension
         /// </remarks>
 
         public static IEnumerable<(T1, T2)> ZipShortest<T1, T2>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource)
-            => MoreEnumerable.ZipShortest(firstSource, secondSource);
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second)
+            => MoreEnumerable.ZipShortest(first, second);
 
         /// <summary>
         /// Returns a sequence of tuples, where each tuple contains the N-th
@@ -7646,9 +7653,9 @@ public static partial class ZipShortestExtension
         /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
         /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
         /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -7663,10 +7670,10 @@ public static partial class ZipShortestExtension
         /// </remarks>
 
         public static IEnumerable<(T1, T2, T3)> ZipShortest<T1, T2, T3>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource)
-            => MoreEnumerable.ZipShortest(firstSource, secondSource, thirdSource);
+            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
@@ -7676,8 +7683,8 @@ public static partial class ZipShortestExtension
         /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
         /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -7694,10 +7701,10 @@ public static partial class ZipShortestExtension
         /// </remarks>
 
         public static IEnumerable<TResult> ZipShortest<T1, T2, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
             Func<T1, T2, TResult> resultSelector)
-            => MoreEnumerable.ZipShortest(firstSource, secondSource, resultSelector);
+            => MoreEnumerable.ZipShortest(first, second, resultSelector);
 
         /// <summary>
         /// Returns a sequence of tuples, where each tuple contains the N-th
@@ -7708,10 +7715,10 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, TResult>(
         /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
         /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
         /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -7726,11 +7733,11 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, TResult>(
         /// </remarks>
 
         public static IEnumerable<(T1, T2, T3, T4)> ZipShortest<T1, T2, T3, T4>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource)
-            => MoreEnumerable.ZipShortest(firstSource, secondSource, thirdSource, fourthSource);
+            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
@@ -7741,9 +7748,9 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, TResult>(
         /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
         /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -7760,11 +7767,11 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, TResult>(
         /// </remarks>
 
         public static IEnumerable<TResult> ZipShortest<T1, T2, T3, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
             Func<T1, T2, T3, TResult> resultSelector)
-            => MoreEnumerable.ZipShortest(firstSource, secondSource, thirdSource, resultSelector);
+            => MoreEnumerable.ZipShortest(first, second, third, resultSelector);
 
         /// <summary>
         /// Returns a sequence of tuples, where each tuple contains the N-th
@@ -7776,11 +7783,11 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, TResult>(
         /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
         /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
         /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -7795,12 +7802,12 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, TResult>(
         /// </remarks>
 
         public static IEnumerable<(T1, T2, T3, T4, T5)> ZipShortest<T1, T2, T3, T4, T5>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource)
-            => MoreEnumerable.ZipShortest(firstSource, secondSource, thirdSource, fourthSource, fifthSource);
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth)
+            => MoreEnumerable.ZipShortest(first, second, third, fourth, fifth);
 
         /// <summary>
         /// Returns a projection of tuples, where each tuple contains the N-th
@@ -7812,10 +7819,10 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, TResult>(
         /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
         /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -7832,12 +7839,12 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, TResult>(
         /// </remarks>
 
         public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
             Func<T1, T2, T3, T4, TResult> resultSelector)
-            => MoreEnumerable.ZipShortest(firstSource, secondSource, thirdSource, fourthSource, resultSelector);
+            => MoreEnumerable.ZipShortest(first, second, third, fourth, resultSelector);
 
         /// <summary>
         /// Returns a sequence of tuples, where each tuple contains the N-th
@@ -7850,12 +7857,12 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, TResult>(
         /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
         /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
         /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
-        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -7870,13 +7877,13 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, TResult>(
         /// </remarks>
 
         public static IEnumerable<(T1, T2, T3, T4, T5, T6)> ZipShortest<T1, T2, T3, T4, T5, T6>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
-            IEnumerable<T6> sixthSource)
-            => MoreEnumerable.ZipShortest(firstSource, secondSource, thirdSource, fourthSource, fifthSource, sixthSource);
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth,
+            IEnumerable<T6> sixth)
+            => MoreEnumerable.ZipShortest(first, second, third, fourth, fifth, sixth);
 
         /// <summary>
         /// Returns a projection of tuples, where each tuple contains the N-th
@@ -7889,11 +7896,11 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, TResult>(
         /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
         /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -7910,13 +7917,13 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, TResult>(
         /// </remarks>
 
         public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth,
             Func<T1, T2, T3, T4, T5, TResult> resultSelector)
-            => MoreEnumerable.ZipShortest(firstSource, secondSource, thirdSource, fourthSource, fifthSource, resultSelector);
+            => MoreEnumerable.ZipShortest(first, second, third, fourth, fifth, resultSelector);
 
         /// <summary>
         /// Returns a sequence of tuples, where each tuple contains the N-th
@@ -7930,13 +7937,13 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, TResult>(
         /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
         /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
         /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
-        /// <param name="sixthSource">The sixth source sequence.</param>
-        /// <param name="seventhSource">The seventh source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <param name="seventh">The seventh source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -7951,14 +7958,14 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, TResult>(
         /// </remarks>
 
         public static IEnumerable<(T1, T2, T3, T4, T5, T6, T7)> ZipShortest<T1, T2, T3, T4, T5, T6, T7>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
-            IEnumerable<T6> sixthSource,
-            IEnumerable<T7> seventhSource)
-            => MoreEnumerable.ZipShortest(firstSource, secondSource, thirdSource, fourthSource, fifthSource, sixthSource, seventhSource);
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth,
+            IEnumerable<T6> sixth,
+            IEnumerable<T7> seventh)
+            => MoreEnumerable.ZipShortest(first, second, third, fourth, fifth, sixth, seventh);
 
         /// <summary>
         /// Returns a projection of tuples, where each tuple contains the N-th
@@ -7972,12 +7979,12 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, TResult>(
         /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
         /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
-        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -7994,14 +8001,14 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, TResult>(
         /// </remarks>
 
         public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
-            IEnumerable<T6> sixthSource,
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth,
+            IEnumerable<T6> sixth,
             Func<T1, T2, T3, T4, T5, T6, TResult> resultSelector)
-            => MoreEnumerable.ZipShortest(firstSource, secondSource, thirdSource, fourthSource, fifthSource, sixthSource, resultSelector);
+            => MoreEnumerable.ZipShortest(first, second, third, fourth, fifth, sixth, resultSelector);
 
         /// <summary>
         /// Returns a sequence of tuples, where each tuple contains the N-th
@@ -8016,14 +8023,14 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, TResult>(
         /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
         /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
         /// <typeparam name="T8">Type of elements in eighth input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
-        /// <param name="sixthSource">The sixth source sequence.</param>
-        /// <param name="seventhSource">The seventh source sequence.</param>
-        /// <param name="eighthSource">The eighth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <param name="seventh">The seventh source sequence.</param>
+        /// <param name="eighth">The eighth source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -8038,15 +8045,15 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, TResult>(
         /// </remarks>
 
         public static IEnumerable<(T1, T2, T3, T4, T5, T6, T7, T8)> ZipShortest<T1, T2, T3, T4, T5, T6, T7, T8>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
-            IEnumerable<T6> sixthSource,
-            IEnumerable<T7> seventhSource,
-            IEnumerable<T8> eighthSource)
-            => MoreEnumerable.ZipShortest(firstSource, secondSource, thirdSource, fourthSource, fifthSource, sixthSource, seventhSource, eighthSource);
+            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.ZipShortest(first, second, third, fourth, fifth, sixth, seventh, eighth);
 
         /// <summary>
         /// Returns a projection of tuples, where each tuple contains the N-th
@@ -8061,13 +8068,13 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, TResult>(
         /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
         /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
-        /// <param name="sixthSource">The sixth source sequence.</param>
-        /// <param name="seventhSource">The seventh source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <param name="seventh">The seventh source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -8084,15 +8091,15 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, TResult>(
         /// </remarks>
 
         public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, T7, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
-            IEnumerable<T6> sixthSource,
-            IEnumerable<T7> seventhSource,
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth,
+            IEnumerable<T6> sixth,
+            IEnumerable<T7> seventh,
             Func<T1, T2, T3, T4, T5, T6, T7, TResult> resultSelector)
-            => MoreEnumerable.ZipShortest(firstSource, secondSource, thirdSource, fourthSource, fifthSource, sixthSource, seventhSource, resultSelector);
+            => MoreEnumerable.ZipShortest(first, second, third, fourth, fifth, sixth, seventh, resultSelector);
 
         /// <summary>
         /// Returns a projection of tuples, where each tuple contains the N-th
@@ -8108,14 +8115,14 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, T7, TResu
         /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
         /// <typeparam name="T8">Type of elements in eighth input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
-        /// <param name="sixthSource">The sixth source sequence.</param>
-        /// <param name="seventhSource">The seventh source sequence.</param>
-        /// <param name="eighthSource">The eighth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <param name="seventh">The seventh source sequence.</param>
+        /// <param name="eighth">The eighth source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -8132,16 +8139,16 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, T7, TResu
         /// </remarks>
 
         public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
-            IEnumerable<T6> sixthSource,
-            IEnumerable<T7> seventhSource,
-            IEnumerable<T8> eighthSource,
+            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,
             Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> resultSelector)
-            => MoreEnumerable.ZipShortest(firstSource, secondSource, thirdSource, fourthSource, fifthSource, sixthSource, seventhSource, eighthSource, resultSelector);
+            => MoreEnumerable.ZipShortest(first, second, third, fourth, fifth, sixth, seventh, eighth, resultSelector);
 
     }
 }
diff --git a/MoreLinq/Zip.cs b/MoreLinq/Zip.cs
new file mode 100644
index 000000000..b03e3c9e0
--- /dev/null
+++ b/MoreLinq/Zip.cs
@@ -0,0 +1,43 @@
+#region License and Terms
+// MoreLINQ - Extensions to LINQ to Objects
+// Copyright (c) 2019 Pierre Lando. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#endregion
+
+namespace MoreLinq
+{
+    using System.Collections.Generic;
+
+    static class ZipHelper
+    {
+        public static bool MoveNextOrDefault<T>(ref IEnumerator<T> enumerator, ref T value)
+        {
+            if (enumerator == null)
+            {
+                return false;
+            }
+
+            if (enumerator.MoveNext())
+            {
+                value = enumerator.Current;
+                return true;
+            }
+
+            enumerator.Dispose();
+            enumerator = null;
+            value = default;
+            return false;
+        }
+    }
+}
diff --git a/MoreLinq/Zip.g.cs b/MoreLinq/Zip.g.cs
index 648dc4814..f191db6f6 100644
--- a/MoreLinq/Zip.g.cs
+++ b/MoreLinq/Zip.g.cs
@@ -30,8 +30,8 @@ static partial class MoreEnumerable
         /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
         /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -43,43 +43,36 @@ static partial class MoreEnumerable
         /// <remarks>
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
+
         public static IEnumerable<TResult> EquiZip<T1, T2, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
             Func<T1, T2, TResult> resultSelector)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
             return _(); IEnumerable<TResult> _()
             {
-                using var e1 = firstSource.GetEnumerator();
-                using var e2 = secondSource.GetEnumerator();
+                using var e1 = first.GetEnumerator();
+                using var e2 = second.GetEnumerator();
 
                 for (;;)
                 {
                     if (e1.MoveNext())
                     {
                         if (e2.MoveNext())
-                        {
                             yield return resultSelector(e1.Current, e2.Current);
-                        }
                         else
-                        {
                             break;
-                        }
                     }
                     else
                     {
                         if (e2.MoveNext())
-                        {
                             break;
-                        }
                         else
-                        {
                             yield break;
-                        }
                     }
                 }
 
@@ -94,8 +87,8 @@ public static IEnumerable<TResult> EquiZip<T1, T2, TResult>(
         /// </summary>
         /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
         /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -106,12 +99,12 @@ public static IEnumerable<TResult> EquiZip<T1, T2, TResult>(
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
         public static IEnumerable<(T1, T2)> EquiZip<T1, T2>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource)
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second)
         {
             return EquiZip(
-                firstSource,
-                secondSource,
+                first,
+                second,
                 ValueTuple.Create);
         }
 
@@ -125,8 +118,8 @@ public static IEnumerable<TResult> EquiZip<T1, T2, TResult>(
         /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
         /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -136,12 +129,12 @@ public static IEnumerable<TResult> EquiZip<T1, T2, TResult>(
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
         public static IEnumerable<TResult> ZipLongest<T1, T2, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
             Func<T1, T2, TResult> resultSelector)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
             return _(); IEnumerable<TResult> _()
@@ -151,8 +144,8 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, TResult>(
 
                 try
                 {
-                    e1 = firstSource.GetEnumerator();
-                    e2 = secondSource.GetEnumerator();
+                    e1 = first.GetEnumerator();
+                    e2 = second.GetEnumerator();
 
                     var v1 = default(T1);
                     var v2 = default(T2);
@@ -181,8 +174,8 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, TResult>(
         /// </summary>
         /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
         /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -190,12 +183,12 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, TResult>(
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
         public static IEnumerable<(T1, T2)> ZipLongest<T1, T2>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource)
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second)
         {
             return ZipLongest(
-                firstSource,
-                secondSource,
+                first,
+                second,
                 ValueTuple.Create);
         }
 
@@ -207,8 +200,8 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, TResult>(
         /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
         /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -225,18 +218,18 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, TResult>(
         /// </remarks>
 
         public static IEnumerable<TResult> ZipShortest<T1, T2, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
             Func<T1, T2, TResult> resultSelector)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
             return _(); IEnumerable<TResult> _()
             {
-                using var e1 = firstSource.GetEnumerator();
-                using var e2 = secondSource.GetEnumerator();
+                using var e1 = first.GetEnumerator();
+                using var e2 = second.GetEnumerator();
 
                 while (e1.MoveNext() && e2.MoveNext())
                 {
@@ -252,8 +245,8 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, TResult>(
         /// </summary>
         /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
         /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -268,12 +261,12 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, TResult>(
         /// </remarks>
 
         public static IEnumerable<(T1, T2)> ZipShortest<T1, T2>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource)
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second)
         {
             return ZipShortest(
-                firstSource,
-                secondSource,
+                first,
+                second,
                 ValueTuple.Create);
         }
 
@@ -286,9 +279,9 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, TResult>(
         /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
         /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -300,46 +293,39 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, TResult>(
         /// <remarks>
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
+
         public static IEnumerable<TResult> EquiZip<T1, T2, T3, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
             Func<T1, T2, T3, TResult> resultSelector)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
-            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
+            if (third == null) throw new ArgumentNullException(nameof(third));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
             return _(); IEnumerable<TResult> _()
             {
-                using var e1 = firstSource.GetEnumerator();
-                using var e2 = secondSource.GetEnumerator();
-                using var e3 = thirdSource.GetEnumerator();
+                using var e1 = first.GetEnumerator();
+                using var e2 = second.GetEnumerator();
+                using var e3 = third.GetEnumerator();
 
                 for (;;)
                 {
                     if (e1.MoveNext())
                     {
                         if (e2.MoveNext() && e3.MoveNext())
-                        {
                             yield return resultSelector(e1.Current, e2.Current, e3.Current);
-                        }
                         else
-                        {
                             break;
-                        }
                     }
                     else
                     {
                         if (e2.MoveNext() || e3.MoveNext())
-                        {
                             break;
-                        }
                         else
-                        {
                             yield break;
-                        }
                     }
                 }
 
@@ -355,9 +341,9 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, TResult>(
         /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
         /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
         /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -368,14 +354,14 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, TResult>(
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
         public static IEnumerable<(T1, T2, T3)> EquiZip<T1, T2, T3>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource)
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third)
         {
             return EquiZip(
-                firstSource,
-                secondSource,
-                thirdSource,
+                first,
+                second,
+                third,
                 ValueTuple.Create);
         }
 
@@ -390,9 +376,9 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, TResult>(
         /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
         /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -402,14 +388,14 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, TResult>(
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
         public static IEnumerable<TResult> ZipLongest<T1, T2, T3, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
             Func<T1, T2, T3, TResult> resultSelector)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
-            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
+            if (third == null) throw new ArgumentNullException(nameof(third));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
             return _(); IEnumerable<TResult> _()
@@ -420,9 +406,9 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, TResult>(
 
                 try
                 {
-                    e1 = firstSource.GetEnumerator();
-                    e2 = secondSource.GetEnumerator();
-                    e3 = thirdSource.GetEnumerator();
+                    e1 = first.GetEnumerator();
+                    e2 = second.GetEnumerator();
+                    e3 = third.GetEnumerator();
 
                     var v1 = default(T1);
                     var v2 = default(T2);
@@ -455,9 +441,9 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, TResult>(
         /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
         /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
         /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -465,14 +451,14 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, TResult>(
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
         public static IEnumerable<(T1, T2, T3)> ZipLongest<T1, T2, T3>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource)
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third)
         {
             return ZipLongest(
-                firstSource,
-                secondSource,
-                thirdSource,
+                first,
+                second,
+                third,
                 ValueTuple.Create);
         }
 
@@ -485,9 +471,9 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, TResult>(
         /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
         /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -504,21 +490,21 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, TResult>(
         /// </remarks>
 
         public static IEnumerable<TResult> ZipShortest<T1, T2, T3, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
             Func<T1, T2, T3, TResult> resultSelector)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
-            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
+            if (third == null) throw new ArgumentNullException(nameof(third));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
             return _(); IEnumerable<TResult> _()
             {
-                using var e1 = firstSource.GetEnumerator();
-                using var e2 = secondSource.GetEnumerator();
-                using var e3 = thirdSource.GetEnumerator();
+                using var e1 = first.GetEnumerator();
+                using var e2 = second.GetEnumerator();
+                using var e3 = third.GetEnumerator();
 
                 while (e1.MoveNext() && e2.MoveNext() && e3.MoveNext())
                 {
@@ -535,9 +521,9 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, TResult>(
         /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
         /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
         /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -552,14 +538,14 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, TResult>(
         /// </remarks>
 
         public static IEnumerable<(T1, T2, T3)> ZipShortest<T1, T2, T3>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource)
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third)
         {
             return ZipShortest(
-                firstSource,
-                secondSource,
-                thirdSource,
+                first,
+                second,
+                third,
                 ValueTuple.Create);
         }
 
@@ -573,10 +559,10 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, TResult>(
         /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
         /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -588,49 +574,42 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, TResult>(
         /// <remarks>
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
+
         public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
             Func<T1, T2, T3, T4, TResult> resultSelector)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
-            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
-            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
+            if (third == null) throw new ArgumentNullException(nameof(third));
+            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
             return _(); IEnumerable<TResult> _()
             {
-                using var e1 = firstSource.GetEnumerator();
-                using var e2 = secondSource.GetEnumerator();
-                using var e3 = thirdSource.GetEnumerator();
-                using var e4 = fourthSource.GetEnumerator();
+                using var e1 = first.GetEnumerator();
+                using var e2 = second.GetEnumerator();
+                using var e3 = third.GetEnumerator();
+                using var e4 = fourth.GetEnumerator();
 
                 for (;;)
                 {
                     if (e1.MoveNext())
                     {
                         if (e2.MoveNext() && e3.MoveNext() && e4.MoveNext())
-                        {
                             yield return resultSelector(e1.Current, e2.Current, e3.Current, e4.Current);
-                        }
                         else
-                        {
                             break;
-                        }
                     }
                     else
                     {
                         if (e2.MoveNext() || e3.MoveNext() || e4.MoveNext())
-                        {
                             break;
-                        }
                         else
-                        {
                             yield break;
-                        }
                     }
                 }
 
@@ -647,10 +626,10 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, TResult>(
         /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
         /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
         /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -661,16 +640,16 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, TResult>(
         /// 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> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource)
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth)
         {
             return EquiZip(
-                firstSource,
-                secondSource,
-                thirdSource,
-                fourthSource,
+                first,
+                second,
+                third,
+                fourth,
                 ValueTuple.Create);
         }
 
@@ -686,10 +665,10 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, TResult>(
         /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
         /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -699,16 +678,16 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, TResult>(
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
         public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
             Func<T1, T2, T3, T4, TResult> resultSelector)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
-            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
-            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
+            if (third == null) throw new ArgumentNullException(nameof(third));
+            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
             return _(); IEnumerable<TResult> _()
@@ -720,10 +699,10 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, TResult>(
 
                 try
                 {
-                    e1 = firstSource.GetEnumerator();
-                    e2 = secondSource.GetEnumerator();
-                    e3 = thirdSource.GetEnumerator();
-                    e4 = fourthSource.GetEnumerator();
+                    e1 = first.GetEnumerator();
+                    e2 = second.GetEnumerator();
+                    e3 = third.GetEnumerator();
+                    e4 = fourth.GetEnumerator();
 
                     var v1 = default(T1);
                     var v2 = default(T2);
@@ -760,10 +739,10 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, TResult>(
         /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
         /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
         /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -771,16 +750,16 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, TResult>(
         /// 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> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource)
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth)
         {
             return ZipLongest(
-                firstSource,
-                secondSource,
-                thirdSource,
-                fourthSource,
+                first,
+                second,
+                third,
+                fourth,
                 ValueTuple.Create);
         }
 
@@ -794,10 +773,10 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, TResult>(
         /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
         /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -814,24 +793,24 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, TResult>(
         /// </remarks>
 
         public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
             Func<T1, T2, T3, T4, TResult> resultSelector)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
-            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
-            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
+            if (third == null) throw new ArgumentNullException(nameof(third));
+            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
             return _(); IEnumerable<TResult> _()
             {
-                using var e1 = firstSource.GetEnumerator();
-                using var e2 = secondSource.GetEnumerator();
-                using var e3 = thirdSource.GetEnumerator();
-                using var e4 = fourthSource.GetEnumerator();
+                using var e1 = first.GetEnumerator();
+                using var e2 = second.GetEnumerator();
+                using var e3 = third.GetEnumerator();
+                using var e4 = fourth.GetEnumerator();
 
                 while (e1.MoveNext() && e2.MoveNext() && e3.MoveNext() && e4.MoveNext())
                 {
@@ -849,10 +828,10 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, TResult>(
         /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
         /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
         /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -867,16 +846,16 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, TResult>(
         /// </remarks>
 
         public static IEnumerable<(T1, T2, T3, T4)> ZipShortest<T1, T2, T3, T4>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource)
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth)
         {
             return ZipShortest(
-                firstSource,
-                secondSource,
-                thirdSource,
-                fourthSource,
+                first,
+                second,
+                third,
+                fourth,
                 ValueTuple.Create);
         }
 
@@ -891,11 +870,11 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, TResult>(
         /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
         /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -907,52 +886,45 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, TResult>(
         /// <remarks>
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
+
         public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth,
             Func<T1, T2, T3, T4, T5, TResult> resultSelector)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
-            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
-            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
-            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
+            if (third == null) throw new ArgumentNullException(nameof(third));
+            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
+            if (fifth == null) throw new ArgumentNullException(nameof(fifth));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
             return _(); IEnumerable<TResult> _()
             {
-                using var e1 = firstSource.GetEnumerator();
-                using var e2 = secondSource.GetEnumerator();
-                using var e3 = thirdSource.GetEnumerator();
-                using var e4 = fourthSource.GetEnumerator();
-                using var e5 = fifthSource.GetEnumerator();
+                using var e1 = first.GetEnumerator();
+                using var e2 = second.GetEnumerator();
+                using var e3 = third.GetEnumerator();
+                using var e4 = fourth.GetEnumerator();
+                using var e5 = fifth.GetEnumerator();
 
                 for (;;)
                 {
                     if (e1.MoveNext())
                     {
                         if (e2.MoveNext() && e3.MoveNext() && e4.MoveNext() && e5.MoveNext())
-                        {
                             yield return resultSelector(e1.Current, e2.Current, e3.Current, e4.Current, e5.Current);
-                        }
                         else
-                        {
                             break;
-                        }
                     }
                     else
                     {
                         if (e2.MoveNext() || e3.MoveNext() || e4.MoveNext() || e5.MoveNext())
-                        {
                             break;
-                        }
                         else
-                        {
                             yield break;
-                        }
                     }
                 }
 
@@ -970,11 +942,11 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, TResult>(
         /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
         /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
         /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -985,18 +957,18 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, TResult>(
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
         public static IEnumerable<(T1, T2, T3, T4, T5)> EquiZip<T1, T2, T3, T4, T5>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource)
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth)
         {
             return EquiZip(
-                firstSource,
-                secondSource,
-                thirdSource,
-                fourthSource,
-                fifthSource,
+                first,
+                second,
+                third,
+                fourth,
+                fifth,
                 ValueTuple.Create);
         }
 
@@ -1013,11 +985,11 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, TResult>(
         /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
         /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -1027,18 +999,18 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, TResult>(
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
         public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth,
             Func<T1, T2, T3, T4, T5, TResult> resultSelector)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
-            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
-            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
-            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
+            if (third == null) throw new ArgumentNullException(nameof(third));
+            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
+            if (fifth == null) throw new ArgumentNullException(nameof(fifth));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
             return _(); IEnumerable<TResult> _()
@@ -1051,11 +1023,11 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, TResult>(
 
                 try
                 {
-                    e1 = firstSource.GetEnumerator();
-                    e2 = secondSource.GetEnumerator();
-                    e3 = thirdSource.GetEnumerator();
-                    e4 = fourthSource.GetEnumerator();
-                    e5 = fifthSource.GetEnumerator();
+                    e1 = first.GetEnumerator();
+                    e2 = second.GetEnumerator();
+                    e3 = third.GetEnumerator();
+                    e4 = fourth.GetEnumerator();
+                    e5 = fifth.GetEnumerator();
 
                     var v1 = default(T1);
                     var v2 = default(T2);
@@ -1096,11 +1068,11 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, TResult>(
         /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
         /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
         /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -1108,18 +1080,18 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, TResult>(
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
         public static IEnumerable<(T1, T2, T3, T4, T5)> ZipLongest<T1, T2, T3, T4, T5>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource)
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth)
         {
             return ZipLongest(
-                firstSource,
-                secondSource,
-                thirdSource,
-                fourthSource,
-                fifthSource,
+                first,
+                second,
+                third,
+                fourth,
+                fifth,
                 ValueTuple.Create);
         }
 
@@ -1134,11 +1106,11 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, TResult>(
         /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
         /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -1155,27 +1127,27 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, TResult>(
         /// </remarks>
 
         public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth,
             Func<T1, T2, T3, T4, T5, TResult> resultSelector)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
-            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
-            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
-            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
+            if (third == null) throw new ArgumentNullException(nameof(third));
+            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
+            if (fifth == null) throw new ArgumentNullException(nameof(fifth));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
             return _(); IEnumerable<TResult> _()
             {
-                using var e1 = firstSource.GetEnumerator();
-                using var e2 = secondSource.GetEnumerator();
-                using var e3 = thirdSource.GetEnumerator();
-                using var e4 = fourthSource.GetEnumerator();
-                using var e5 = fifthSource.GetEnumerator();
+                using var e1 = first.GetEnumerator();
+                using var e2 = second.GetEnumerator();
+                using var e3 = third.GetEnumerator();
+                using var e4 = fourth.GetEnumerator();
+                using var e5 = fifth.GetEnumerator();
 
                 while (e1.MoveNext() && e2.MoveNext() && e3.MoveNext() && e4.MoveNext() && e5.MoveNext())
                 {
@@ -1194,11 +1166,11 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, TResult>(
         /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
         /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
         /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -1213,18 +1185,18 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, TResult>(
         /// </remarks>
 
         public static IEnumerable<(T1, T2, T3, T4, T5)> ZipShortest<T1, T2, T3, T4, T5>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource)
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth)
         {
             return ZipShortest(
-                firstSource,
-                secondSource,
-                thirdSource,
-                fourthSource,
-                fifthSource,
+                first,
+                second,
+                third,
+                fourth,
+                fifth,
                 ValueTuple.Create);
         }
 
@@ -1240,12 +1212,12 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, TResult>(
         /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
         /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
-        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -1257,55 +1229,48 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, TResult>(
         /// <remarks>
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
+
         public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
-            IEnumerable<T6> sixthSource,
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth,
+            IEnumerable<T6> sixth,
             Func<T1, T2, T3, T4, T5, T6, TResult> resultSelector)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
-            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
-            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
-            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
-            if (sixthSource == null) throw new ArgumentNullException(nameof(sixthSource));
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
+            if (third == null) throw new ArgumentNullException(nameof(third));
+            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
+            if (fifth == null) throw new ArgumentNullException(nameof(fifth));
+            if (sixth == null) throw new ArgumentNullException(nameof(sixth));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
             return _(); IEnumerable<TResult> _()
             {
-                using var e1 = firstSource.GetEnumerator();
-                using var e2 = secondSource.GetEnumerator();
-                using var e3 = thirdSource.GetEnumerator();
-                using var e4 = fourthSource.GetEnumerator();
-                using var e5 = fifthSource.GetEnumerator();
-                using var e6 = sixthSource.GetEnumerator();
+                using var e1 = first.GetEnumerator();
+                using var e2 = second.GetEnumerator();
+                using var e3 = third.GetEnumerator();
+                using var e4 = fourth.GetEnumerator();
+                using var e5 = fifth.GetEnumerator();
+                using var e6 = sixth.GetEnumerator();
 
                 for (;;)
                 {
                     if (e1.MoveNext())
                     {
                         if (e2.MoveNext() && e3.MoveNext() && e4.MoveNext() && e5.MoveNext() && e6.MoveNext())
-                        {
                             yield return resultSelector(e1.Current, e2.Current, e3.Current, e4.Current, e5.Current, e6.Current);
-                        }
                         else
-                        {
                             break;
-                        }
                     }
                     else
                     {
                         if (e2.MoveNext() || e3.MoveNext() || e4.MoveNext() || e5.MoveNext() || e6.MoveNext())
-                        {
                             break;
-                        }
                         else
-                        {
                             yield break;
-                        }
                     }
                 }
 
@@ -1324,12 +1289,12 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, TResult>(
         /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
         /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
         /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
-        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -1340,20 +1305,20 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, TResult>(
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
         public static IEnumerable<(T1, T2, T3, T4, T5, T6)> EquiZip<T1, T2, T3, T4, T5, T6>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
-            IEnumerable<T6> sixthSource)
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth,
+            IEnumerable<T6> sixth)
         {
             return EquiZip(
-                firstSource,
-                secondSource,
-                thirdSource,
-                fourthSource,
-                fifthSource,
-                sixthSource,
+                first,
+                second,
+                third,
+                fourth,
+                fifth,
+                sixth,
                 ValueTuple.Create);
         }
 
@@ -1371,12 +1336,12 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, TResult>(
         /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
         /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
-        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -1386,20 +1351,20 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, TResult>(
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
         public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
-            IEnumerable<T6> sixthSource,
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth,
+            IEnumerable<T6> sixth,
             Func<T1, T2, T3, T4, T5, T6, TResult> resultSelector)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
-            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
-            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
-            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
-            if (sixthSource == null) throw new ArgumentNullException(nameof(sixthSource));
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
+            if (third == null) throw new ArgumentNullException(nameof(third));
+            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
+            if (fifth == null) throw new ArgumentNullException(nameof(fifth));
+            if (sixth == null) throw new ArgumentNullException(nameof(sixth));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
             return _(); IEnumerable<TResult> _()
@@ -1413,12 +1378,12 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, TResult>(
 
                 try
                 {
-                    e1 = firstSource.GetEnumerator();
-                    e2 = secondSource.GetEnumerator();
-                    e3 = thirdSource.GetEnumerator();
-                    e4 = fourthSource.GetEnumerator();
-                    e5 = fifthSource.GetEnumerator();
-                    e6 = sixthSource.GetEnumerator();
+                    e1 = first.GetEnumerator();
+                    e2 = second.GetEnumerator();
+                    e3 = third.GetEnumerator();
+                    e4 = fourth.GetEnumerator();
+                    e5 = fifth.GetEnumerator();
+                    e6 = sixth.GetEnumerator();
 
                     var v1 = default(T1);
                     var v2 = default(T2);
@@ -1463,12 +1428,12 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, TResult>(
         /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
         /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
         /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
-        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -1476,20 +1441,20 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, TResult>(
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
         public static IEnumerable<(T1, T2, T3, T4, T5, T6)> ZipLongest<T1, T2, T3, T4, T5, T6>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
-            IEnumerable<T6> sixthSource)
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth,
+            IEnumerable<T6> sixth)
         {
             return ZipLongest(
-                firstSource,
-                secondSource,
-                thirdSource,
-                fourthSource,
-                fifthSource,
-                sixthSource,
+                first,
+                second,
+                third,
+                fourth,
+                fifth,
+                sixth,
                 ValueTuple.Create);
         }
 
@@ -1505,12 +1470,12 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, TResult>(
         /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
         /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
-        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -1527,30 +1492,30 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, TResult>(
         /// </remarks>
 
         public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
-            IEnumerable<T6> sixthSource,
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth,
+            IEnumerable<T6> sixth,
             Func<T1, T2, T3, T4, T5, T6, TResult> resultSelector)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
-            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
-            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
-            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
-            if (sixthSource == null) throw new ArgumentNullException(nameof(sixthSource));
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
+            if (third == null) throw new ArgumentNullException(nameof(third));
+            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
+            if (fifth == null) throw new ArgumentNullException(nameof(fifth));
+            if (sixth == null) throw new ArgumentNullException(nameof(sixth));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
             return _(); IEnumerable<TResult> _()
             {
-                using var e1 = firstSource.GetEnumerator();
-                using var e2 = secondSource.GetEnumerator();
-                using var e3 = thirdSource.GetEnumerator();
-                using var e4 = fourthSource.GetEnumerator();
-                using var e5 = fifthSource.GetEnumerator();
-                using var e6 = sixthSource.GetEnumerator();
+                using var e1 = first.GetEnumerator();
+                using var e2 = second.GetEnumerator();
+                using var e3 = third.GetEnumerator();
+                using var e4 = fourth.GetEnumerator();
+                using var e5 = fifth.GetEnumerator();
+                using var e6 = sixth.GetEnumerator();
 
                 while (e1.MoveNext() && e2.MoveNext() && e3.MoveNext() && e4.MoveNext() && e5.MoveNext() && e6.MoveNext())
                 {
@@ -1570,12 +1535,12 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, TResult>(
         /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
         /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
         /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
-        /// <param name="sixthSource">The sixth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -1590,20 +1555,20 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, TResult>(
         /// </remarks>
 
         public static IEnumerable<(T1, T2, T3, T4, T5, T6)> ZipShortest<T1, T2, T3, T4, T5, T6>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
-            IEnumerable<T6> sixthSource)
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth,
+            IEnumerable<T6> sixth)
         {
             return ZipShortest(
-                firstSource,
-                secondSource,
-                thirdSource,
-                fourthSource,
-                fifthSource,
-                sixthSource,
+                first,
+                second,
+                third,
+                fourth,
+                fifth,
+                sixth,
                 ValueTuple.Create);
         }
 
@@ -1620,13 +1585,13 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, TResult>(
         /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
         /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
-        /// <param name="sixthSource">The sixth source sequence.</param>
-        /// <param name="seventhSource">The seventh source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <param name="seventh">The seventh source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -1638,58 +1603,51 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, TResult>(
         /// <remarks>
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
+
         public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, T7, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
-            IEnumerable<T6> sixthSource,
-            IEnumerable<T7> seventhSource,
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth,
+            IEnumerable<T6> sixth,
+            IEnumerable<T7> seventh,
             Func<T1, T2, T3, T4, T5, T6, T7, TResult> resultSelector)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
-            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
-            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
-            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
-            if (sixthSource == null) throw new ArgumentNullException(nameof(sixthSource));
-            if (seventhSource == null) throw new ArgumentNullException(nameof(seventhSource));
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
+            if (third == null) throw new ArgumentNullException(nameof(third));
+            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
+            if (fifth == null) throw new ArgumentNullException(nameof(fifth));
+            if (sixth == null) throw new ArgumentNullException(nameof(sixth));
+            if (seventh == null) throw new ArgumentNullException(nameof(seventh));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
             return _(); IEnumerable<TResult> _()
             {
-                using var e1 = firstSource.GetEnumerator();
-                using var e2 = secondSource.GetEnumerator();
-                using var e3 = thirdSource.GetEnumerator();
-                using var e4 = fourthSource.GetEnumerator();
-                using var e5 = fifthSource.GetEnumerator();
-                using var e6 = sixthSource.GetEnumerator();
-                using var e7 = seventhSource.GetEnumerator();
+                using var e1 = first.GetEnumerator();
+                using var e2 = second.GetEnumerator();
+                using var e3 = third.GetEnumerator();
+                using var e4 = fourth.GetEnumerator();
+                using var e5 = fifth.GetEnumerator();
+                using var e6 = sixth.GetEnumerator();
+                using var e7 = seventh.GetEnumerator();
 
                 for (;;)
                 {
                     if (e1.MoveNext())
                     {
                         if (e2.MoveNext() && e3.MoveNext() && e4.MoveNext() && e5.MoveNext() && e6.MoveNext() && e7.MoveNext())
-                        {
                             yield return resultSelector(e1.Current, e2.Current, e3.Current, e4.Current, e5.Current, e6.Current, e7.Current);
-                        }
                         else
-                        {
                             break;
-                        }
                     }
                     else
                     {
                         if (e2.MoveNext() || e3.MoveNext() || e4.MoveNext() || e5.MoveNext() || e6.MoveNext() || e7.MoveNext())
-                        {
                             break;
-                        }
                         else
-                        {
                             yield break;
-                        }
                     }
                 }
 
@@ -1709,13 +1667,13 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, T7, TResult>(
         /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
         /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
         /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
-        /// <param name="sixthSource">The sixth source sequence.</param>
-        /// <param name="seventhSource">The seventh source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <param name="seventh">The seventh source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -1726,22 +1684,22 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, T7, TResult>(
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
         public static IEnumerable<(T1, T2, T3, T4, T5, T6, T7)> EquiZip<T1, T2, T3, T4, T5, T6, T7>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
-            IEnumerable<T6> sixthSource,
-            IEnumerable<T7> seventhSource)
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth,
+            IEnumerable<T6> sixth,
+            IEnumerable<T7> seventh)
         {
             return EquiZip(
-                firstSource,
-                secondSource,
-                thirdSource,
-                fourthSource,
-                fifthSource,
-                sixthSource,
-                seventhSource,
+                first,
+                second,
+                third,
+                fourth,
+                fifth,
+                sixth,
+                seventh,
                 ValueTuple.Create);
         }
 
@@ -1760,13 +1718,13 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, T7, TResult>(
         /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
         /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
-        /// <param name="sixthSource">The sixth source sequence.</param>
-        /// <param name="seventhSource">The seventh source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <param name="seventh">The seventh source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -1776,22 +1734,22 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, T7, TResult>(
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
         public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, T7, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
-            IEnumerable<T6> sixthSource,
-            IEnumerable<T7> seventhSource,
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth,
+            IEnumerable<T6> sixth,
+            IEnumerable<T7> seventh,
             Func<T1, T2, T3, T4, T5, T6, T7, TResult> resultSelector)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
-            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
-            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
-            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
-            if (sixthSource == null) throw new ArgumentNullException(nameof(sixthSource));
-            if (seventhSource == null) throw new ArgumentNullException(nameof(seventhSource));
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
+            if (third == null) throw new ArgumentNullException(nameof(third));
+            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
+            if (fifth == null) throw new ArgumentNullException(nameof(fifth));
+            if (sixth == null) throw new ArgumentNullException(nameof(sixth));
+            if (seventh == null) throw new ArgumentNullException(nameof(seventh));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
             return _(); IEnumerable<TResult> _()
@@ -1806,13 +1764,13 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, T7, TResul
 
                 try
                 {
-                    e1 = firstSource.GetEnumerator();
-                    e2 = secondSource.GetEnumerator();
-                    e3 = thirdSource.GetEnumerator();
-                    e4 = fourthSource.GetEnumerator();
-                    e5 = fifthSource.GetEnumerator();
-                    e6 = sixthSource.GetEnumerator();
-                    e7 = seventhSource.GetEnumerator();
+                    e1 = first.GetEnumerator();
+                    e2 = second.GetEnumerator();
+                    e3 = third.GetEnumerator();
+                    e4 = fourth.GetEnumerator();
+                    e5 = fifth.GetEnumerator();
+                    e6 = sixth.GetEnumerator();
+                    e7 = seventh.GetEnumerator();
 
                     var v1 = default(T1);
                     var v2 = default(T2);
@@ -1861,13 +1819,13 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, T7, TResul
         /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
         /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
         /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
-        /// <param name="sixthSource">The sixth source sequence.</param>
-        /// <param name="seventhSource">The seventh source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <param name="seventh">The seventh source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -1875,22 +1833,22 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, T7, TResul
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
         public static IEnumerable<(T1, T2, T3, T4, T5, T6, T7)> ZipLongest<T1, T2, T3, T4, T5, T6, T7>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
-            IEnumerable<T6> sixthSource,
-            IEnumerable<T7> seventhSource)
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth,
+            IEnumerable<T6> sixth,
+            IEnumerable<T7> seventh)
         {
             return ZipLongest(
-                firstSource,
-                secondSource,
-                thirdSource,
-                fourthSource,
-                fifthSource,
-                sixthSource,
-                seventhSource,
+                first,
+                second,
+                third,
+                fourth,
+                fifth,
+                sixth,
+                seventh,
                 ValueTuple.Create);
         }
 
@@ -1907,13 +1865,13 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, T7, TResul
         /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
         /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
-        /// <param name="sixthSource">The sixth source sequence.</param>
-        /// <param name="seventhSource">The seventh source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <param name="seventh">The seventh source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -1930,33 +1888,33 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, T7, TResul
         /// </remarks>
 
         public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, T7, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
-            IEnumerable<T6> sixthSource,
-            IEnumerable<T7> seventhSource,
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth,
+            IEnumerable<T6> sixth,
+            IEnumerable<T7> seventh,
             Func<T1, T2, T3, T4, T5, T6, T7, TResult> resultSelector)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
-            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
-            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
-            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
-            if (sixthSource == null) throw new ArgumentNullException(nameof(sixthSource));
-            if (seventhSource == null) throw new ArgumentNullException(nameof(seventhSource));
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
+            if (third == null) throw new ArgumentNullException(nameof(third));
+            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
+            if (fifth == null) throw new ArgumentNullException(nameof(fifth));
+            if (sixth == null) throw new ArgumentNullException(nameof(sixth));
+            if (seventh == null) throw new ArgumentNullException(nameof(seventh));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
             return _(); IEnumerable<TResult> _()
             {
-                using var e1 = firstSource.GetEnumerator();
-                using var e2 = secondSource.GetEnumerator();
-                using var e3 = thirdSource.GetEnumerator();
-                using var e4 = fourthSource.GetEnumerator();
-                using var e5 = fifthSource.GetEnumerator();
-                using var e6 = sixthSource.GetEnumerator();
-                using var e7 = seventhSource.GetEnumerator();
+                using var e1 = first.GetEnumerator();
+                using var e2 = second.GetEnumerator();
+                using var e3 = third.GetEnumerator();
+                using var e4 = fourth.GetEnumerator();
+                using var e5 = fifth.GetEnumerator();
+                using var e6 = sixth.GetEnumerator();
+                using var e7 = seventh.GetEnumerator();
 
                 while (e1.MoveNext() && e2.MoveNext() && e3.MoveNext() && e4.MoveNext() && e5.MoveNext() && e6.MoveNext() && e7.MoveNext())
                 {
@@ -1977,13 +1935,13 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, T7, TResu
         /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
         /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
         /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
-        /// <param name="sixthSource">The sixth source sequence.</param>
-        /// <param name="seventhSource">The seventh source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <param name="seventh">The seventh source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -1998,22 +1956,22 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, T7, TResu
         /// </remarks>
 
         public static IEnumerable<(T1, T2, T3, T4, T5, T6, T7)> ZipShortest<T1, T2, T3, T4, T5, T6, T7>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
-            IEnumerable<T6> sixthSource,
-            IEnumerable<T7> seventhSource)
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth,
+            IEnumerable<T6> sixth,
+            IEnumerable<T7> seventh)
         {
             return ZipShortest(
-                firstSource,
-                secondSource,
-                thirdSource,
-                fourthSource,
-                fifthSource,
-                sixthSource,
-                seventhSource,
+                first,
+                second,
+                third,
+                fourth,
+                fifth,
+                sixth,
+                seventh,
                 ValueTuple.Create);
         }
 
@@ -2031,14 +1989,14 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, T7, TResu
         /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
         /// <typeparam name="T8">Type of elements in eighth input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
-        /// <param name="sixthSource">The sixth source sequence.</param>
-        /// <param name="seventhSource">The seventh source sequence.</param>
-        /// <param name="eighthSource">The eighth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <param name="seventh">The seventh source sequence.</param>
+        /// <param name="eighth">The eighth source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -2050,61 +2008,54 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, T7, TResu
         /// <remarks>
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
+
         public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
-            IEnumerable<T6> sixthSource,
-            IEnumerable<T7> seventhSource,
-            IEnumerable<T8> eighthSource,
+            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,
             Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> resultSelector)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
-            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
-            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
-            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
-            if (sixthSource == null) throw new ArgumentNullException(nameof(sixthSource));
-            if (seventhSource == null) throw new ArgumentNullException(nameof(seventhSource));
-            if (eighthSource == null) throw new ArgumentNullException(nameof(eighthSource));
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
+            if (third == null) throw new ArgumentNullException(nameof(third));
+            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
+            if (fifth == null) throw new ArgumentNullException(nameof(fifth));
+            if (sixth == null) throw new ArgumentNullException(nameof(sixth));
+            if (seventh == null) throw new ArgumentNullException(nameof(seventh));
+            if (eighth == null) throw new ArgumentNullException(nameof(eighth));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
             return _(); IEnumerable<TResult> _()
             {
-                using var e1 = firstSource.GetEnumerator();
-                using var e2 = secondSource.GetEnumerator();
-                using var e3 = thirdSource.GetEnumerator();
-                using var e4 = fourthSource.GetEnumerator();
-                using var e5 = fifthSource.GetEnumerator();
-                using var e6 = sixthSource.GetEnumerator();
-                using var e7 = seventhSource.GetEnumerator();
-                using var e8 = eighthSource.GetEnumerator();
+                using var e1 = first.GetEnumerator();
+                using var e2 = second.GetEnumerator();
+                using var e3 = third.GetEnumerator();
+                using var e4 = fourth.GetEnumerator();
+                using var e5 = fifth.GetEnumerator();
+                using var e6 = sixth.GetEnumerator();
+                using var e7 = seventh.GetEnumerator();
+                using var e8 = eighth.GetEnumerator();
 
                 for (;;)
                 {
                     if (e1.MoveNext())
                     {
                         if (e2.MoveNext() && e3.MoveNext() && e4.MoveNext() && e5.MoveNext() && e6.MoveNext() && e7.MoveNext() && e8.MoveNext())
-                        {
                             yield return resultSelector(e1.Current, e2.Current, e3.Current, e4.Current, e5.Current, e6.Current, e7.Current, e8.Current);
-                        }
                         else
-                        {
                             break;
-                        }
                     }
                     else
                     {
                         if (e2.MoveNext() || e3.MoveNext() || e4.MoveNext() || e5.MoveNext() || e6.MoveNext() || e7.MoveNext() || e8.MoveNext())
-                        {
                             break;
-                        }
                         else
-                        {
                             yield break;
-                        }
                     }
                 }
 
@@ -2125,14 +2076,14 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, T7, T8, TResu
         /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
         /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
         /// <typeparam name="T8">Type of elements in eighth input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
-        /// <param name="sixthSource">The sixth source sequence.</param>
-        /// <param name="seventhSource">The seventh source sequence.</param>
-        /// <param name="eighthSource">The eighth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <param name="seventh">The seventh source sequence.</param>
+        /// <param name="eighth">The eighth source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -2143,24 +2094,24 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, T7, T8, TResu
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
         public static IEnumerable<(T1, T2, T3, T4, T5, T6, T7, T8)> EquiZip<T1, T2, T3, T4, T5, T6, T7, T8>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
-            IEnumerable<T6> sixthSource,
-            IEnumerable<T7> seventhSource,
-            IEnumerable<T8> eighthSource)
+            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 EquiZip(
-                firstSource,
-                secondSource,
-                thirdSource,
-                fourthSource,
-                fifthSource,
-                sixthSource,
-                seventhSource,
-                eighthSource,
+                first,
+                second,
+                third,
+                fourth,
+                fifth,
+                sixth,
+                seventh,
+                eighth,
                 ValueTuple.Create);
         }
 
@@ -2180,14 +2131,14 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, T7, T8, TResu
         /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
         /// <typeparam name="T8">Type of elements in eighth input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
-        /// <param name="sixthSource">The sixth source sequence.</param>
-        /// <param name="seventhSource">The seventh source sequence.</param>
-        /// <param name="eighthSource">The eighth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <param name="seventh">The seventh source sequence.</param>
+        /// <param name="eighth">The eighth source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -2197,24 +2148,24 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, T7, T8, TResu
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
         public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
-            IEnumerable<T6> sixthSource,
-            IEnumerable<T7> seventhSource,
-            IEnumerable<T8> eighthSource,
+            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,
             Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> resultSelector)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
-            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
-            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
-            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
-            if (sixthSource == null) throw new ArgumentNullException(nameof(sixthSource));
-            if (seventhSource == null) throw new ArgumentNullException(nameof(seventhSource));
-            if (eighthSource == null) throw new ArgumentNullException(nameof(eighthSource));
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
+            if (third == null) throw new ArgumentNullException(nameof(third));
+            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
+            if (fifth == null) throw new ArgumentNullException(nameof(fifth));
+            if (sixth == null) throw new ArgumentNullException(nameof(sixth));
+            if (seventh == null) throw new ArgumentNullException(nameof(seventh));
+            if (eighth == null) throw new ArgumentNullException(nameof(eighth));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
             return _(); IEnumerable<TResult> _()
@@ -2230,14 +2181,14 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, T7, T8, TR
 
                 try
                 {
-                    e1 = firstSource.GetEnumerator();
-                    e2 = secondSource.GetEnumerator();
-                    e3 = thirdSource.GetEnumerator();
-                    e4 = fourthSource.GetEnumerator();
-                    e5 = fifthSource.GetEnumerator();
-                    e6 = sixthSource.GetEnumerator();
-                    e7 = seventhSource.GetEnumerator();
-                    e8 = eighthSource.GetEnumerator();
+                    e1 = first.GetEnumerator();
+                    e2 = second.GetEnumerator();
+                    e3 = third.GetEnumerator();
+                    e4 = fourth.GetEnumerator();
+                    e5 = fifth.GetEnumerator();
+                    e6 = sixth.GetEnumerator();
+                    e7 = seventh.GetEnumerator();
+                    e8 = eighth.GetEnumerator();
 
                     var v1 = default(T1);
                     var v2 = default(T2);
@@ -2290,14 +2241,14 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, T7, T8, TR
         /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
         /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
         /// <typeparam name="T8">Type of elements in eighth input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
-        /// <param name="sixthSource">The sixth source sequence.</param>
-        /// <param name="seventhSource">The seventh source sequence.</param>
-        /// <param name="eighthSource">The eighth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <param name="seventh">The seventh source sequence.</param>
+        /// <param name="eighth">The eighth source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -2305,24 +2256,24 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, T7, T8, TR
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
         public static IEnumerable<(T1, T2, T3, T4, T5, T6, T7, T8)> ZipLongest<T1, T2, T3, T4, T5, T6, T7, T8>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
-            IEnumerable<T6> sixthSource,
-            IEnumerable<T7> seventhSource,
-            IEnumerable<T8> eighthSource)
+            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 ZipLongest(
-                firstSource,
-                secondSource,
-                thirdSource,
-                fourthSource,
-                fifthSource,
-                sixthSource,
-                seventhSource,
-                eighthSource,
+                first,
+                second,
+                third,
+                fourth,
+                fifth,
+                sixth,
+                seventh,
+                eighth,
                 ValueTuple.Create);
         }
 
@@ -2340,14 +2291,14 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, T7, T8, TR
         /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
         /// <typeparam name="T8">Type of elements in eighth input sequence.</typeparam>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
-        /// <param name="sixthSource">The sixth source sequence.</param>
-        /// <param name="seventhSource">The seventh source sequence.</param>
-        /// <param name="eighthSource">The eighth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <param name="seventh">The seventh source sequence.</param>
+        /// <param name="eighth">The eighth source sequence.</param>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
         /// <returns>
@@ -2364,36 +2315,36 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, T7, T8, TR
         /// </remarks>
 
         public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
-            IEnumerable<T6> sixthSource,
-            IEnumerable<T7> seventhSource,
-            IEnumerable<T8> eighthSource,
+            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,
             Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> resultSelector)
         {
-            if (firstSource == null) throw new ArgumentNullException(nameof(firstSource));
-            if (secondSource == null) throw new ArgumentNullException(nameof(secondSource));
-            if (thirdSource == null) throw new ArgumentNullException(nameof(thirdSource));
-            if (fourthSource == null) throw new ArgumentNullException(nameof(fourthSource));
-            if (fifthSource == null) throw new ArgumentNullException(nameof(fifthSource));
-            if (sixthSource == null) throw new ArgumentNullException(nameof(sixthSource));
-            if (seventhSource == null) throw new ArgumentNullException(nameof(seventhSource));
-            if (eighthSource == null) throw new ArgumentNullException(nameof(eighthSource));
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
+            if (third == null) throw new ArgumentNullException(nameof(third));
+            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
+            if (fifth == null) throw new ArgumentNullException(nameof(fifth));
+            if (sixth == null) throw new ArgumentNullException(nameof(sixth));
+            if (seventh == null) throw new ArgumentNullException(nameof(seventh));
+            if (eighth == null) throw new ArgumentNullException(nameof(eighth));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
             return _(); IEnumerable<TResult> _()
             {
-                using var e1 = firstSource.GetEnumerator();
-                using var e2 = secondSource.GetEnumerator();
-                using var e3 = thirdSource.GetEnumerator();
-                using var e4 = fourthSource.GetEnumerator();
-                using var e5 = fifthSource.GetEnumerator();
-                using var e6 = sixthSource.GetEnumerator();
-                using var e7 = seventhSource.GetEnumerator();
-                using var e8 = eighthSource.GetEnumerator();
+                using var e1 = first.GetEnumerator();
+                using var e2 = second.GetEnumerator();
+                using var e3 = third.GetEnumerator();
+                using var e4 = fourth.GetEnumerator();
+                using var e5 = fifth.GetEnumerator();
+                using var e6 = sixth.GetEnumerator();
+                using var e7 = seventh.GetEnumerator();
+                using var e8 = eighth.GetEnumerator();
 
                 while (e1.MoveNext() && e2.MoveNext() && e3.MoveNext() && e4.MoveNext() && e5.MoveNext() && e6.MoveNext() && e7.MoveNext() && e8.MoveNext())
                 {
@@ -2415,14 +2366,14 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, T7, T8, T
         /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
         /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
         /// <typeparam name="T8">Type of elements in eighth input sequence.</typeparam>
-        /// <param name="firstSource">The first source sequence.</param>
-        /// <param name="secondSource">The second source sequence.</param>
-        /// <param name="thirdSource">The third source sequence.</param>
-        /// <param name="fourthSource">The fourth source sequence.</param>
-        /// <param name="fifthSource">The fifth source sequence.</param>
-        /// <param name="sixthSource">The sixth source sequence.</param>
-        /// <param name="seventhSource">The seventh source sequence.</param>
-        /// <param name="eighthSource">The eighth source sequence.</param>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <param name="seventh">The seventh source sequence.</param>
+        /// <param name="eighth">The eighth source sequence.</param>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
         /// from each of the argument sequences.</returns>
@@ -2437,47 +2388,26 @@ public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, T7, T8, T
         /// </remarks>
 
         public static IEnumerable<(T1, T2, T3, T4, T5, T6, T7, T8)> ZipShortest<T1, T2, T3, T4, T5, T6, T7, T8>(
-            this IEnumerable<T1> firstSource,
-            IEnumerable<T2> secondSource,
-            IEnumerable<T3> thirdSource,
-            IEnumerable<T4> fourthSource,
-            IEnumerable<T5> fifthSource,
-            IEnumerable<T6> sixthSource,
-            IEnumerable<T7> seventhSource,
-            IEnumerable<T8> eighthSource)
+            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 ZipShortest(
-                firstSource,
-                secondSource,
-                thirdSource,
-                fourthSource,
-                fifthSource,
-                sixthSource,
-                seventhSource,
-                eighthSource,
+                first,
+                second,
+                third,
+                fourth,
+                fifth,
+                sixth,
+                seventh,
+                eighth,
                 ValueTuple.Create);
         }
 
-        static class ZipHelper
-        {
-            public static bool MoveNextOrDefault<T>(ref IEnumerator<T> enumerator, ref T value)
-            {
-                if (enumerator == null)
-                {
-                    return false;
-                }
-
-                if (enumerator.MoveNext())
-                {
-                    value = enumerator.Current;
-                    return true;
-                }
-
-                enumerator.Dispose();
-                enumerator = null;
-                value = default;
-                return false;
-            }
-        }
     }
 }
diff --git a/MoreLinq/Zip.g.tt b/MoreLinq/Zip.g.tt
index f013e67bb..fba441e95 100644
--- a/MoreLinq/Zip.g.tt
+++ b/MoreLinq/Zip.g.tt
@@ -77,7 +77,7 @@ namespace MoreLinq
 <#} #>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
 <# foreach (var arg in o.Arguments) { #>
-        /// <param name="<#= arg.Ordinal #>Source">The <#= arg.Ordinal #> source sequence.</param>
+        /// <param name="<#= arg.Ordinal #>">The <#= arg.Ordinal #> source sequence.</param>
 <#} #>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
@@ -90,21 +90,22 @@ namespace MoreLinq
         /// <remarks>
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
+
         public static IEnumerable<TResult> EquiZip<<#= o.Types#>, TResult>(
 <# foreach (var arg in o.Arguments) { #>
-            <#= arg.Num == 1 ? "this " : "" #>IEnumerable<T<#= arg.Number #>> <#= arg.Ordinal #>Source,
+            <#= arg.Num == 1 ? "this " : "" #>IEnumerable<T<#= arg.Number #>> <#= arg.Ordinal #>,
 <#}#>
             Func<<#= o.Types#>, TResult> resultSelector)
         {
 <# foreach (var arg in o.Arguments) { #>
-            if (<#= arg.Ordinal #>Source == null) throw new ArgumentNullException(nameof(<#= arg.Ordinal #>Source));
+            if (<#= arg.Ordinal #> == null) throw new ArgumentNullException(nameof(<#= arg.Ordinal #>));
 <#} #>
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
             return _(); IEnumerable<TResult> _()
             {
 <# foreach (var arg in o.Arguments) { #>
-                using var e<#= arg.Number #> = <#= arg.Ordinal #>Source.GetEnumerator();
+                using var e<#= arg.Number #> = <#= arg.Ordinal #>.GetEnumerator();
 <#} #>
 
                 for (;;)
@@ -112,24 +113,16 @@ namespace MoreLinq
                     if (e<#= o.Arguments.First().Number #>.MoveNext())
                     {
                         if (<# foreach (var arg in o.Arguments.Skip(1)) { #>e<#= arg.Number #>.MoveNext()<#= arg.Num < o.Count ? " && " : "" #><#}#>)
-                        {
                             yield return resultSelector(<# foreach (var arg in o.Arguments) { #>e<#= arg.Number #>.Current<#= arg.Num < o.Count ? ", " : "" #><#}#>);
-                        }
                         else
-                        {
                             break;
-                        }
                     }
                     else
                     {
                         if (<# foreach (var arg in o.Arguments.Skip(1)) { #>e<#= arg.Number #>.MoveNext()<#= arg.Num < o.Count ? " || " : "" #><#}#>)
-                        {
                             break;
-                        }
                         else
-                        {
                             yield break;
-                        }
                     }
                 }
 
@@ -146,7 +139,7 @@ namespace MoreLinq
         /// <typeparam name="T<#= arg.Number #>">Type of elements in <#= arg.Ordinal #> input sequence.</typeparam>
 <#} #>
 <# foreach (var arg in o.Arguments) { #>
-        /// <param name="<#= arg.Ordinal #>Source">The <#= arg.Ordinal #> source sequence.</param>
+        /// <param name="<#= arg.Ordinal #>">The <#= arg.Ordinal #> source sequence.</param>
 <#} #>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
@@ -159,12 +152,12 @@ namespace MoreLinq
         /// </remarks>
         public static IEnumerable<(<#= o.Types#>)> EquiZip<<#= o.Types#>>(
 <# foreach (var arg in o.Arguments) { #>
-            <#= arg.Num == 1 ? "this " : "" #>IEnumerable<T<#= arg.Number #>> <#= arg.Ordinal #>Source<#= arg.Num < o.Count ? "," : ")" #>
+            <#= arg.Num == 1 ? "this " : "" #>IEnumerable<T<#= arg.Number #>> <#= arg.Ordinal #><#= arg.Num < o.Count ? "," : ")" #>
 <#}#>
         {
             return EquiZip(
 <# foreach (var arg in o.Arguments) { #>
-                <#= arg.Ordinal #>Source,
+                <#= arg.Ordinal #>,
 <#}#>
                 ValueTuple.Create);
         }
@@ -181,7 +174,7 @@ namespace MoreLinq
 <#} #>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
 <# foreach (var arg in o.Arguments) { #>
-        /// <param name="<#= arg.Ordinal #>Source">The <#= arg.Ordinal #> source sequence.</param>
+        /// <param name="<#= arg.Ordinal #>">The <#= arg.Ordinal #> source sequence.</param>
 <#} #>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
@@ -193,12 +186,12 @@ namespace MoreLinq
         /// </remarks>
         public static IEnumerable<TResult> ZipLongest<<#= o.Types#>, TResult>(
 <# foreach (var arg in o.Arguments) { #>
-            <#= arg.Num == 1 ? "this " : "" #>IEnumerable<T<#= arg.Number #>> <#= arg.Ordinal #>Source,
+            <#= arg.Num == 1 ? "this " : "" #>IEnumerable<T<#= arg.Number #>> <#= arg.Ordinal #>,
 <#}#>
             Func<<#= o.Types#>, TResult> resultSelector)
         {
 <# foreach (var arg in o.Arguments) { #>
-            if (<#= arg.Ordinal #>Source == null) throw new ArgumentNullException(nameof(<#= arg.Ordinal #>Source));
+            if (<#= arg.Ordinal #> == null) throw new ArgumentNullException(nameof(<#= arg.Ordinal #>));
 <#} #>
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
@@ -211,7 +204,7 @@ namespace MoreLinq
                 try
                 {
 <# foreach (var arg in o.Arguments) { #>
-                    e<#= arg.Number #> = <#= arg.Ordinal #>Source.GetEnumerator();
+                    e<#= arg.Number #> = <#= arg.Ordinal #>.GetEnumerator();
 <#} #>
 
 <# foreach (var arg in o.Arguments) { #>
@@ -246,7 +239,7 @@ namespace MoreLinq
         /// <typeparam name="T<#= arg.Number #>">Type of elements in <#= arg.Ordinal #> input sequence.</typeparam>
 <#} #>
 <# foreach (var arg in o.Arguments) { #>
-        /// <param name="<#= arg.Ordinal #>Source">The <#= arg.Ordinal #> source sequence.</param>
+        /// <param name="<#= arg.Ordinal #>">The <#= arg.Ordinal #> source sequence.</param>
 <#} #>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
@@ -256,12 +249,12 @@ namespace MoreLinq
         /// </remarks>
         public static IEnumerable<(<#= o.Types#>)> ZipLongest<<#= o.Types#>>(
 <# foreach (var arg in o.Arguments) { #>
-            <#= arg.Num == 1 ? "this " : "" #>IEnumerable<T<#= arg.Number #>> <#= arg.Ordinal #>Source<#= arg.Num < o.Count ? "," : ")" #>
+            <#= arg.Num == 1 ? "this " : "" #>IEnumerable<T<#= arg.Number #>> <#= arg.Ordinal #><#= arg.Num < o.Count ? "," : ")" #>
 <#}#>
         {
             return ZipLongest(
 <# foreach (var arg in o.Arguments) { #>
-                <#= arg.Ordinal #>Source,
+                <#= arg.Ordinal #>,
 <#}#>
                 ValueTuple.Create);
         }
@@ -276,7 +269,7 @@ namespace MoreLinq
 <#} #>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
 <# foreach (var arg in o.Arguments) { #>
-        /// <param name="<#= arg.Ordinal #>Source">The <#= arg.Ordinal #> source sequence.</param>
+        /// <param name="<#= arg.Ordinal #>">The <#= arg.Ordinal #> source sequence.</param>
 <#} #>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
@@ -295,19 +288,19 @@ namespace MoreLinq
 
         public static IEnumerable<TResult> ZipShortest<<#= o.Types#>, TResult>(
 <# foreach (var arg in o.Arguments) { #>
-            <#= arg.Num == 1 ? "this " : "" #>IEnumerable<T<#= arg.Number #>> <#= arg.Ordinal #>Source,
+            <#= arg.Num == 1 ? "this " : "" #>IEnumerable<T<#= arg.Number #>> <#= arg.Ordinal #>,
 <#}#>
             Func<<#= o.Types#>, TResult> resultSelector)
         {
 <# foreach (var arg in o.Arguments) { #>
-            if (<#= arg.Ordinal #>Source == null) throw new ArgumentNullException(nameof(<#= arg.Ordinal #>Source));
+            if (<#= arg.Ordinal #> == null) throw new ArgumentNullException(nameof(<#= arg.Ordinal #>));
 <#} #>
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
             return _(); IEnumerable<TResult> _()
             {
 <# foreach (var arg in o.Arguments) { #>
-                using var e<#= arg.Number #> = <#= arg.Ordinal #>Source.GetEnumerator();
+                using var e<#= arg.Number #> = <#= arg.Ordinal #>.GetEnumerator();
 <#} #>
 
                 while (<# foreach (var arg in o.Arguments) { #>e<#= arg.Number #>.MoveNext()<#= arg.Num < o.Count ? " && " : "" #><#}#>)
@@ -326,7 +319,7 @@ namespace MoreLinq
         /// <typeparam name="T<#= arg.Number #>">Type of elements in <#= arg.Ordinal #> input sequence.</typeparam>
 <#} #>
 <# foreach (var arg in o.Arguments) { #>
-        /// <param name="<#= arg.Ordinal #>Source">The <#= arg.Ordinal #> source sequence.</param>
+        /// <param name="<#= arg.Ordinal #>">The <#= arg.Ordinal #> source sequence.</param>
 <#} #>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
@@ -343,37 +336,16 @@ namespace MoreLinq
 
         public static IEnumerable<(<#= o.Types#>)> ZipShortest<<#= o.Types#>>(
 <# foreach (var arg in o.Arguments) { #>
-            <#= arg.Num == 1 ? "this " : "" #>IEnumerable<T<#= arg.Number #>> <#= arg.Ordinal #>Source<#= arg.Num < o.Count ? "," : ")" #>
+            <#= arg.Num == 1 ? "this " : "" #>IEnumerable<T<#= arg.Number #>> <#= arg.Ordinal #><#= arg.Num < o.Count ? "," : ")" #>
 <#}#>
         {
             return ZipShortest(
 <# foreach (var arg in o.Arguments) { #>
-                <#= arg.Ordinal #>Source,
+                <#= arg.Ordinal #>,
 <#}#>
                 ValueTuple.Create);
         }
 
 <#  } #>
-        static class ZipHelper
-        {
-            public static bool MoveNextOrDefault<T>(ref IEnumerator<T> enumerator, ref T value)
-            {
-                if (enumerator == null)
-                {
-                    return false;
-                }
-
-                if (enumerator.MoveNext())
-                {
-                    value = enumerator.Current;
-                    return true;
-                }
-
-                enumerator.Dispose();
-                enumerator = null;
-                value = default;
-                return false;
-            }
-        }
     }
 }

From 236123acf83ae53226c4d1b9d2f187d027b25bee Mon Sep 17 00:00:00 2001
From: Orace <pierre.lando@gmail.com>
Date: Wed, 6 Nov 2019 10:39:18 +0100
Subject: [PATCH 07/11] Refactor Zip.g.tt

---
 MoreLinq/Zip.g.tt | 157 ++++++++++++++++++++++------------------------
 1 file changed, 76 insertions(+), 81 deletions(-)

diff --git a/MoreLinq/Zip.g.tt b/MoreLinq/Zip.g.tt
index fba441e95..acf41571f 100644
--- a/MoreLinq/Zip.g.tt
+++ b/MoreLinq/Zip.g.tt
@@ -22,40 +22,35 @@
 #endregion
 
 <#
+    var ordinals = new[]
+    {
+        "",
+        "first", "second", "third", "fourth",
+        "fifth", "sixth", "seventh", "eighth"
+    };
+
     var overloads =
-        from args in new[]
-        {
-            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" },
-            }
-        }
-        select args.Select((a, i) => new
-        {
-            a.Ordinal,
-            a.Arity,
-            Count = i + 1,
-            Number = (i + 1).ToString(CultureInfo.InvariantCulture),
-        })
-        into args
-        select args.ToList() into args
-        from a in args.Skip(1)
-        select new
-        {
-            a.Arity,
-            a.Count,
-            Arguments = args.Take(a.Count)
-                            .Select(aa => new { aa.Number, Num = aa.Count, aa.Ordinal })
-                            .ToList(),
-            Types = string.Join(", ", Enumerable.Range(1, a.Count).Select(i => $"T{i}")),
-        };
+        Enumerable.Range(2, 7)
+            .Select(argCount =>
+                Enumerable.Range(1, argCount).Select(argPosition =>
+                    new
+                    {
+                        IsFirst = argPosition == 1,
+                        IsLast = argPosition == argCount,
+                        Name = ordinals[argPosition],
+                        Ordinal = ordinals[argPosition],
+                        Type = $"T{argPosition}",
+                        // Objects associated with the argument
+                        Enumerator = $"e{argPosition}",
+                        Value = $"v{argPosition}"
+                    }))
+            .Select(args => args.ToList())
+            .Select(args =>
+                new
+                {
+                    Arguments = args,
+                    TParams = string.Join(", ", args.Select(arg => arg.Type))
+                });
 #>
 namespace MoreLinq
 {
@@ -73,11 +68,11 @@ namespace MoreLinq
         /// if the input sequences are of different lengths.
         /// </summary>
 <# foreach (var arg in o.Arguments) { #>
-        /// <typeparam name="T<#= arg.Number #>">Type of elements in <#= arg.Ordinal #> input sequence.</typeparam>
+        /// <typeparam name="<#=arg.Type#>">Type of elements in <#=arg.Name#> input sequence.</typeparam>
 <#} #>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
 <# foreach (var arg in o.Arguments) { #>
-        /// <param name="<#= arg.Ordinal #>">The <#= arg.Ordinal #> source sequence.</param>
+        /// <param name="<#=arg.Name#>">The <#=arg.Ordinal#> source sequence.</param>
 <#} #>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
@@ -91,35 +86,35 @@ namespace MoreLinq
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
 
-        public static IEnumerable<TResult> EquiZip<<#= o.Types#>, TResult>(
+        public static IEnumerable<TResult> EquiZip<<#=o.TParams#>, TResult>(
 <# foreach (var arg in o.Arguments) { #>
-            <#= arg.Num == 1 ? "this " : "" #>IEnumerable<T<#= arg.Number #>> <#= arg.Ordinal #>,
-<#}#>
-            Func<<#= o.Types#>, TResult> resultSelector)
+            <#= arg.IsFirst ? "this " : "" #>IEnumerable<<#=arg.Type#>> <#=arg.Name#>,
+<#} #>
+            Func<<#=o.TParams#>, TResult> resultSelector)
         {
 <# foreach (var arg in o.Arguments) { #>
-            if (<#= arg.Ordinal #> == null) throw new ArgumentNullException(nameof(<#= arg.Ordinal #>));
+            if (<#=arg.Name#> == null) throw new ArgumentNullException(nameof(<#=arg.Name#>));
 <#} #>
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
             return _(); IEnumerable<TResult> _()
             {
 <# foreach (var arg in o.Arguments) { #>
-                using var e<#= arg.Number #> = <#= arg.Ordinal #>.GetEnumerator();
+                using var <#=arg.Enumerator#> = <#=arg.Name#>.GetEnumerator();
 <#} #>
 
                 for (;;)
                 {
-                    if (e<#= o.Arguments.First().Number #>.MoveNext())
+                    if (<#=o.Arguments.First().Enumerator#>.MoveNext())
                     {
-                        if (<# foreach (var arg in o.Arguments.Skip(1)) { #>e<#= arg.Number #>.MoveNext()<#= arg.Num < o.Count ? " && " : "" #><#}#>)
-                            yield return resultSelector(<# foreach (var arg in o.Arguments) { #>e<#= arg.Number #>.Current<#= arg.Num < o.Count ? ", " : "" #><#}#>);
+                        if (<# foreach (var arg in o.Arguments.Skip(1)) { #><#=arg.Enumerator#>.MoveNext()<#= arg.IsLast ? "" : " && " #><#}#>)
+                            yield return resultSelector(<# foreach (var arg in o.Arguments) { #><#=arg.Enumerator#>.Current<#= arg.IsLast ? "" : ", " #><#}#>);
                         else
                             break;
                     }
                     else
                     {
-                        if (<# foreach (var arg in o.Arguments.Skip(1)) { #>e<#= arg.Number #>.MoveNext()<#= arg.Num < o.Count ? " || " : "" #><#}#>)
+                        if (<# foreach (var arg in o.Arguments.Skip(1)) { #><#=arg.Enumerator#>.MoveNext()<#= arg.IsLast ? "" : " || " #><#}#>)
                             break;
                         else
                             yield break;
@@ -136,10 +131,10 @@ namespace MoreLinq
         /// if the input sequences are of different lengths.
         /// </summary>
 <# foreach (var arg in o.Arguments) { #>
-        /// <typeparam name="T<#= arg.Number #>">Type of elements in <#= arg.Ordinal #> input sequence.</typeparam>
+        /// <typeparam name="<#=arg.Type#>">Type of elements in <#=arg.Name#> input sequence.</typeparam>
 <#} #>
 <# foreach (var arg in o.Arguments) { #>
-        /// <param name="<#= arg.Ordinal #>">The <#= arg.Ordinal #> source sequence.</param>
+        /// <param name="<#=arg.Name#>">The <#=arg.Ordinal#> source sequence.</param>
 <#} #>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
@@ -150,14 +145,14 @@ namespace MoreLinq
         /// <remarks>
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
-        public static IEnumerable<(<#= o.Types#>)> EquiZip<<#= o.Types#>>(
+        public static IEnumerable<(<#=o.TParams#>)> EquiZip<<#=o.TParams#>>(
 <# foreach (var arg in o.Arguments) { #>
-            <#= arg.Num == 1 ? "this " : "" #>IEnumerable<T<#= arg.Number #>> <#= arg.Ordinal #><#= arg.Num < o.Count ? "," : ")" #>
+            <#= arg.IsFirst ? "this " : "" #>IEnumerable<<#=arg.Type#>> <#=arg.Name#><#= arg.IsLast ? ")" : "," #>
 <#}#>
         {
             return EquiZip(
 <# foreach (var arg in o.Arguments) { #>
-                <#= arg.Ordinal #>,
+                <#=arg.Name#>,
 <#}#>
                 ValueTuple.Create);
         }
@@ -170,11 +165,11 @@ namespace MoreLinq
         /// for padding.
         /// </summary>
 <# foreach (var arg in o.Arguments) { #>
-        /// <typeparam name="T<#= arg.Number #>">Type of elements in <#= arg.Ordinal #> input sequence.</typeparam>
+        /// <typeparam name="<#=arg.Type#>">Type of elements in <#=arg.Name#> input sequence.</typeparam>
 <#} #>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
 <# foreach (var arg in o.Arguments) { #>
-        /// <param name="<#= arg.Ordinal #>">The <#= arg.Ordinal #> source sequence.</param>
+        /// <param name="<#=arg.Name#>">The <#=arg.Ordinal#> source sequence.</param>
 <#} #>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
@@ -184,45 +179,45 @@ namespace MoreLinq
         /// <remarks>
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
-        public static IEnumerable<TResult> ZipLongest<<#= o.Types#>, TResult>(
+        public static IEnumerable<TResult> ZipLongest<<#=o.TParams#>, TResult>(
 <# foreach (var arg in o.Arguments) { #>
-            <#= arg.Num == 1 ? "this " : "" #>IEnumerable<T<#= arg.Number #>> <#= arg.Ordinal #>,
+            <#= arg.IsFirst ? "this " : "" #>IEnumerable<<#=arg.Type#>> <#=arg.Name#>,
 <#}#>
-            Func<<#= o.Types#>, TResult> resultSelector)
+            Func<<#=o.TParams#>, TResult> resultSelector)
         {
 <# foreach (var arg in o.Arguments) { #>
-            if (<#= arg.Ordinal #> == null) throw new ArgumentNullException(nameof(<#= arg.Ordinal #>));
+            if (<#=arg.Name#> == null) throw new ArgumentNullException(nameof(<#=arg.Name#>));
 <#} #>
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
             return _(); IEnumerable<TResult> _()
             {
 <# foreach (var arg in o.Arguments) { #>
-                IEnumerator<T<#= arg.Number #>> e<#= arg.Number #> = null;
+                IEnumerator<<#=arg.Type#>> <#=arg.Enumerator#> = null;
 <#} #>
 
                 try
                 {
 <# foreach (var arg in o.Arguments) { #>
-                    e<#= arg.Number #> = <#= arg.Ordinal #>.GetEnumerator();
+                    <#=arg.Enumerator#> = <#=arg.Name#>.GetEnumerator();
 <#} #>
 
 <# foreach (var arg in o.Arguments) { #>
-                    var v<#= arg.Number #> = default(T<#= arg.Number #>);
+                    var <#=arg.Value#> = default(<#=arg.Type#>);
 <#} #>
 
                     while (
 <# foreach (var arg in o.Arguments) { #>
-                        ZipHelper.MoveNextOrDefault<T<#= arg.Number #>>(ref e<#= arg.Number #>, ref v<#= arg.Number #>)<#= arg.Num < o.Count ? " |" : ")" #>
+                        ZipHelper.MoveNextOrDefault<<#=arg.Type#>>(ref <#=arg.Enumerator#>, ref <#=arg.Value#>)<#= arg.IsLast ? ")" : " |" #>
 <#}#>
                     {
-                        yield return resultSelector(<# foreach (var arg in o.Arguments) { #>v<#= arg.Number #><#= arg.Num < o.Count ? ", " : "" #><#}#>);
+                        yield return resultSelector(<# foreach (var arg in o.Arguments) { #><#=arg.Value#><#= arg.IsLast ? "" : ", " #><#}#>);
                     }
                 }
                 finally
                 {
 <# foreach (var arg in o.Arguments) { #>
-                    e<#= arg.Number #>?.Dispose();
+                    <#=arg.Enumerator#>?.Dispose();
 <#} #>
                 }
             }
@@ -236,10 +231,10 @@ namespace MoreLinq
         /// for padding.
         /// </summary>
 <# foreach (var arg in o.Arguments) { #>
-        /// <typeparam name="T<#= arg.Number #>">Type of elements in <#= arg.Ordinal #> input sequence.</typeparam>
+        /// <typeparam name="<#=arg.Type#>">Type of elements in <#=arg.Name#> input sequence.</typeparam>
 <#} #>
 <# foreach (var arg in o.Arguments) { #>
-        /// <param name="<#= arg.Ordinal #>">The <#= arg.Ordinal #> source sequence.</param>
+        /// <param name="<#=arg.Name#>">The <#=arg.Ordinal#> source sequence.</param>
 <#} #>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
@@ -247,14 +242,14 @@ namespace MoreLinq
         /// <remarks>
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
-        public static IEnumerable<(<#= o.Types#>)> ZipLongest<<#= o.Types#>>(
+        public static IEnumerable<(<#=o.TParams#>)> ZipLongest<<#=o.TParams#>>(
 <# foreach (var arg in o.Arguments) { #>
-            <#= arg.Num == 1 ? "this " : "" #>IEnumerable<T<#= arg.Number #>> <#= arg.Ordinal #><#= arg.Num < o.Count ? "," : ")" #>
+            <#= arg.IsFirst ? "this " : "" #>IEnumerable<<#=arg.Type#>> <#=arg.Name#><#= arg.IsLast ? ")" : "," #>
 <#}#>
         {
             return ZipLongest(
 <# foreach (var arg in o.Arguments) { #>
-                <#= arg.Ordinal #>,
+                <#=arg.Name#>,
 <#}#>
                 ValueTuple.Create);
         }
@@ -265,11 +260,11 @@ namespace MoreLinq
         /// is as short as the shortest input sequence.
         /// </summary>
 <# foreach (var arg in o.Arguments) { #>
-        /// <typeparam name="T<#= arg.Number #>">Type of elements in <#= arg.Ordinal #> input sequence.</typeparam>
+        /// <typeparam name="<#=arg.Type#>">Type of elements in <#=arg.Name#> input sequence.</typeparam>
 <#} #>
         /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
 <# foreach (var arg in o.Arguments) { #>
-        /// <param name="<#= arg.Ordinal #>">The <#= arg.Ordinal #> source sequence.</param>
+        /// <param name="<#=arg.Name#>">The <#=arg.Ordinal#> source sequence.</param>
 <#} #>
         /// <param name="resultSelector">
         /// Function to apply to each tuple of elements.</param>
@@ -286,26 +281,26 @@ namespace MoreLinq
         /// This operator uses deferred execution and streams its results.</para>
         /// </remarks>
 
-        public static IEnumerable<TResult> ZipShortest<<#= o.Types#>, TResult>(
+        public static IEnumerable<TResult> ZipShortest<<#=o.TParams#>, TResult>(
 <# foreach (var arg in o.Arguments) { #>
-            <#= arg.Num == 1 ? "this " : "" #>IEnumerable<T<#= arg.Number #>> <#= arg.Ordinal #>,
+            <#= arg.IsFirst ? "this " : "" #>IEnumerable<<#=arg.Type#>> <#=arg.Name#>,
 <#}#>
-            Func<<#= o.Types#>, TResult> resultSelector)
+            Func<<#=o.TParams#>, TResult> resultSelector)
         {
 <# foreach (var arg in o.Arguments) { #>
-            if (<#= arg.Ordinal #> == null) throw new ArgumentNullException(nameof(<#= arg.Ordinal #>));
+            if (<#=arg.Name#> == null) throw new ArgumentNullException(nameof(<#=arg.Name#>));
 <#} #>
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
             return _(); IEnumerable<TResult> _()
             {
 <# foreach (var arg in o.Arguments) { #>
-                using var e<#= arg.Number #> = <#= arg.Ordinal #>.GetEnumerator();
+                using var <#=arg.Enumerator#> = <#=arg.Name#>.GetEnumerator();
 <#} #>
 
-                while (<# foreach (var arg in o.Arguments) { #>e<#= arg.Number #>.MoveNext()<#= arg.Num < o.Count ? " && " : "" #><#}#>)
+                while (<# foreach (var arg in o.Arguments) { #><#=arg.Enumerator#>.MoveNext()<#= arg.IsLast ? "" : " && " #><#}#>)
                 {
-                    yield return resultSelector(<# foreach (var arg in o.Arguments) { #>e<#= arg.Number #>.Current<#= arg.Num < o.Count ? ", " : "" #><#}#>);
+                    yield return resultSelector(<# foreach (var arg in o.Arguments) { #><#=arg.Enumerator#>.Current<#= arg.IsLast ? "" : ", " #><#}#>);
                 }
             }
         }
@@ -316,10 +311,10 @@ namespace MoreLinq
         /// is as short as the shortest input sequence.
         /// </summary>
 <# foreach (var arg in o.Arguments) { #>
-        /// <typeparam name="T<#= arg.Number #>">Type of elements in <#= arg.Ordinal #> input sequence.</typeparam>
+        /// <typeparam name="<#=arg.Type#>">Type of elements in <#=arg.Name#> input sequence.</typeparam>
 <#} #>
 <# foreach (var arg in o.Arguments) { #>
-        /// <param name="<#= arg.Ordinal #>">The <#= arg.Ordinal #> source sequence.</param>
+        /// <param name="<#=arg.Name#>">The <#=arg.Ordinal#> source sequence.</param>
 <#} #>
         /// <returns>
         /// A sequence of tuples, where each tuple contains the N-th element
@@ -334,14 +329,14 @@ namespace MoreLinq
         /// This operator uses deferred execution and streams its results.</para>
         /// </remarks>
 
-        public static IEnumerable<(<#= o.Types#>)> ZipShortest<<#= o.Types#>>(
+        public static IEnumerable<(<#=o.TParams#>)> ZipShortest<<#=o.TParams#>>(
 <# foreach (var arg in o.Arguments) { #>
-            <#= arg.Num == 1 ? "this " : "" #>IEnumerable<T<#= arg.Number #>> <#= arg.Ordinal #><#= arg.Num < o.Count ? "," : ")" #>
+            <#= arg.IsFirst ? "this " : "" #>IEnumerable<<#=arg.Type#>> <#=arg.Name#><#= arg.IsLast ? ")" : "," #>
 <#}#>
         {
             return ZipShortest(
 <# foreach (var arg in o.Arguments) { #>
-                <#= arg.Ordinal #>,
+                <#=arg.Name#>,
 <#}#>
                 ValueTuple.Create);
         }

From e8925dc2187f5475a1cdf3bdd498645846fac2ed Mon Sep 17 00:00:00 2001
From: Orace <pierre.lando@gmail.com>
Date: Wed, 6 Nov 2019 10:52:24 +0100
Subject: [PATCH 08/11] Split Zip into EquiZip, ZipLongest, ZipShortest

---
 MoreLinq/EquiZip.g.cs                    |  824 ++++++++
 MoreLinq/EquiZip.g.tt                    |  163 ++
 MoreLinq/Extensions.g.cs                 |   23 +-
 MoreLinq/MoreLinq.csproj                 |   26 +-
 MoreLinq/Zip.g.cs                        | 2413 ----------------------
 MoreLinq/Zip.g.tt                        |  346 ----
 MoreLinq/ZipLongest.g.cs                 |  901 ++++++++
 MoreLinq/ZipLongest.g.tt                 |  166 ++
 MoreLinq/{Zip.cs => ZipLongestHelper.cs} |    2 +-
 MoreLinq/ZipShortest.g.cs                |  761 +++++++
 MoreLinq/ZipShortest.g.tt                |  154 ++
 11 files changed, 3013 insertions(+), 2766 deletions(-)
 create mode 100644 MoreLinq/EquiZip.g.cs
 create mode 100644 MoreLinq/EquiZip.g.tt
 delete mode 100644 MoreLinq/Zip.g.cs
 delete mode 100644 MoreLinq/Zip.g.tt
 create mode 100644 MoreLinq/ZipLongest.g.cs
 create mode 100644 MoreLinq/ZipLongest.g.tt
 rename MoreLinq/{Zip.cs => ZipLongestHelper.cs} (97%)
 create mode 100644 MoreLinq/ZipShortest.g.cs
 create mode 100644 MoreLinq/ZipShortest.g.tt

diff --git a/MoreLinq/EquiZip.g.cs b/MoreLinq/EquiZip.g.cs
new file mode 100644
index 000000000..97f37b883
--- /dev/null
+++ b/MoreLinq/EquiZip.g.cs
@@ -0,0 +1,824 @@
+#region License and Terms
+// MoreLINQ - Extensions to LINQ to Objects
+// Copyright (c) 2019 Pierre Lando. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#endregion
+
+namespace MoreLinq
+{
+    using System;
+    using System.Collections.Generic;
+
+    static partial class MoreEnumerable
+    {
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+
+        public static IEnumerable<TResult> EquiZip<T1, T2, TResult>(
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            Func<T1, T2, TResult> resultSelector)
+        {
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return _(); IEnumerable<TResult> _()
+            {
+                using var e1 = first.GetEnumerator();
+                using var e2 = second.GetEnumerator();
+
+                for (;;)
+                {
+                    if (e1.MoveNext())
+                    {
+                        if (e2.MoveNext())
+                            yield return resultSelector(e1.Current, e2.Current);
+                        else
+                            break;
+                    }
+                    else
+                    {
+                        if (e2.MoveNext())
+                            break;
+                        else
+                            yield break;
+                    }
+                }
+
+                throw new InvalidOperationException($"Sequences differ in length.");
+            }
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <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 EquiZip(
+                first,
+                second,
+                ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+
+        public static IEnumerable<TResult> EquiZip<T1, T2, T3, TResult>(
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            Func<T1, T2, T3, TResult> resultSelector)
+        {
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
+            if (third == null) throw new ArgumentNullException(nameof(third));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return _(); IEnumerable<TResult> _()
+            {
+                using var e1 = first.GetEnumerator();
+                using var e2 = second.GetEnumerator();
+                using var e3 = third.GetEnumerator();
+
+                for (;;)
+                {
+                    if (e1.MoveNext())
+                    {
+                        if (e2.MoveNext() && e3.MoveNext())
+                            yield return resultSelector(e1.Current, e2.Current, e3.Current);
+                        else
+                            break;
+                    }
+                    else
+                    {
+                        if (e2.MoveNext() || e3.MoveNext())
+                            break;
+                        else
+                            yield break;
+                    }
+                }
+
+                throw new InvalidOperationException($"Sequences differ in length.");
+            }
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <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 EquiZip(
+                first,
+                second,
+                third,
+                ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+
+        public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, TResult>(
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            Func<T1, T2, T3, T4, TResult> resultSelector)
+        {
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
+            if (third == null) throw new ArgumentNullException(nameof(third));
+            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return _(); IEnumerable<TResult> _()
+            {
+                using var e1 = first.GetEnumerator();
+                using var e2 = second.GetEnumerator();
+                using var e3 = third.GetEnumerator();
+                using var e4 = fourth.GetEnumerator();
+
+                for (;;)
+                {
+                    if (e1.MoveNext())
+                    {
+                        if (e2.MoveNext() && e3.MoveNext() && e4.MoveNext())
+                            yield return resultSelector(e1.Current, e2.Current, e3.Current, e4.Current);
+                        else
+                            break;
+                    }
+                    else
+                    {
+                        if (e2.MoveNext() || e3.MoveNext() || e4.MoveNext())
+                            break;
+                        else
+                            yield break;
+                    }
+                }
+
+                throw new InvalidOperationException($"Sequences differ in length.");
+            }
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <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 EquiZip(
+                first,
+                second,
+                third,
+                fourth,
+                ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+
+        public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, TResult>(
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth,
+            Func<T1, T2, T3, T4, T5, TResult> resultSelector)
+        {
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
+            if (third == null) throw new ArgumentNullException(nameof(third));
+            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
+            if (fifth == null) throw new ArgumentNullException(nameof(fifth));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return _(); IEnumerable<TResult> _()
+            {
+                using var e1 = first.GetEnumerator();
+                using var e2 = second.GetEnumerator();
+                using var e3 = third.GetEnumerator();
+                using var e4 = fourth.GetEnumerator();
+                using var e5 = fifth.GetEnumerator();
+
+                for (;;)
+                {
+                    if (e1.MoveNext())
+                    {
+                        if (e2.MoveNext() && e3.MoveNext() && e4.MoveNext() && e5.MoveNext())
+                            yield return resultSelector(e1.Current, e2.Current, e3.Current, e4.Current, e5.Current);
+                        else
+                            break;
+                    }
+                    else
+                    {
+                        if (e2.MoveNext() || e3.MoveNext() || e4.MoveNext() || e5.MoveNext())
+                            break;
+                        else
+                            yield break;
+                    }
+                }
+
+                throw new InvalidOperationException($"Sequences differ in length.");
+            }
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+
+        public static IEnumerable<(T1, T2, T3, T4, T5)> EquiZip<T1, T2, T3, T4, T5>(
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth)
+        {
+            return EquiZip(
+                first,
+                second,
+                third,
+                fourth,
+                fifth,
+                ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+
+        public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, TResult>(
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth,
+            IEnumerable<T6> sixth,
+            Func<T1, T2, T3, T4, T5, T6, TResult> resultSelector)
+        {
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
+            if (third == null) throw new ArgumentNullException(nameof(third));
+            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
+            if (fifth == null) throw new ArgumentNullException(nameof(fifth));
+            if (sixth == null) throw new ArgumentNullException(nameof(sixth));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return _(); IEnumerable<TResult> _()
+            {
+                using var e1 = first.GetEnumerator();
+                using var e2 = second.GetEnumerator();
+                using var e3 = third.GetEnumerator();
+                using var e4 = fourth.GetEnumerator();
+                using var e5 = fifth.GetEnumerator();
+                using var e6 = sixth.GetEnumerator();
+
+                for (;;)
+                {
+                    if (e1.MoveNext())
+                    {
+                        if (e2.MoveNext() && e3.MoveNext() && e4.MoveNext() && e5.MoveNext() && e6.MoveNext())
+                            yield return resultSelector(e1.Current, e2.Current, e3.Current, e4.Current, e5.Current, e6.Current);
+                        else
+                            break;
+                    }
+                    else
+                    {
+                        if (e2.MoveNext() || e3.MoveNext() || e4.MoveNext() || e5.MoveNext() || e6.MoveNext())
+                            break;
+                        else
+                            yield break;
+                    }
+                }
+
+                throw new InvalidOperationException($"Sequences differ in length.");
+            }
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+
+        public static IEnumerable<(T1, T2, T3, T4, T5, T6)> EquiZip<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 EquiZip(
+                first,
+                second,
+                third,
+                fourth,
+                fifth,
+                sixth,
+                ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <param name="seventh">The seventh source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+
+        public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, T7, TResult>(
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth,
+            IEnumerable<T6> sixth,
+            IEnumerable<T7> seventh,
+            Func<T1, T2, T3, T4, T5, T6, T7, TResult> resultSelector)
+        {
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
+            if (third == null) throw new ArgumentNullException(nameof(third));
+            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
+            if (fifth == null) throw new ArgumentNullException(nameof(fifth));
+            if (sixth == null) throw new ArgumentNullException(nameof(sixth));
+            if (seventh == null) throw new ArgumentNullException(nameof(seventh));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return _(); IEnumerable<TResult> _()
+            {
+                using var e1 = first.GetEnumerator();
+                using var e2 = second.GetEnumerator();
+                using var e3 = third.GetEnumerator();
+                using var e4 = fourth.GetEnumerator();
+                using var e5 = fifth.GetEnumerator();
+                using var e6 = sixth.GetEnumerator();
+                using var e7 = seventh.GetEnumerator();
+
+                for (;;)
+                {
+                    if (e1.MoveNext())
+                    {
+                        if (e2.MoveNext() && e3.MoveNext() && e4.MoveNext() && e5.MoveNext() && e6.MoveNext() && e7.MoveNext())
+                            yield return resultSelector(e1.Current, e2.Current, e3.Current, e4.Current, e5.Current, e6.Current, e7.Current);
+                        else
+                            break;
+                    }
+                    else
+                    {
+                        if (e2.MoveNext() || e3.MoveNext() || e4.MoveNext() || e5.MoveNext() || e6.MoveNext() || e7.MoveNext())
+                            break;
+                        else
+                            yield break;
+                    }
+                }
+
+                throw new InvalidOperationException($"Sequences differ in length.");
+            }
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <param name="seventh">The seventh source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+
+        public static IEnumerable<(T1, T2, T3, T4, T5, T6, T7)> EquiZip<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 EquiZip(
+                first,
+                second,
+                third,
+                fourth,
+                fifth,
+                sixth,
+                seventh,
+                ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
+        /// <typeparam name="T8">Type of elements in eighth input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <param name="seventh">The seventh source sequence.</param>
+        /// <param name="eighth">The eighth source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+
+        public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(
+            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,
+            Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> resultSelector)
+        {
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
+            if (third == null) throw new ArgumentNullException(nameof(third));
+            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
+            if (fifth == null) throw new ArgumentNullException(nameof(fifth));
+            if (sixth == null) throw new ArgumentNullException(nameof(sixth));
+            if (seventh == null) throw new ArgumentNullException(nameof(seventh));
+            if (eighth == null) throw new ArgumentNullException(nameof(eighth));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return _(); IEnumerable<TResult> _()
+            {
+                using var e1 = first.GetEnumerator();
+                using var e2 = second.GetEnumerator();
+                using var e3 = third.GetEnumerator();
+                using var e4 = fourth.GetEnumerator();
+                using var e5 = fifth.GetEnumerator();
+                using var e6 = sixth.GetEnumerator();
+                using var e7 = seventh.GetEnumerator();
+                using var e8 = eighth.GetEnumerator();
+
+                for (;;)
+                {
+                    if (e1.MoveNext())
+                    {
+                        if (e2.MoveNext() && e3.MoveNext() && e4.MoveNext() && e5.MoveNext() && e6.MoveNext() && e7.MoveNext() && e8.MoveNext())
+                            yield return resultSelector(e1.Current, e2.Current, e3.Current, e4.Current, e5.Current, e6.Current, e7.Current, e8.Current);
+                        else
+                            break;
+                    }
+                    else
+                    {
+                        if (e2.MoveNext() || e3.MoveNext() || e4.MoveNext() || e5.MoveNext() || e6.MoveNext() || e7.MoveNext() || e8.MoveNext())
+                            break;
+                        else
+                            yield break;
+                    }
+                }
+
+                throw new InvalidOperationException($"Sequences differ in length.");
+            }
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
+        /// <typeparam name="T8">Type of elements in eighth input sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <param name="seventh">The seventh source sequence.</param>
+        /// <param name="eighth">The eighth source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+
+        public static IEnumerable<(T1, T2, T3, T4, T5, T6, T7, T8)> EquiZip<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 EquiZip(
+                first,
+                second,
+                third,
+                fourth,
+                fifth,
+                sixth,
+                seventh,
+                eighth,
+                ValueTuple.Create);
+        }
+
+    }
+}
diff --git a/MoreLinq/EquiZip.g.tt b/MoreLinq/EquiZip.g.tt
new file mode 100644
index 000000000..0a5644995
--- /dev/null
+++ b/MoreLinq/EquiZip.g.tt
@@ -0,0 +1,163 @@
+<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ output extension=".cs" #>
+<#@ assembly name="System.Core" #>
+<#@ assembly name="System.Collections" #>
+<#@ import namespace="System.Globalization" #>
+<#@ import namespace="System.Linq" #>
+#region License and Terms
+// MoreLINQ - Extensions to LINQ to Objects
+// Copyright (c) 2019 Pierre Lando. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#endregion
+
+<#
+    var ordinals = new[]
+    {
+        "",
+        "first", "second", "third", "fourth",
+        "fifth", "sixth", "seventh", "eighth"
+    };
+
+    var overloads =
+        Enumerable.Range(2, 7)
+            .Select(argCount =>
+                Enumerable.Range(1, argCount).Select(argPosition =>
+                    new
+                    {
+                        IsFirst = argPosition == 1,
+                        IsLast = argPosition == argCount,
+                        Name = ordinals[argPosition],
+                        Ordinal = ordinals[argPosition],
+                        Type = $"T{argPosition}",
+                        // Objects associated with the argument
+                        Enumerator = $"e{argPosition}",
+                        Value = $"v{argPosition}"
+                    }))
+            .Select(args => args.ToList())
+            .Select(args =>
+                new
+                {
+                    Arguments = args,
+                    TParams = string.Join(", ", args.Select(arg => arg.Type))
+                });
+#>
+namespace MoreLinq
+{
+    using System;
+    using System.Collections.Generic;
+
+    static partial class MoreEnumerable
+    {
+<#  foreach (var o in overloads)
+    {
+#>
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+<# foreach (var arg in o.Arguments) { #>
+        /// <typeparam name="<#=arg.Type#>">Type of elements in <#=arg.Name#> input sequence.</typeparam>
+<#  } #>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+<# foreach (var arg in o.Arguments) { #>
+        /// <param name="<#=arg.Name#>">The <#=arg.Ordinal#> source sequence.</param>
+<#  } #>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+
+        public static IEnumerable<TResult> EquiZip<<#=o.TParams#>, TResult>(
+<# foreach (var arg in o.Arguments) { #>
+            <#= arg.IsFirst ? "this " : "" #>IEnumerable<<#=arg.Type#>> <#=arg.Name#>,
+<#  } #>
+            Func<<#=o.TParams#>, TResult> resultSelector)
+        {
+<# foreach (var arg in o.Arguments) { #>
+            if (<#=arg.Name#> == null) throw new ArgumentNullException(nameof(<#=arg.Name#>));
+<#  } #>
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return _(); IEnumerable<TResult> _()
+            {
+<# foreach (var arg in o.Arguments) { #>
+                using var <#=arg.Enumerator#> = <#=arg.Name#>.GetEnumerator();
+<#  } #>
+
+                for (;;)
+                {
+                    if (<#=o.Arguments.First().Enumerator#>.MoveNext())
+                    {
+                        if (<# foreach (var arg in o.Arguments.Skip(1)) { #><#=arg.Enumerator#>.MoveNext()<#= arg.IsLast ? "" : " && " #><#}#>)
+                            yield return resultSelector(<# foreach (var arg in o.Arguments) { #><#=arg.Enumerator#>.Current<#= arg.IsLast ? "" : ", " #><#}#>);
+                        else
+                            break;
+                    }
+                    else
+                    {
+                        if (<# foreach (var arg in o.Arguments.Skip(1)) { #><#=arg.Enumerator#>.MoveNext()<#= arg.IsLast ? "" : " || " #><#}#>)
+                            break;
+                        else
+                            yield break;
+                    }
+                }
+
+                throw new InvalidOperationException($"Sequences differ in length.");
+            }
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. An exception is thrown
+        /// if the input sequences are of different lengths.
+        /// </summary>
+<# foreach (var arg in o.Arguments) { #>
+        /// <typeparam name="<#=arg.Type#>">Type of elements in <#=arg.Name#> input sequence.</typeparam>
+<#  } #>
+<# foreach (var arg in o.Arguments) { #>
+        /// <param name="<#=arg.Name#>">The <#=arg.Ordinal#> source sequence.</param>
+<#  } #>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <exception cref="InvalidOperationException">
+        /// The input sequences are of different lengths.
+        /// </exception>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+
+        public static IEnumerable<(<#=o.TParams#>)> EquiZip<<#=o.TParams#>>(
+<# foreach (var arg in o.Arguments) { #>
+            <#= arg.IsFirst ? "this " : "" #>IEnumerable<<#=arg.Type#>> <#=arg.Name#><#= arg.IsLast ? ")" : "," #>
+<#  } #>
+        {
+            return EquiZip(
+<# foreach (var arg in o.Arguments) { #>
+                <#=arg.Name#>,
+<#  } #>
+                ValueTuple.Create);
+        }
+
+<#  } #>
+    }
+}
diff --git a/MoreLinq/Extensions.g.cs b/MoreLinq/Extensions.g.cs
index 4b2a4d2e2..a1499c011 100644
--- a/MoreLinq/Extensions.g.cs
+++ b/MoreLinq/Extensions.g.cs
@@ -1343,6 +1343,7 @@ public static partial class EquiZipExtension
         /// <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)
@@ -1368,6 +1369,7 @@ public static partial class EquiZipExtension
         /// <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,
@@ -1423,6 +1425,7 @@ public static IEnumerable<TResult> EquiZip<T1, T2, TResult>(
         /// <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,
@@ -1485,6 +1488,7 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, TResult>(
         /// <remarks>
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
+
         public static IEnumerable<(T1, T2, T3, T4, T5)> EquiZip<T1, T2, T3, T4, T5>(
             this IEnumerable<T1> first,
             IEnumerable<T2> second,
@@ -1553,6 +1557,7 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, TResult>(
         /// <remarks>
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
+
         public static IEnumerable<(T1, T2, T3, T4, T5, T6)> EquiZip<T1, T2, T3, T4, T5, T6>(
             this IEnumerable<T1> first,
             IEnumerable<T2> second,
@@ -1627,6 +1632,7 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, TResult>(
         /// <remarks>
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
+
         public static IEnumerable<(T1, T2, T3, T4, T5, T6, T7)> EquiZip<T1, T2, T3, T4, T5, T6, T7>(
             this IEnumerable<T1> first,
             IEnumerable<T2> second,
@@ -1707,6 +1713,7 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, TResult>(
         /// <remarks>
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
+
         public static IEnumerable<(T1, T2, T3, T4, T5, T6, T7, T8)> EquiZip<T1, T2, T3, T4, T5, T6, T7, T8>(
             this IEnumerable<T1> first,
             IEnumerable<T2> second,
@@ -7165,6 +7172,7 @@ public static partial class ZipLongestExtension
         /// <remarks>
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
+
         public static IEnumerable<(T1, T2)> ZipLongest<T1, T2>(
             this IEnumerable<T1> first,
             IEnumerable<T2> second)
@@ -7189,12 +7197,12 @@ public static partial class ZipLongestExtension
         /// <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 input sequences. The resulting sequence
@@ -7215,6 +7223,7 @@ public static partial class ZipLongestExtension
         /// <remarks>
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
+
         public static IEnumerable<TResult> ZipLongest<T1, T2, TResult>(
             this IEnumerable<T1> first,
             IEnumerable<T2> second,
@@ -7242,6 +7251,7 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, TResult>(
         /// <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,
@@ -7271,6 +7281,7 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, TResult>(
         /// <remarks>
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
+
         public static IEnumerable<TResult> ZipLongest<T1, T2, T3, TResult>(
             this IEnumerable<T1> first,
             IEnumerable<T2> second,
@@ -7301,6 +7312,7 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, TResult>(
         /// <remarks>
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
+
         public static IEnumerable<(T1, T2, T3, T4, T5)> ZipLongest<T1, T2, T3, T4, T5>(
             this IEnumerable<T1> first,
             IEnumerable<T2> second,
@@ -7333,6 +7345,7 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, TResult>(
         /// <remarks>
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
+
         public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, TResult>(
             this IEnumerable<T1> first,
             IEnumerable<T2> second,
@@ -7366,6 +7379,7 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, TResult>(
         /// <remarks>
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
+
         public static IEnumerable<(T1, T2, T3, T4, T5, T6)> ZipLongest<T1, T2, T3, T4, T5, T6>(
             this IEnumerable<T1> first,
             IEnumerable<T2> second,
@@ -7401,6 +7415,7 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, TResult>(
         /// <remarks>
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
+
         public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, TResult>(
             this IEnumerable<T1> first,
             IEnumerable<T2> second,
@@ -7437,6 +7452,7 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, TResult>(
         /// <remarks>
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
+
         public static IEnumerable<(T1, T2, T3, T4, T5, T6, T7)> ZipLongest<T1, T2, T3, T4, T5, T6, T7>(
             this IEnumerable<T1> first,
             IEnumerable<T2> second,
@@ -7475,6 +7491,7 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, TResult>(
         /// <remarks>
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
+
         public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, TResult>(
             this IEnumerable<T1> first,
             IEnumerable<T2> second,
@@ -7514,6 +7531,7 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, TResult>(
         /// <remarks>
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
+
         public static IEnumerable<(T1, T2, T3, T4, T5, T6, T7, T8)> ZipLongest<T1, T2, T3, T4, T5, T6, T7, T8>(
             this IEnumerable<T1> first,
             IEnumerable<T2> second,
@@ -7555,6 +7573,7 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, TResult>(
         /// <remarks>
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
+
         public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, T7, TResult>(
             this IEnumerable<T1> first,
             IEnumerable<T2> second,
@@ -7598,6 +7617,7 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, T7, TResul
         /// <remarks>
         /// This operator uses deferred execution and streams its results.
         /// </remarks>
+
         public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(
             this IEnumerable<T1> first,
             IEnumerable<T2> second,
@@ -7674,7 +7694,6 @@ public static partial class ZipShortestExtension
             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 input sequences. The resulting sequence
diff --git a/MoreLinq/MoreLinq.csproj b/MoreLinq/MoreLinq.csproj
index db2b6cc08..9c27744f5 100644
--- a/MoreLinq/MoreLinq.csproj
+++ b/MoreLinq/MoreLinq.csproj
@@ -159,6 +159,10 @@
       <Generator>TextTemplatingFileGenerator</Generator>
       <LastGenOutput>Cartesian.g.cs</LastGenOutput>
     </None>
+    <None Update="EquiZip.g.tt">
+      <Generator>TextTemplatingFileGenerator</Generator>
+      <LastGenOutput>EquiZip.g.cs</LastGenOutput>
+    </None>
     <None Update="Experimental\Aggregate.g.tt">
       <LastGenOutput>Aggregate.g.cs</LastGenOutput>
       <Generator>TextTemplatingFileGenerator</Generator>
@@ -171,9 +175,13 @@
       <Generator>TextTemplatingFileGenerator</Generator>
       <LastGenOutput>ToDelimitedString.g.cs</LastGenOutput>
     </None>
-    <None Update="Zip.g.tt">
+    <None Update="ZipLongest.g.tt">
       <Generator>TextTemplatingFileGenerator</Generator>
-      <LastGenOutput>Zip.g.cs</LastGenOutput>
+      <LastGenOutput>ZipLongest.g.cs</LastGenOutput>
+    </None>
+    <None Update="ZipShortest.g.tt">
+      <Generator>TextTemplatingFileGenerator</Generator>
+      <LastGenOutput>ZipShortest.g.cs</LastGenOutput>
     </None>
   </ItemGroup>
 
@@ -216,6 +224,11 @@
       <AutoGen>True</AutoGen>
       <DependentUpon>Cartesian.g.tt</DependentUpon>
     </Compile>
+    <Compile Update="EquiZip.g.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>EquiZip.g.tt</DependentUpon>
+    </Compile>
     <Compile Update="Experimental\Aggregate.g.cs">
       <DesignTime>True</DesignTime>
       <AutoGen>True</AutoGen>
@@ -239,10 +252,15 @@
       <AutoGen>True</AutoGen>
       <DependentUpon>ToDelimitedString.g.tt</DependentUpon>
     </Compile>
-    <Compile Update="Zip.g.cs">
+    <Compile Update="ZipLongest.g.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>ZipLongest.g.tt</DependentUpon>
+    </Compile>
+    <Compile Update="ZipShortest.g.cs">
       <DesignTime>True</DesignTime>
       <AutoGen>True</AutoGen>
-      <DependentUpon>Zip.g.tt</DependentUpon>
+      <DependentUpon>ZipShortest.g.tt</DependentUpon>
     </Compile>
   </ItemGroup>
 
diff --git a/MoreLinq/Zip.g.cs b/MoreLinq/Zip.g.cs
deleted file mode 100644
index f191db6f6..000000000
--- a/MoreLinq/Zip.g.cs
+++ /dev/null
@@ -1,2413 +0,0 @@
-#region License and Terms
-// MoreLINQ - Extensions to LINQ to Objects
-// Copyright (c) 2019 Pierre Lando. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-#endregion
-
-namespace MoreLinq
-{
-    using System;
-    using System.Collections.Generic;
-
-    static partial class MoreEnumerable
-    {
-        /// <summary>
-        /// Returns a projection of tuples, where each tuple contains the N-th
-        /// element from each of the input sequences. An exception is thrown
-        /// if the input sequences are of different lengths.
-        /// </summary>
-        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <param name="resultSelector">
-        /// Function to apply to each tuple of elements.</param>
-        /// <returns>
-        /// A projection of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <exception cref="InvalidOperationException">
-        /// The input sequences are of different lengths.
-        /// </exception>
-        /// <remarks>
-        /// This operator uses deferred execution and streams its results.
-        /// </remarks>
-
-        public static IEnumerable<TResult> EquiZip<T1, T2, TResult>(
-            this IEnumerable<T1> first,
-            IEnumerable<T2> second,
-            Func<T1, T2, TResult> resultSelector)
-        {
-            if (first == null) throw new ArgumentNullException(nameof(first));
-            if (second == null) throw new ArgumentNullException(nameof(second));
-            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
-
-            return _(); IEnumerable<TResult> _()
-            {
-                using var e1 = first.GetEnumerator();
-                using var e2 = second.GetEnumerator();
-
-                for (;;)
-                {
-                    if (e1.MoveNext())
-                    {
-                        if (e2.MoveNext())
-                            yield return resultSelector(e1.Current, e2.Current);
-                        else
-                            break;
-                    }
-                    else
-                    {
-                        if (e2.MoveNext())
-                            break;
-                        else
-                            yield break;
-                    }
-                }
-
-                throw new InvalidOperationException($"Sequences differ in length.");
-            }
-        }
-
-        /// <summary>
-        /// Returns a sequence of tuples, where each tuple contains the N-th
-        /// element from each of the input sequences. An exception is thrown
-        /// if the input sequences are of different lengths.
-        /// </summary>
-        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <returns>
-        /// A sequence of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <exception cref="InvalidOperationException">
-        /// The input sequences are of different lengths.
-        /// </exception>
-        /// <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 EquiZip(
-                first,
-                second,
-                ValueTuple.Create);
-        }
-
-        /// <summary>
-        /// Returns a projection of tuples, where each tuple contains the N-th
-        /// element from each of the input 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 input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <param name="resultSelector">
-        /// Function to apply to each tuple of elements.</param>
-        /// <returns>
-        /// A projection of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <remarks>
-        /// This operator uses deferred execution and streams its results.
-        /// </remarks>
-        public static IEnumerable<TResult> ZipLongest<T1, T2, TResult>(
-            this IEnumerable<T1> first,
-            IEnumerable<T2> second,
-            Func<T1, T2, TResult> resultSelector)
-        {
-            if (first == null) throw new ArgumentNullException(nameof(first));
-            if (second == null) throw new ArgumentNullException(nameof(second));
-            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
-
-            return _(); IEnumerable<TResult> _()
-            {
-                IEnumerator<T1> e1 = null;
-                IEnumerator<T2> e2 = null;
-
-                try
-                {
-                    e1 = first.GetEnumerator();
-                    e2 = second.GetEnumerator();
-
-                    var v1 = default(T1);
-                    var v2 = default(T2);
-
-                    while (
-                        ZipHelper.MoveNextOrDefault<T1>(ref e1, ref v1) |
-                        ZipHelper.MoveNextOrDefault<T2>(ref e2, ref v2))
-                    {
-                        yield return resultSelector(v1, v2);
-                    }
-                }
-                finally
-                {
-                    e1?.Dispose();
-                    e2?.Dispose();
-                }
-            }
-        }
-
-        /// <summary>
-        /// Returns a sequence of tuples, where each tuple contains the N-th
-        /// element from each of the input 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 input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <returns>
-        /// A sequence of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <remarks>
-        /// This operator uses deferred execution and streams its results.
-        /// </remarks>
-        public static IEnumerable<(T1, T2)> ZipLongest<T1, T2>(
-            this IEnumerable<T1> first,
-            IEnumerable<T2> second)
-        {
-            return ZipLongest(
-                first,
-                second,
-                ValueTuple.Create);
-        }
-
-        /// <summary>
-        /// Returns a projection of tuples, where each tuple contains the N-th
-        /// element from each of the input sequences. The resulting sequence
-        /// is as short as the shortest input sequence.
-        /// </summary>
-        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <param name="resultSelector">
-        /// Function to apply to each tuple of elements.</param>
-        /// <returns>
-        /// A projection of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <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<TResult> ZipShortest<T1, T2, TResult>(
-            this IEnumerable<T1> first,
-            IEnumerable<T2> second,
-            Func<T1, T2, TResult> resultSelector)
-        {
-            if (first == null) throw new ArgumentNullException(nameof(first));
-            if (second == null) throw new ArgumentNullException(nameof(second));
-            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
-
-            return _(); IEnumerable<TResult> _()
-            {
-                using var e1 = first.GetEnumerator();
-                using var e2 = second.GetEnumerator();
-
-                while (e1.MoveNext() && e2.MoveNext())
-                {
-                    yield return resultSelector(e1.Current, e2.Current);
-                }
-            }
-        }
-
-        /// <summary>
-        /// Returns a sequence of tuples, where each tuple contains the N-th
-        /// element from each of the input sequences. The resulting sequence
-        /// is as short as the shortest input sequence.
-        /// </summary>
-        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <returns>
-        /// A sequence of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <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)> ZipShortest<T1, T2>(
-            this IEnumerable<T1> first,
-            IEnumerable<T2> second)
-        {
-            return ZipShortest(
-                first,
-                second,
-                ValueTuple.Create);
-        }
-
-        /// <summary>
-        /// Returns a projection of tuples, where each tuple contains the N-th
-        /// element from each of the input sequences. An exception is thrown
-        /// if the input sequences are of different lengths.
-        /// </summary>
-        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <param name="third">The third source sequence.</param>
-        /// <param name="resultSelector">
-        /// Function to apply to each tuple of elements.</param>
-        /// <returns>
-        /// A projection of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <exception cref="InvalidOperationException">
-        /// The input sequences are of different lengths.
-        /// </exception>
-        /// <remarks>
-        /// This operator uses deferred execution and streams its results.
-        /// </remarks>
-
-        public static IEnumerable<TResult> EquiZip<T1, T2, T3, TResult>(
-            this IEnumerable<T1> first,
-            IEnumerable<T2> second,
-            IEnumerable<T3> third,
-            Func<T1, T2, T3, TResult> resultSelector)
-        {
-            if (first == null) throw new ArgumentNullException(nameof(first));
-            if (second == null) throw new ArgumentNullException(nameof(second));
-            if (third == null) throw new ArgumentNullException(nameof(third));
-            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
-
-            return _(); IEnumerable<TResult> _()
-            {
-                using var e1 = first.GetEnumerator();
-                using var e2 = second.GetEnumerator();
-                using var e3 = third.GetEnumerator();
-
-                for (;;)
-                {
-                    if (e1.MoveNext())
-                    {
-                        if (e2.MoveNext() && e3.MoveNext())
-                            yield return resultSelector(e1.Current, e2.Current, e3.Current);
-                        else
-                            break;
-                    }
-                    else
-                    {
-                        if (e2.MoveNext() || e3.MoveNext())
-                            break;
-                        else
-                            yield break;
-                    }
-                }
-
-                throw new InvalidOperationException($"Sequences differ in length.");
-            }
-        }
-
-        /// <summary>
-        /// Returns a sequence of tuples, where each tuple contains the N-th
-        /// element from each of the input sequences. An exception is thrown
-        /// if the input sequences are of different lengths.
-        /// </summary>
-        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <param name="third">The third source sequence.</param>
-        /// <returns>
-        /// A sequence of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <exception cref="InvalidOperationException">
-        /// The input sequences are of different lengths.
-        /// </exception>
-        /// <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 EquiZip(
-                first,
-                second,
-                third,
-                ValueTuple.Create);
-        }
-
-        /// <summary>
-        /// Returns a projection of tuples, where each tuple contains the N-th
-        /// element from each of the input 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 input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <param name="third">The third source sequence.</param>
-        /// <param name="resultSelector">
-        /// Function to apply to each tuple of elements.</param>
-        /// <returns>
-        /// A projection of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <remarks>
-        /// This operator uses deferred execution and streams its results.
-        /// </remarks>
-        public static IEnumerable<TResult> ZipLongest<T1, T2, T3, TResult>(
-            this IEnumerable<T1> first,
-            IEnumerable<T2> second,
-            IEnumerable<T3> third,
-            Func<T1, T2, T3, TResult> resultSelector)
-        {
-            if (first == null) throw new ArgumentNullException(nameof(first));
-            if (second == null) throw new ArgumentNullException(nameof(second));
-            if (third == null) throw new ArgumentNullException(nameof(third));
-            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
-
-            return _(); IEnumerable<TResult> _()
-            {
-                IEnumerator<T1> e1 = null;
-                IEnumerator<T2> e2 = null;
-                IEnumerator<T3> e3 = null;
-
-                try
-                {
-                    e1 = first.GetEnumerator();
-                    e2 = second.GetEnumerator();
-                    e3 = third.GetEnumerator();
-
-                    var v1 = default(T1);
-                    var v2 = default(T2);
-                    var v3 = default(T3);
-
-                    while (
-                        ZipHelper.MoveNextOrDefault<T1>(ref e1, ref v1) |
-                        ZipHelper.MoveNextOrDefault<T2>(ref e2, ref v2) |
-                        ZipHelper.MoveNextOrDefault<T3>(ref e3, ref v3))
-                    {
-                        yield return resultSelector(v1, v2, v3);
-                    }
-                }
-                finally
-                {
-                    e1?.Dispose();
-                    e2?.Dispose();
-                    e3?.Dispose();
-                }
-            }
-        }
-
-        /// <summary>
-        /// Returns a sequence of tuples, where each tuple contains the N-th
-        /// element from each of the input 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 input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <param name="third">The third source sequence.</param>
-        /// <returns>
-        /// A sequence of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <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 ZipLongest(
-                first,
-                second,
-                third,
-                ValueTuple.Create);
-        }
-
-        /// <summary>
-        /// Returns a projection of tuples, where each tuple contains the N-th
-        /// element from each of the input sequences. The resulting sequence
-        /// is as short as the shortest input sequence.
-        /// </summary>
-        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <param name="third">The third source sequence.</param>
-        /// <param name="resultSelector">
-        /// Function to apply to each tuple of elements.</param>
-        /// <returns>
-        /// A projection of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <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<TResult> ZipShortest<T1, T2, T3, TResult>(
-            this IEnumerable<T1> first,
-            IEnumerable<T2> second,
-            IEnumerable<T3> third,
-            Func<T1, T2, T3, TResult> resultSelector)
-        {
-            if (first == null) throw new ArgumentNullException(nameof(first));
-            if (second == null) throw new ArgumentNullException(nameof(second));
-            if (third == null) throw new ArgumentNullException(nameof(third));
-            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
-
-            return _(); IEnumerable<TResult> _()
-            {
-                using var e1 = first.GetEnumerator();
-                using var e2 = second.GetEnumerator();
-                using var e3 = third.GetEnumerator();
-
-                while (e1.MoveNext() && e2.MoveNext() && e3.MoveNext())
-                {
-                    yield return resultSelector(e1.Current, e2.Current, e3.Current);
-                }
-            }
-        }
-
-        /// <summary>
-        /// Returns a sequence of tuples, where each tuple contains the N-th
-        /// element from each of the input sequences. The resulting sequence
-        /// is as short as the shortest input sequence.
-        /// </summary>
-        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <param name="third">The third source sequence.</param>
-        /// <returns>
-        /// A sequence of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <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 ZipShortest(
-                first,
-                second,
-                third,
-                ValueTuple.Create);
-        }
-
-        /// <summary>
-        /// Returns a projection of tuples, where each tuple contains the N-th
-        /// element from each of the input sequences. An exception is thrown
-        /// if the input sequences are of different lengths.
-        /// </summary>
-        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
-        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <param name="third">The third source sequence.</param>
-        /// <param name="fourth">The fourth source sequence.</param>
-        /// <param name="resultSelector">
-        /// Function to apply to each tuple of elements.</param>
-        /// <returns>
-        /// A projection of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <exception cref="InvalidOperationException">
-        /// The input sequences are of different lengths.
-        /// </exception>
-        /// <remarks>
-        /// This operator uses deferred execution and streams its results.
-        /// </remarks>
-
-        public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, TResult>(
-            this IEnumerable<T1> first,
-            IEnumerable<T2> second,
-            IEnumerable<T3> third,
-            IEnumerable<T4> fourth,
-            Func<T1, T2, T3, T4, TResult> resultSelector)
-        {
-            if (first == null) throw new ArgumentNullException(nameof(first));
-            if (second == null) throw new ArgumentNullException(nameof(second));
-            if (third == null) throw new ArgumentNullException(nameof(third));
-            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
-            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
-
-            return _(); IEnumerable<TResult> _()
-            {
-                using var e1 = first.GetEnumerator();
-                using var e2 = second.GetEnumerator();
-                using var e3 = third.GetEnumerator();
-                using var e4 = fourth.GetEnumerator();
-
-                for (;;)
-                {
-                    if (e1.MoveNext())
-                    {
-                        if (e2.MoveNext() && e3.MoveNext() && e4.MoveNext())
-                            yield return resultSelector(e1.Current, e2.Current, e3.Current, e4.Current);
-                        else
-                            break;
-                    }
-                    else
-                    {
-                        if (e2.MoveNext() || e3.MoveNext() || e4.MoveNext())
-                            break;
-                        else
-                            yield break;
-                    }
-                }
-
-                throw new InvalidOperationException($"Sequences differ in length.");
-            }
-        }
-
-        /// <summary>
-        /// Returns a sequence of tuples, where each tuple contains the N-th
-        /// element from each of the input sequences. An exception is thrown
-        /// if the input sequences are of different lengths.
-        /// </summary>
-        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <param name="third">The third source sequence.</param>
-        /// <param name="fourth">The fourth source sequence.</param>
-        /// <returns>
-        /// A sequence of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <exception cref="InvalidOperationException">
-        /// The input sequences are of different lengths.
-        /// </exception>
-        /// <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 EquiZip(
-                first,
-                second,
-                third,
-                fourth,
-                ValueTuple.Create);
-        }
-
-        /// <summary>
-        /// Returns a projection of tuples, where each tuple contains the N-th
-        /// element from each of the input 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 input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
-        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <param name="third">The third source sequence.</param>
-        /// <param name="fourth">The fourth source sequence.</param>
-        /// <param name="resultSelector">
-        /// Function to apply to each tuple of elements.</param>
-        /// <returns>
-        /// A projection of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <remarks>
-        /// This operator uses deferred execution and streams its results.
-        /// </remarks>
-        public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, TResult>(
-            this IEnumerable<T1> first,
-            IEnumerable<T2> second,
-            IEnumerable<T3> third,
-            IEnumerable<T4> fourth,
-            Func<T1, T2, T3, T4, TResult> resultSelector)
-        {
-            if (first == null) throw new ArgumentNullException(nameof(first));
-            if (second == null) throw new ArgumentNullException(nameof(second));
-            if (third == null) throw new ArgumentNullException(nameof(third));
-            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
-            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
-
-            return _(); IEnumerable<TResult> _()
-            {
-                IEnumerator<T1> e1 = null;
-                IEnumerator<T2> e2 = null;
-                IEnumerator<T3> e3 = null;
-                IEnumerator<T4> e4 = null;
-
-                try
-                {
-                    e1 = first.GetEnumerator();
-                    e2 = second.GetEnumerator();
-                    e3 = third.GetEnumerator();
-                    e4 = fourth.GetEnumerator();
-
-                    var v1 = default(T1);
-                    var v2 = default(T2);
-                    var v3 = default(T3);
-                    var v4 = default(T4);
-
-                    while (
-                        ZipHelper.MoveNextOrDefault<T1>(ref e1, ref v1) |
-                        ZipHelper.MoveNextOrDefault<T2>(ref e2, ref v2) |
-                        ZipHelper.MoveNextOrDefault<T3>(ref e3, ref v3) |
-                        ZipHelper.MoveNextOrDefault<T4>(ref e4, ref v4))
-                    {
-                        yield return resultSelector(v1, v2, v3, v4);
-                    }
-                }
-                finally
-                {
-                    e1?.Dispose();
-                    e2?.Dispose();
-                    e3?.Dispose();
-                    e4?.Dispose();
-                }
-            }
-        }
-
-        /// <summary>
-        /// Returns a sequence of tuples, where each tuple contains the N-th
-        /// element from each of the input 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 input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <param name="third">The third source sequence.</param>
-        /// <param name="fourth">The fourth source sequence.</param>
-        /// <returns>
-        /// A sequence of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <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 ZipLongest(
-                first,
-                second,
-                third,
-                fourth,
-                ValueTuple.Create);
-        }
-
-        /// <summary>
-        /// Returns a projection of tuples, where each tuple contains the N-th
-        /// element from each of the input sequences. The resulting sequence
-        /// is as short as the shortest input sequence.
-        /// </summary>
-        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
-        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <param name="third">The third source sequence.</param>
-        /// <param name="fourth">The fourth source sequence.</param>
-        /// <param name="resultSelector">
-        /// Function to apply to each tuple of elements.</param>
-        /// <returns>
-        /// A projection of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <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<TResult> ZipShortest<T1, T2, T3, T4, TResult>(
-            this IEnumerable<T1> first,
-            IEnumerable<T2> second,
-            IEnumerable<T3> third,
-            IEnumerable<T4> fourth,
-            Func<T1, T2, T3, T4, TResult> resultSelector)
-        {
-            if (first == null) throw new ArgumentNullException(nameof(first));
-            if (second == null) throw new ArgumentNullException(nameof(second));
-            if (third == null) throw new ArgumentNullException(nameof(third));
-            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
-            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
-
-            return _(); IEnumerable<TResult> _()
-            {
-                using var e1 = first.GetEnumerator();
-                using var e2 = second.GetEnumerator();
-                using var e3 = third.GetEnumerator();
-                using var e4 = fourth.GetEnumerator();
-
-                while (e1.MoveNext() && e2.MoveNext() && e3.MoveNext() && e4.MoveNext())
-                {
-                    yield return resultSelector(e1.Current, e2.Current, e3.Current, e4.Current);
-                }
-            }
-        }
-
-        /// <summary>
-        /// Returns a sequence of tuples, where each tuple contains the N-th
-        /// element from each of the input sequences. The resulting sequence
-        /// is as short as the shortest input sequence.
-        /// </summary>
-        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <param name="third">The third source sequence.</param>
-        /// <param name="fourth">The fourth source sequence.</param>
-        /// <returns>
-        /// A sequence of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <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 ZipShortest(
-                first,
-                second,
-                third,
-                fourth,
-                ValueTuple.Create);
-        }
-
-        /// <summary>
-        /// Returns a projection of tuples, where each tuple contains the N-th
-        /// element from each of the input sequences. An exception is thrown
-        /// if the input sequences are of different lengths.
-        /// </summary>
-        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
-        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
-        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <param name="third">The third source sequence.</param>
-        /// <param name="fourth">The fourth source sequence.</param>
-        /// <param name="fifth">The fifth source sequence.</param>
-        /// <param name="resultSelector">
-        /// Function to apply to each tuple of elements.</param>
-        /// <returns>
-        /// A projection of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <exception cref="InvalidOperationException">
-        /// The input sequences are of different lengths.
-        /// </exception>
-        /// <remarks>
-        /// This operator uses deferred execution and streams its results.
-        /// </remarks>
-
-        public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, TResult>(
-            this IEnumerable<T1> first,
-            IEnumerable<T2> second,
-            IEnumerable<T3> third,
-            IEnumerable<T4> fourth,
-            IEnumerable<T5> fifth,
-            Func<T1, T2, T3, T4, T5, TResult> resultSelector)
-        {
-            if (first == null) throw new ArgumentNullException(nameof(first));
-            if (second == null) throw new ArgumentNullException(nameof(second));
-            if (third == null) throw new ArgumentNullException(nameof(third));
-            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
-            if (fifth == null) throw new ArgumentNullException(nameof(fifth));
-            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
-
-            return _(); IEnumerable<TResult> _()
-            {
-                using var e1 = first.GetEnumerator();
-                using var e2 = second.GetEnumerator();
-                using var e3 = third.GetEnumerator();
-                using var e4 = fourth.GetEnumerator();
-                using var e5 = fifth.GetEnumerator();
-
-                for (;;)
-                {
-                    if (e1.MoveNext())
-                    {
-                        if (e2.MoveNext() && e3.MoveNext() && e4.MoveNext() && e5.MoveNext())
-                            yield return resultSelector(e1.Current, e2.Current, e3.Current, e4.Current, e5.Current);
-                        else
-                            break;
-                    }
-                    else
-                    {
-                        if (e2.MoveNext() || e3.MoveNext() || e4.MoveNext() || e5.MoveNext())
-                            break;
-                        else
-                            yield break;
-                    }
-                }
-
-                throw new InvalidOperationException($"Sequences differ in length.");
-            }
-        }
-
-        /// <summary>
-        /// Returns a sequence of tuples, where each tuple contains the N-th
-        /// element from each of the input sequences. An exception is thrown
-        /// if the input sequences are of different lengths.
-        /// </summary>
-        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
-        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <param name="third">The third source sequence.</param>
-        /// <param name="fourth">The fourth source sequence.</param>
-        /// <param name="fifth">The fifth source sequence.</param>
-        /// <returns>
-        /// A sequence of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <exception cref="InvalidOperationException">
-        /// The input sequences are of different lengths.
-        /// </exception>
-        /// <remarks>
-        /// This operator uses deferred execution and streams its results.
-        /// </remarks>
-        public static IEnumerable<(T1, T2, T3, T4, T5)> EquiZip<T1, T2, T3, T4, T5>(
-            this IEnumerable<T1> first,
-            IEnumerable<T2> second,
-            IEnumerable<T3> third,
-            IEnumerable<T4> fourth,
-            IEnumerable<T5> fifth)
-        {
-            return EquiZip(
-                first,
-                second,
-                third,
-                fourth,
-                fifth,
-                ValueTuple.Create);
-        }
-
-        /// <summary>
-        /// Returns a projection of tuples, where each tuple contains the N-th
-        /// element from each of the input 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 input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
-        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
-        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <param name="third">The third source sequence.</param>
-        /// <param name="fourth">The fourth source sequence.</param>
-        /// <param name="fifth">The fifth source sequence.</param>
-        /// <param name="resultSelector">
-        /// Function to apply to each tuple of elements.</param>
-        /// <returns>
-        /// A projection of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <remarks>
-        /// This operator uses deferred execution and streams its results.
-        /// </remarks>
-        public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, TResult>(
-            this IEnumerable<T1> first,
-            IEnumerable<T2> second,
-            IEnumerable<T3> third,
-            IEnumerable<T4> fourth,
-            IEnumerable<T5> fifth,
-            Func<T1, T2, T3, T4, T5, TResult> resultSelector)
-        {
-            if (first == null) throw new ArgumentNullException(nameof(first));
-            if (second == null) throw new ArgumentNullException(nameof(second));
-            if (third == null) throw new ArgumentNullException(nameof(third));
-            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
-            if (fifth == null) throw new ArgumentNullException(nameof(fifth));
-            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
-
-            return _(); IEnumerable<TResult> _()
-            {
-                IEnumerator<T1> e1 = null;
-                IEnumerator<T2> e2 = null;
-                IEnumerator<T3> e3 = null;
-                IEnumerator<T4> e4 = null;
-                IEnumerator<T5> e5 = null;
-
-                try
-                {
-                    e1 = first.GetEnumerator();
-                    e2 = second.GetEnumerator();
-                    e3 = third.GetEnumerator();
-                    e4 = fourth.GetEnumerator();
-                    e5 = fifth.GetEnumerator();
-
-                    var v1 = default(T1);
-                    var v2 = default(T2);
-                    var v3 = default(T3);
-                    var v4 = default(T4);
-                    var v5 = default(T5);
-
-                    while (
-                        ZipHelper.MoveNextOrDefault<T1>(ref e1, ref v1) |
-                        ZipHelper.MoveNextOrDefault<T2>(ref e2, ref v2) |
-                        ZipHelper.MoveNextOrDefault<T3>(ref e3, ref v3) |
-                        ZipHelper.MoveNextOrDefault<T4>(ref e4, ref v4) |
-                        ZipHelper.MoveNextOrDefault<T5>(ref e5, ref v5))
-                    {
-                        yield return resultSelector(v1, v2, v3, v4, v5);
-                    }
-                }
-                finally
-                {
-                    e1?.Dispose();
-                    e2?.Dispose();
-                    e3?.Dispose();
-                    e4?.Dispose();
-                    e5?.Dispose();
-                }
-            }
-        }
-
-        /// <summary>
-        /// Returns a sequence of tuples, where each tuple contains the N-th
-        /// element from each of the input 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 input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
-        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <param name="third">The third source sequence.</param>
-        /// <param name="fourth">The fourth source sequence.</param>
-        /// <param name="fifth">The fifth source sequence.</param>
-        /// <returns>
-        /// A sequence of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <remarks>
-        /// This operator uses deferred execution and streams its results.
-        /// </remarks>
-        public static IEnumerable<(T1, T2, T3, T4, T5)> ZipLongest<T1, T2, T3, T4, T5>(
-            this IEnumerable<T1> first,
-            IEnumerable<T2> second,
-            IEnumerable<T3> third,
-            IEnumerable<T4> fourth,
-            IEnumerable<T5> fifth)
-        {
-            return ZipLongest(
-                first,
-                second,
-                third,
-                fourth,
-                fifth,
-                ValueTuple.Create);
-        }
-
-        /// <summary>
-        /// Returns a projection of tuples, where each tuple contains the N-th
-        /// element from each of the input sequences. The resulting sequence
-        /// is as short as the shortest input sequence.
-        /// </summary>
-        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
-        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
-        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <param name="third">The third source sequence.</param>
-        /// <param name="fourth">The fourth source sequence.</param>
-        /// <param name="fifth">The fifth source sequence.</param>
-        /// <param name="resultSelector">
-        /// Function to apply to each tuple of elements.</param>
-        /// <returns>
-        /// A projection of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <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<TResult> ZipShortest<T1, T2, T3, T4, T5, TResult>(
-            this IEnumerable<T1> first,
-            IEnumerable<T2> second,
-            IEnumerable<T3> third,
-            IEnumerable<T4> fourth,
-            IEnumerable<T5> fifth,
-            Func<T1, T2, T3, T4, T5, TResult> resultSelector)
-        {
-            if (first == null) throw new ArgumentNullException(nameof(first));
-            if (second == null) throw new ArgumentNullException(nameof(second));
-            if (third == null) throw new ArgumentNullException(nameof(third));
-            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
-            if (fifth == null) throw new ArgumentNullException(nameof(fifth));
-            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
-
-            return _(); IEnumerable<TResult> _()
-            {
-                using var e1 = first.GetEnumerator();
-                using var e2 = second.GetEnumerator();
-                using var e3 = third.GetEnumerator();
-                using var e4 = fourth.GetEnumerator();
-                using var e5 = fifth.GetEnumerator();
-
-                while (e1.MoveNext() && e2.MoveNext() && e3.MoveNext() && e4.MoveNext() && e5.MoveNext())
-                {
-                    yield return resultSelector(e1.Current, e2.Current, e3.Current, e4.Current, e5.Current);
-                }
-            }
-        }
-
-        /// <summary>
-        /// Returns a sequence of tuples, where each tuple contains the N-th
-        /// element from each of the input sequences. The resulting sequence
-        /// is as short as the shortest input sequence.
-        /// </summary>
-        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
-        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <param name="third">The third source sequence.</param>
-        /// <param name="fourth">The fourth source sequence.</param>
-        /// <param name="fifth">The fifth source sequence.</param>
-        /// <returns>
-        /// A sequence of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <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, T5)> ZipShortest<T1, T2, T3, T4, T5>(
-            this IEnumerable<T1> first,
-            IEnumerable<T2> second,
-            IEnumerable<T3> third,
-            IEnumerable<T4> fourth,
-            IEnumerable<T5> fifth)
-        {
-            return ZipShortest(
-                first,
-                second,
-                third,
-                fourth,
-                fifth,
-                ValueTuple.Create);
-        }
-
-        /// <summary>
-        /// Returns a projection of tuples, where each tuple contains the N-th
-        /// element from each of the input sequences. An exception is thrown
-        /// if the input sequences are of different lengths.
-        /// </summary>
-        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
-        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
-        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
-        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <param name="third">The third source sequence.</param>
-        /// <param name="fourth">The fourth source sequence.</param>
-        /// <param name="fifth">The fifth source sequence.</param>
-        /// <param name="sixth">The sixth source sequence.</param>
-        /// <param name="resultSelector">
-        /// Function to apply to each tuple of elements.</param>
-        /// <returns>
-        /// A projection of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <exception cref="InvalidOperationException">
-        /// The input sequences are of different lengths.
-        /// </exception>
-        /// <remarks>
-        /// This operator uses deferred execution and streams its results.
-        /// </remarks>
-
-        public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, TResult>(
-            this IEnumerable<T1> first,
-            IEnumerable<T2> second,
-            IEnumerable<T3> third,
-            IEnumerable<T4> fourth,
-            IEnumerable<T5> fifth,
-            IEnumerable<T6> sixth,
-            Func<T1, T2, T3, T4, T5, T6, TResult> resultSelector)
-        {
-            if (first == null) throw new ArgumentNullException(nameof(first));
-            if (second == null) throw new ArgumentNullException(nameof(second));
-            if (third == null) throw new ArgumentNullException(nameof(third));
-            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
-            if (fifth == null) throw new ArgumentNullException(nameof(fifth));
-            if (sixth == null) throw new ArgumentNullException(nameof(sixth));
-            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
-
-            return _(); IEnumerable<TResult> _()
-            {
-                using var e1 = first.GetEnumerator();
-                using var e2 = second.GetEnumerator();
-                using var e3 = third.GetEnumerator();
-                using var e4 = fourth.GetEnumerator();
-                using var e5 = fifth.GetEnumerator();
-                using var e6 = sixth.GetEnumerator();
-
-                for (;;)
-                {
-                    if (e1.MoveNext())
-                    {
-                        if (e2.MoveNext() && e3.MoveNext() && e4.MoveNext() && e5.MoveNext() && e6.MoveNext())
-                            yield return resultSelector(e1.Current, e2.Current, e3.Current, e4.Current, e5.Current, e6.Current);
-                        else
-                            break;
-                    }
-                    else
-                    {
-                        if (e2.MoveNext() || e3.MoveNext() || e4.MoveNext() || e5.MoveNext() || e6.MoveNext())
-                            break;
-                        else
-                            yield break;
-                    }
-                }
-
-                throw new InvalidOperationException($"Sequences differ in length.");
-            }
-        }
-
-        /// <summary>
-        /// Returns a sequence of tuples, where each tuple contains the N-th
-        /// element from each of the input sequences. An exception is thrown
-        /// if the input sequences are of different lengths.
-        /// </summary>
-        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
-        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
-        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <param name="third">The third source sequence.</param>
-        /// <param name="fourth">The fourth source sequence.</param>
-        /// <param name="fifth">The fifth source sequence.</param>
-        /// <param name="sixth">The sixth source sequence.</param>
-        /// <returns>
-        /// A sequence of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <exception cref="InvalidOperationException">
-        /// The input sequences are of different lengths.
-        /// </exception>
-        /// <remarks>
-        /// This operator uses deferred execution and streams its results.
-        /// </remarks>
-        public static IEnumerable<(T1, T2, T3, T4, T5, T6)> EquiZip<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 EquiZip(
-                first,
-                second,
-                third,
-                fourth,
-                fifth,
-                sixth,
-                ValueTuple.Create);
-        }
-
-        /// <summary>
-        /// Returns a projection of tuples, where each tuple contains the N-th
-        /// element from each of the input 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 input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
-        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
-        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
-        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <param name="third">The third source sequence.</param>
-        /// <param name="fourth">The fourth source sequence.</param>
-        /// <param name="fifth">The fifth source sequence.</param>
-        /// <param name="sixth">The sixth source sequence.</param>
-        /// <param name="resultSelector">
-        /// Function to apply to each tuple of elements.</param>
-        /// <returns>
-        /// A projection of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <remarks>
-        /// This operator uses deferred execution and streams its results.
-        /// </remarks>
-        public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, TResult>(
-            this IEnumerable<T1> first,
-            IEnumerable<T2> second,
-            IEnumerable<T3> third,
-            IEnumerable<T4> fourth,
-            IEnumerable<T5> fifth,
-            IEnumerable<T6> sixth,
-            Func<T1, T2, T3, T4, T5, T6, TResult> resultSelector)
-        {
-            if (first == null) throw new ArgumentNullException(nameof(first));
-            if (second == null) throw new ArgumentNullException(nameof(second));
-            if (third == null) throw new ArgumentNullException(nameof(third));
-            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
-            if (fifth == null) throw new ArgumentNullException(nameof(fifth));
-            if (sixth == null) throw new ArgumentNullException(nameof(sixth));
-            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
-
-            return _(); IEnumerable<TResult> _()
-            {
-                IEnumerator<T1> e1 = null;
-                IEnumerator<T2> e2 = null;
-                IEnumerator<T3> e3 = null;
-                IEnumerator<T4> e4 = null;
-                IEnumerator<T5> e5 = null;
-                IEnumerator<T6> e6 = null;
-
-                try
-                {
-                    e1 = first.GetEnumerator();
-                    e2 = second.GetEnumerator();
-                    e3 = third.GetEnumerator();
-                    e4 = fourth.GetEnumerator();
-                    e5 = fifth.GetEnumerator();
-                    e6 = sixth.GetEnumerator();
-
-                    var v1 = default(T1);
-                    var v2 = default(T2);
-                    var v3 = default(T3);
-                    var v4 = default(T4);
-                    var v5 = default(T5);
-                    var v6 = default(T6);
-
-                    while (
-                        ZipHelper.MoveNextOrDefault<T1>(ref e1, ref v1) |
-                        ZipHelper.MoveNextOrDefault<T2>(ref e2, ref v2) |
-                        ZipHelper.MoveNextOrDefault<T3>(ref e3, ref v3) |
-                        ZipHelper.MoveNextOrDefault<T4>(ref e4, ref v4) |
-                        ZipHelper.MoveNextOrDefault<T5>(ref e5, ref v5) |
-                        ZipHelper.MoveNextOrDefault<T6>(ref e6, ref v6))
-                    {
-                        yield return resultSelector(v1, v2, v3, v4, v5, v6);
-                    }
-                }
-                finally
-                {
-                    e1?.Dispose();
-                    e2?.Dispose();
-                    e3?.Dispose();
-                    e4?.Dispose();
-                    e5?.Dispose();
-                    e6?.Dispose();
-                }
-            }
-        }
-
-        /// <summary>
-        /// Returns a sequence of tuples, where each tuple contains the N-th
-        /// element from each of the input 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 input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
-        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
-        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <param name="third">The third source sequence.</param>
-        /// <param name="fourth">The fourth source sequence.</param>
-        /// <param name="fifth">The fifth source sequence.</param>
-        /// <param name="sixth">The sixth source sequence.</param>
-        /// <returns>
-        /// A sequence of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <remarks>
-        /// This operator uses deferred execution and streams its results.
-        /// </remarks>
-        public static IEnumerable<(T1, T2, T3, T4, T5, T6)> ZipLongest<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 ZipLongest(
-                first,
-                second,
-                third,
-                fourth,
-                fifth,
-                sixth,
-                ValueTuple.Create);
-        }
-
-        /// <summary>
-        /// Returns a projection of tuples, where each tuple contains the N-th
-        /// element from each of the input sequences. The resulting sequence
-        /// is as short as the shortest input sequence.
-        /// </summary>
-        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
-        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
-        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
-        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <param name="third">The third source sequence.</param>
-        /// <param name="fourth">The fourth source sequence.</param>
-        /// <param name="fifth">The fifth source sequence.</param>
-        /// <param name="sixth">The sixth source sequence.</param>
-        /// <param name="resultSelector">
-        /// Function to apply to each tuple of elements.</param>
-        /// <returns>
-        /// A projection of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <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<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, TResult>(
-            this IEnumerable<T1> first,
-            IEnumerable<T2> second,
-            IEnumerable<T3> third,
-            IEnumerable<T4> fourth,
-            IEnumerable<T5> fifth,
-            IEnumerable<T6> sixth,
-            Func<T1, T2, T3, T4, T5, T6, TResult> resultSelector)
-        {
-            if (first == null) throw new ArgumentNullException(nameof(first));
-            if (second == null) throw new ArgumentNullException(nameof(second));
-            if (third == null) throw new ArgumentNullException(nameof(third));
-            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
-            if (fifth == null) throw new ArgumentNullException(nameof(fifth));
-            if (sixth == null) throw new ArgumentNullException(nameof(sixth));
-            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
-
-            return _(); IEnumerable<TResult> _()
-            {
-                using var e1 = first.GetEnumerator();
-                using var e2 = second.GetEnumerator();
-                using var e3 = third.GetEnumerator();
-                using var e4 = fourth.GetEnumerator();
-                using var e5 = fifth.GetEnumerator();
-                using var e6 = sixth.GetEnumerator();
-
-                while (e1.MoveNext() && e2.MoveNext() && e3.MoveNext() && e4.MoveNext() && e5.MoveNext() && e6.MoveNext())
-                {
-                    yield return resultSelector(e1.Current, e2.Current, e3.Current, e4.Current, e5.Current, e6.Current);
-                }
-            }
-        }
-
-        /// <summary>
-        /// Returns a sequence of tuples, where each tuple contains the N-th
-        /// element from each of the input sequences. The resulting sequence
-        /// is as short as the shortest input sequence.
-        /// </summary>
-        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
-        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
-        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <param name="third">The third source sequence.</param>
-        /// <param name="fourth">The fourth source sequence.</param>
-        /// <param name="fifth">The fifth source sequence.</param>
-        /// <param name="sixth">The sixth source sequence.</param>
-        /// <returns>
-        /// A sequence of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <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, T5, T6)> ZipShortest<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 ZipShortest(
-                first,
-                second,
-                third,
-                fourth,
-                fifth,
-                sixth,
-                ValueTuple.Create);
-        }
-
-        /// <summary>
-        /// Returns a projection of tuples, where each tuple contains the N-th
-        /// element from each of the input sequences. An exception is thrown
-        /// if the input sequences are of different lengths.
-        /// </summary>
-        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
-        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
-        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
-        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
-        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <param name="third">The third source sequence.</param>
-        /// <param name="fourth">The fourth source sequence.</param>
-        /// <param name="fifth">The fifth source sequence.</param>
-        /// <param name="sixth">The sixth source sequence.</param>
-        /// <param name="seventh">The seventh source sequence.</param>
-        /// <param name="resultSelector">
-        /// Function to apply to each tuple of elements.</param>
-        /// <returns>
-        /// A projection of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <exception cref="InvalidOperationException">
-        /// The input sequences are of different lengths.
-        /// </exception>
-        /// <remarks>
-        /// This operator uses deferred execution and streams its results.
-        /// </remarks>
-
-        public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, T7, TResult>(
-            this IEnumerable<T1> first,
-            IEnumerable<T2> second,
-            IEnumerable<T3> third,
-            IEnumerable<T4> fourth,
-            IEnumerable<T5> fifth,
-            IEnumerable<T6> sixth,
-            IEnumerable<T7> seventh,
-            Func<T1, T2, T3, T4, T5, T6, T7, TResult> resultSelector)
-        {
-            if (first == null) throw new ArgumentNullException(nameof(first));
-            if (second == null) throw new ArgumentNullException(nameof(second));
-            if (third == null) throw new ArgumentNullException(nameof(third));
-            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
-            if (fifth == null) throw new ArgumentNullException(nameof(fifth));
-            if (sixth == null) throw new ArgumentNullException(nameof(sixth));
-            if (seventh == null) throw new ArgumentNullException(nameof(seventh));
-            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
-
-            return _(); IEnumerable<TResult> _()
-            {
-                using var e1 = first.GetEnumerator();
-                using var e2 = second.GetEnumerator();
-                using var e3 = third.GetEnumerator();
-                using var e4 = fourth.GetEnumerator();
-                using var e5 = fifth.GetEnumerator();
-                using var e6 = sixth.GetEnumerator();
-                using var e7 = seventh.GetEnumerator();
-
-                for (;;)
-                {
-                    if (e1.MoveNext())
-                    {
-                        if (e2.MoveNext() && e3.MoveNext() && e4.MoveNext() && e5.MoveNext() && e6.MoveNext() && e7.MoveNext())
-                            yield return resultSelector(e1.Current, e2.Current, e3.Current, e4.Current, e5.Current, e6.Current, e7.Current);
-                        else
-                            break;
-                    }
-                    else
-                    {
-                        if (e2.MoveNext() || e3.MoveNext() || e4.MoveNext() || e5.MoveNext() || e6.MoveNext() || e7.MoveNext())
-                            break;
-                        else
-                            yield break;
-                    }
-                }
-
-                throw new InvalidOperationException($"Sequences differ in length.");
-            }
-        }
-
-        /// <summary>
-        /// Returns a sequence of tuples, where each tuple contains the N-th
-        /// element from each of the input sequences. An exception is thrown
-        /// if the input sequences are of different lengths.
-        /// </summary>
-        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
-        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
-        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
-        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <param name="third">The third source sequence.</param>
-        /// <param name="fourth">The fourth source sequence.</param>
-        /// <param name="fifth">The fifth source sequence.</param>
-        /// <param name="sixth">The sixth source sequence.</param>
-        /// <param name="seventh">The seventh source sequence.</param>
-        /// <returns>
-        /// A sequence of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <exception cref="InvalidOperationException">
-        /// The input sequences are of different lengths.
-        /// </exception>
-        /// <remarks>
-        /// This operator uses deferred execution and streams its results.
-        /// </remarks>
-        public static IEnumerable<(T1, T2, T3, T4, T5, T6, T7)> EquiZip<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 EquiZip(
-                first,
-                second,
-                third,
-                fourth,
-                fifth,
-                sixth,
-                seventh,
-                ValueTuple.Create);
-        }
-
-        /// <summary>
-        /// Returns a projection of tuples, where each tuple contains the N-th
-        /// element from each of the input 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 input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
-        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
-        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
-        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
-        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <param name="third">The third source sequence.</param>
-        /// <param name="fourth">The fourth source sequence.</param>
-        /// <param name="fifth">The fifth source sequence.</param>
-        /// <param name="sixth">The sixth source sequence.</param>
-        /// <param name="seventh">The seventh source sequence.</param>
-        /// <param name="resultSelector">
-        /// Function to apply to each tuple of elements.</param>
-        /// <returns>
-        /// A projection of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <remarks>
-        /// This operator uses deferred execution and streams its results.
-        /// </remarks>
-        public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, T7, TResult>(
-            this IEnumerable<T1> first,
-            IEnumerable<T2> second,
-            IEnumerable<T3> third,
-            IEnumerable<T4> fourth,
-            IEnumerable<T5> fifth,
-            IEnumerable<T6> sixth,
-            IEnumerable<T7> seventh,
-            Func<T1, T2, T3, T4, T5, T6, T7, TResult> resultSelector)
-        {
-            if (first == null) throw new ArgumentNullException(nameof(first));
-            if (second == null) throw new ArgumentNullException(nameof(second));
-            if (third == null) throw new ArgumentNullException(nameof(third));
-            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
-            if (fifth == null) throw new ArgumentNullException(nameof(fifth));
-            if (sixth == null) throw new ArgumentNullException(nameof(sixth));
-            if (seventh == null) throw new ArgumentNullException(nameof(seventh));
-            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
-
-            return _(); IEnumerable<TResult> _()
-            {
-                IEnumerator<T1> e1 = null;
-                IEnumerator<T2> e2 = null;
-                IEnumerator<T3> e3 = null;
-                IEnumerator<T4> e4 = null;
-                IEnumerator<T5> e5 = null;
-                IEnumerator<T6> e6 = null;
-                IEnumerator<T7> e7 = null;
-
-                try
-                {
-                    e1 = first.GetEnumerator();
-                    e2 = second.GetEnumerator();
-                    e3 = third.GetEnumerator();
-                    e4 = fourth.GetEnumerator();
-                    e5 = fifth.GetEnumerator();
-                    e6 = sixth.GetEnumerator();
-                    e7 = seventh.GetEnumerator();
-
-                    var v1 = default(T1);
-                    var v2 = default(T2);
-                    var v3 = default(T3);
-                    var v4 = default(T4);
-                    var v5 = default(T5);
-                    var v6 = default(T6);
-                    var v7 = default(T7);
-
-                    while (
-                        ZipHelper.MoveNextOrDefault<T1>(ref e1, ref v1) |
-                        ZipHelper.MoveNextOrDefault<T2>(ref e2, ref v2) |
-                        ZipHelper.MoveNextOrDefault<T3>(ref e3, ref v3) |
-                        ZipHelper.MoveNextOrDefault<T4>(ref e4, ref v4) |
-                        ZipHelper.MoveNextOrDefault<T5>(ref e5, ref v5) |
-                        ZipHelper.MoveNextOrDefault<T6>(ref e6, ref v6) |
-                        ZipHelper.MoveNextOrDefault<T7>(ref e7, ref v7))
-                    {
-                        yield return resultSelector(v1, v2, v3, v4, v5, v6, v7);
-                    }
-                }
-                finally
-                {
-                    e1?.Dispose();
-                    e2?.Dispose();
-                    e3?.Dispose();
-                    e4?.Dispose();
-                    e5?.Dispose();
-                    e6?.Dispose();
-                    e7?.Dispose();
-                }
-            }
-        }
-
-        /// <summary>
-        /// Returns a sequence of tuples, where each tuple contains the N-th
-        /// element from each of the input 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 input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
-        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
-        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
-        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <param name="third">The third source sequence.</param>
-        /// <param name="fourth">The fourth source sequence.</param>
-        /// <param name="fifth">The fifth source sequence.</param>
-        /// <param name="sixth">The sixth source sequence.</param>
-        /// <param name="seventh">The seventh source sequence.</param>
-        /// <returns>
-        /// A sequence of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <remarks>
-        /// This operator uses deferred execution and streams its results.
-        /// </remarks>
-        public static IEnumerable<(T1, T2, T3, T4, T5, T6, T7)> ZipLongest<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 ZipLongest(
-                first,
-                second,
-                third,
-                fourth,
-                fifth,
-                sixth,
-                seventh,
-                ValueTuple.Create);
-        }
-
-        /// <summary>
-        /// Returns a projection of tuples, where each tuple contains the N-th
-        /// element from each of the input sequences. The resulting sequence
-        /// is as short as the shortest input sequence.
-        /// </summary>
-        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
-        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
-        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
-        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
-        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <param name="third">The third source sequence.</param>
-        /// <param name="fourth">The fourth source sequence.</param>
-        /// <param name="fifth">The fifth source sequence.</param>
-        /// <param name="sixth">The sixth source sequence.</param>
-        /// <param name="seventh">The seventh source sequence.</param>
-        /// <param name="resultSelector">
-        /// Function to apply to each tuple of elements.</param>
-        /// <returns>
-        /// A projection of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <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<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, T7, TResult>(
-            this IEnumerable<T1> first,
-            IEnumerable<T2> second,
-            IEnumerable<T3> third,
-            IEnumerable<T4> fourth,
-            IEnumerable<T5> fifth,
-            IEnumerable<T6> sixth,
-            IEnumerable<T7> seventh,
-            Func<T1, T2, T3, T4, T5, T6, T7, TResult> resultSelector)
-        {
-            if (first == null) throw new ArgumentNullException(nameof(first));
-            if (second == null) throw new ArgumentNullException(nameof(second));
-            if (third == null) throw new ArgumentNullException(nameof(third));
-            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
-            if (fifth == null) throw new ArgumentNullException(nameof(fifth));
-            if (sixth == null) throw new ArgumentNullException(nameof(sixth));
-            if (seventh == null) throw new ArgumentNullException(nameof(seventh));
-            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
-
-            return _(); IEnumerable<TResult> _()
-            {
-                using var e1 = first.GetEnumerator();
-                using var e2 = second.GetEnumerator();
-                using var e3 = third.GetEnumerator();
-                using var e4 = fourth.GetEnumerator();
-                using var e5 = fifth.GetEnumerator();
-                using var e6 = sixth.GetEnumerator();
-                using var e7 = seventh.GetEnumerator();
-
-                while (e1.MoveNext() && e2.MoveNext() && e3.MoveNext() && e4.MoveNext() && e5.MoveNext() && e6.MoveNext() && e7.MoveNext())
-                {
-                    yield return resultSelector(e1.Current, e2.Current, e3.Current, e4.Current, e5.Current, e6.Current, e7.Current);
-                }
-            }
-        }
-
-        /// <summary>
-        /// Returns a sequence of tuples, where each tuple contains the N-th
-        /// element from each of the input sequences. The resulting sequence
-        /// is as short as the shortest input sequence.
-        /// </summary>
-        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
-        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
-        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
-        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <param name="third">The third source sequence.</param>
-        /// <param name="fourth">The fourth source sequence.</param>
-        /// <param name="fifth">The fifth source sequence.</param>
-        /// <param name="sixth">The sixth source sequence.</param>
-        /// <param name="seventh">The seventh source sequence.</param>
-        /// <returns>
-        /// A sequence of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <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, T5, T6, T7)> ZipShortest<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 ZipShortest(
-                first,
-                second,
-                third,
-                fourth,
-                fifth,
-                sixth,
-                seventh,
-                ValueTuple.Create);
-        }
-
-        /// <summary>
-        /// Returns a projection of tuples, where each tuple contains the N-th
-        /// element from each of the input sequences. An exception is thrown
-        /// if the input sequences are of different lengths.
-        /// </summary>
-        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
-        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
-        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
-        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
-        /// <typeparam name="T8">Type of elements in eighth input sequence.</typeparam>
-        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <param name="third">The third source sequence.</param>
-        /// <param name="fourth">The fourth source sequence.</param>
-        /// <param name="fifth">The fifth source sequence.</param>
-        /// <param name="sixth">The sixth source sequence.</param>
-        /// <param name="seventh">The seventh source sequence.</param>
-        /// <param name="eighth">The eighth source sequence.</param>
-        /// <param name="resultSelector">
-        /// Function to apply to each tuple of elements.</param>
-        /// <returns>
-        /// A projection of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <exception cref="InvalidOperationException">
-        /// The input sequences are of different lengths.
-        /// </exception>
-        /// <remarks>
-        /// This operator uses deferred execution and streams its results.
-        /// </remarks>
-
-        public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(
-            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,
-            Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> resultSelector)
-        {
-            if (first == null) throw new ArgumentNullException(nameof(first));
-            if (second == null) throw new ArgumentNullException(nameof(second));
-            if (third == null) throw new ArgumentNullException(nameof(third));
-            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
-            if (fifth == null) throw new ArgumentNullException(nameof(fifth));
-            if (sixth == null) throw new ArgumentNullException(nameof(sixth));
-            if (seventh == null) throw new ArgumentNullException(nameof(seventh));
-            if (eighth == null) throw new ArgumentNullException(nameof(eighth));
-            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
-
-            return _(); IEnumerable<TResult> _()
-            {
-                using var e1 = first.GetEnumerator();
-                using var e2 = second.GetEnumerator();
-                using var e3 = third.GetEnumerator();
-                using var e4 = fourth.GetEnumerator();
-                using var e5 = fifth.GetEnumerator();
-                using var e6 = sixth.GetEnumerator();
-                using var e7 = seventh.GetEnumerator();
-                using var e8 = eighth.GetEnumerator();
-
-                for (;;)
-                {
-                    if (e1.MoveNext())
-                    {
-                        if (e2.MoveNext() && e3.MoveNext() && e4.MoveNext() && e5.MoveNext() && e6.MoveNext() && e7.MoveNext() && e8.MoveNext())
-                            yield return resultSelector(e1.Current, e2.Current, e3.Current, e4.Current, e5.Current, e6.Current, e7.Current, e8.Current);
-                        else
-                            break;
-                    }
-                    else
-                    {
-                        if (e2.MoveNext() || e3.MoveNext() || e4.MoveNext() || e5.MoveNext() || e6.MoveNext() || e7.MoveNext() || e8.MoveNext())
-                            break;
-                        else
-                            yield break;
-                    }
-                }
-
-                throw new InvalidOperationException($"Sequences differ in length.");
-            }
-        }
-
-        /// <summary>
-        /// Returns a sequence of tuples, where each tuple contains the N-th
-        /// element from each of the input sequences. An exception is thrown
-        /// if the input sequences are of different lengths.
-        /// </summary>
-        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
-        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
-        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
-        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
-        /// <typeparam name="T8">Type of elements in eighth input sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <param name="third">The third source sequence.</param>
-        /// <param name="fourth">The fourth source sequence.</param>
-        /// <param name="fifth">The fifth source sequence.</param>
-        /// <param name="sixth">The sixth source sequence.</param>
-        /// <param name="seventh">The seventh source sequence.</param>
-        /// <param name="eighth">The eighth source sequence.</param>
-        /// <returns>
-        /// A sequence of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <exception cref="InvalidOperationException">
-        /// The input sequences are of different lengths.
-        /// </exception>
-        /// <remarks>
-        /// This operator uses deferred execution and streams its results.
-        /// </remarks>
-        public static IEnumerable<(T1, T2, T3, T4, T5, T6, T7, T8)> EquiZip<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 EquiZip(
-                first,
-                second,
-                third,
-                fourth,
-                fifth,
-                sixth,
-                seventh,
-                eighth,
-                ValueTuple.Create);
-        }
-
-        /// <summary>
-        /// Returns a projection of tuples, where each tuple contains the N-th
-        /// element from each of the input 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 input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
-        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
-        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
-        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
-        /// <typeparam name="T8">Type of elements in eighth input sequence.</typeparam>
-        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <param name="third">The third source sequence.</param>
-        /// <param name="fourth">The fourth source sequence.</param>
-        /// <param name="fifth">The fifth source sequence.</param>
-        /// <param name="sixth">The sixth source sequence.</param>
-        /// <param name="seventh">The seventh source sequence.</param>
-        /// <param name="eighth">The eighth source sequence.</param>
-        /// <param name="resultSelector">
-        /// Function to apply to each tuple of elements.</param>
-        /// <returns>
-        /// A projection of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <remarks>
-        /// This operator uses deferred execution and streams its results.
-        /// </remarks>
-        public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(
-            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,
-            Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> resultSelector)
-        {
-            if (first == null) throw new ArgumentNullException(nameof(first));
-            if (second == null) throw new ArgumentNullException(nameof(second));
-            if (third == null) throw new ArgumentNullException(nameof(third));
-            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
-            if (fifth == null) throw new ArgumentNullException(nameof(fifth));
-            if (sixth == null) throw new ArgumentNullException(nameof(sixth));
-            if (seventh == null) throw new ArgumentNullException(nameof(seventh));
-            if (eighth == null) throw new ArgumentNullException(nameof(eighth));
-            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
-
-            return _(); IEnumerable<TResult> _()
-            {
-                IEnumerator<T1> e1 = null;
-                IEnumerator<T2> e2 = null;
-                IEnumerator<T3> e3 = null;
-                IEnumerator<T4> e4 = null;
-                IEnumerator<T5> e5 = null;
-                IEnumerator<T6> e6 = null;
-                IEnumerator<T7> e7 = null;
-                IEnumerator<T8> e8 = null;
-
-                try
-                {
-                    e1 = first.GetEnumerator();
-                    e2 = second.GetEnumerator();
-                    e3 = third.GetEnumerator();
-                    e4 = fourth.GetEnumerator();
-                    e5 = fifth.GetEnumerator();
-                    e6 = sixth.GetEnumerator();
-                    e7 = seventh.GetEnumerator();
-                    e8 = eighth.GetEnumerator();
-
-                    var v1 = default(T1);
-                    var v2 = default(T2);
-                    var v3 = default(T3);
-                    var v4 = default(T4);
-                    var v5 = default(T5);
-                    var v6 = default(T6);
-                    var v7 = default(T7);
-                    var v8 = default(T8);
-
-                    while (
-                        ZipHelper.MoveNextOrDefault<T1>(ref e1, ref v1) |
-                        ZipHelper.MoveNextOrDefault<T2>(ref e2, ref v2) |
-                        ZipHelper.MoveNextOrDefault<T3>(ref e3, ref v3) |
-                        ZipHelper.MoveNextOrDefault<T4>(ref e4, ref v4) |
-                        ZipHelper.MoveNextOrDefault<T5>(ref e5, ref v5) |
-                        ZipHelper.MoveNextOrDefault<T6>(ref e6, ref v6) |
-                        ZipHelper.MoveNextOrDefault<T7>(ref e7, ref v7) |
-                        ZipHelper.MoveNextOrDefault<T8>(ref e8, ref v8))
-                    {
-                        yield return resultSelector(v1, v2, v3, v4, v5, v6, v7, v8);
-                    }
-                }
-                finally
-                {
-                    e1?.Dispose();
-                    e2?.Dispose();
-                    e3?.Dispose();
-                    e4?.Dispose();
-                    e5?.Dispose();
-                    e6?.Dispose();
-                    e7?.Dispose();
-                    e8?.Dispose();
-                }
-            }
-        }
-
-        /// <summary>
-        /// Returns a sequence of tuples, where each tuple contains the N-th
-        /// element from each of the input 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 input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
-        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
-        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
-        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
-        /// <typeparam name="T8">Type of elements in eighth input sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <param name="third">The third source sequence.</param>
-        /// <param name="fourth">The fourth source sequence.</param>
-        /// <param name="fifth">The fifth source sequence.</param>
-        /// <param name="sixth">The sixth source sequence.</param>
-        /// <param name="seventh">The seventh source sequence.</param>
-        /// <param name="eighth">The eighth source sequence.</param>
-        /// <returns>
-        /// A sequence of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <remarks>
-        /// This operator uses deferred execution and streams its results.
-        /// </remarks>
-        public static IEnumerable<(T1, T2, T3, T4, T5, T6, T7, T8)> ZipLongest<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 ZipLongest(
-                first,
-                second,
-                third,
-                fourth,
-                fifth,
-                sixth,
-                seventh,
-                eighth,
-                ValueTuple.Create);
-        }
-
-        /// <summary>
-        /// Returns a projection of tuples, where each tuple contains the N-th
-        /// element from each of the input sequences. The resulting sequence
-        /// is as short as the shortest input sequence.
-        /// </summary>
-        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
-        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
-        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
-        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
-        /// <typeparam name="T8">Type of elements in eighth input sequence.</typeparam>
-        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <param name="third">The third source sequence.</param>
-        /// <param name="fourth">The fourth source sequence.</param>
-        /// <param name="fifth">The fifth source sequence.</param>
-        /// <param name="sixth">The sixth source sequence.</param>
-        /// <param name="seventh">The seventh source sequence.</param>
-        /// <param name="eighth">The eighth source sequence.</param>
-        /// <param name="resultSelector">
-        /// Function to apply to each tuple of elements.</param>
-        /// <returns>
-        /// A projection of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <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<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(
-            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,
-            Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> resultSelector)
-        {
-            if (first == null) throw new ArgumentNullException(nameof(first));
-            if (second == null) throw new ArgumentNullException(nameof(second));
-            if (third == null) throw new ArgumentNullException(nameof(third));
-            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
-            if (fifth == null) throw new ArgumentNullException(nameof(fifth));
-            if (sixth == null) throw new ArgumentNullException(nameof(sixth));
-            if (seventh == null) throw new ArgumentNullException(nameof(seventh));
-            if (eighth == null) throw new ArgumentNullException(nameof(eighth));
-            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
-
-            return _(); IEnumerable<TResult> _()
-            {
-                using var e1 = first.GetEnumerator();
-                using var e2 = second.GetEnumerator();
-                using var e3 = third.GetEnumerator();
-                using var e4 = fourth.GetEnumerator();
-                using var e5 = fifth.GetEnumerator();
-                using var e6 = sixth.GetEnumerator();
-                using var e7 = seventh.GetEnumerator();
-                using var e8 = eighth.GetEnumerator();
-
-                while (e1.MoveNext() && e2.MoveNext() && e3.MoveNext() && e4.MoveNext() && e5.MoveNext() && e6.MoveNext() && e7.MoveNext() && e8.MoveNext())
-                {
-                    yield return resultSelector(e1.Current, e2.Current, e3.Current, e4.Current, e5.Current, e6.Current, e7.Current, e8.Current);
-                }
-            }
-        }
-
-        /// <summary>
-        /// Returns a sequence of tuples, where each tuple contains the N-th
-        /// element from each of the input sequences. The resulting sequence
-        /// is as short as the shortest input sequence.
-        /// </summary>
-        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
-        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
-        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
-        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
-        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
-        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
-        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
-        /// <typeparam name="T8">Type of elements in eighth input sequence.</typeparam>
-        /// <param name="first">The first source sequence.</param>
-        /// <param name="second">The second source sequence.</param>
-        /// <param name="third">The third source sequence.</param>
-        /// <param name="fourth">The fourth source sequence.</param>
-        /// <param name="fifth">The fifth source sequence.</param>
-        /// <param name="sixth">The sixth source sequence.</param>
-        /// <param name="seventh">The seventh source sequence.</param>
-        /// <param name="eighth">The eighth source sequence.</param>
-        /// <returns>
-        /// A sequence of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <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, T5, T6, T7, T8)> ZipShortest<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 ZipShortest(
-                first,
-                second,
-                third,
-                fourth,
-                fifth,
-                sixth,
-                seventh,
-                eighth,
-                ValueTuple.Create);
-        }
-
-    }
-}
diff --git a/MoreLinq/Zip.g.tt b/MoreLinq/Zip.g.tt
deleted file mode 100644
index acf41571f..000000000
--- a/MoreLinq/Zip.g.tt
+++ /dev/null
@@ -1,346 +0,0 @@
-<#@ template debug="false" hostspecific="false" language="C#" #>
-<#@ output extension=".cs" #>
-<#@ assembly name="System.Core" #>
-<#@ assembly name="System.Collections" #>
-<#@ import namespace="System.Globalization" #>
-<#@ import namespace="System.Linq" #>
-#region License and Terms
-// MoreLINQ - Extensions to LINQ to Objects
-// Copyright (c) 2019 Pierre Lando. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-#endregion
-
-<#
-    var ordinals = new[]
-    {
-        "",
-        "first", "second", "third", "fourth",
-        "fifth", "sixth", "seventh", "eighth"
-    };
-
-    var overloads =
-        Enumerable.Range(2, 7)
-            .Select(argCount =>
-                Enumerable.Range(1, argCount).Select(argPosition =>
-                    new
-                    {
-                        IsFirst = argPosition == 1,
-                        IsLast = argPosition == argCount,
-                        Name = ordinals[argPosition],
-                        Ordinal = ordinals[argPosition],
-                        Type = $"T{argPosition}",
-                        // Objects associated with the argument
-                        Enumerator = $"e{argPosition}",
-                        Value = $"v{argPosition}"
-                    }))
-            .Select(args => args.ToList())
-            .Select(args =>
-                new
-                {
-                    Arguments = args,
-                    TParams = string.Join(", ", args.Select(arg => arg.Type))
-                });
-#>
-namespace MoreLinq
-{
-    using System;
-    using System.Collections.Generic;
-
-    static partial class MoreEnumerable
-    {
-<#  foreach (var o in overloads)
-    {
-#>
-        /// <summary>
-        /// Returns a projection of tuples, where each tuple contains the N-th
-        /// element from each of the input sequences. An exception is thrown
-        /// if the input sequences are of different lengths.
-        /// </summary>
-<# foreach (var arg in o.Arguments) { #>
-        /// <typeparam name="<#=arg.Type#>">Type of elements in <#=arg.Name#> input sequence.</typeparam>
-<#} #>
-        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-<# foreach (var arg in o.Arguments) { #>
-        /// <param name="<#=arg.Name#>">The <#=arg.Ordinal#> source sequence.</param>
-<#} #>
-        /// <param name="resultSelector">
-        /// Function to apply to each tuple of elements.</param>
-        /// <returns>
-        /// A projection of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <exception cref="InvalidOperationException">
-        /// The input sequences are of different lengths.
-        /// </exception>
-        /// <remarks>
-        /// This operator uses deferred execution and streams its results.
-        /// </remarks>
-
-        public static IEnumerable<TResult> EquiZip<<#=o.TParams#>, TResult>(
-<# foreach (var arg in o.Arguments) { #>
-            <#= arg.IsFirst ? "this " : "" #>IEnumerable<<#=arg.Type#>> <#=arg.Name#>,
-<#} #>
-            Func<<#=o.TParams#>, TResult> resultSelector)
-        {
-<# foreach (var arg in o.Arguments) { #>
-            if (<#=arg.Name#> == null) throw new ArgumentNullException(nameof(<#=arg.Name#>));
-<#} #>
-            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
-
-            return _(); IEnumerable<TResult> _()
-            {
-<# foreach (var arg in o.Arguments) { #>
-                using var <#=arg.Enumerator#> = <#=arg.Name#>.GetEnumerator();
-<#} #>
-
-                for (;;)
-                {
-                    if (<#=o.Arguments.First().Enumerator#>.MoveNext())
-                    {
-                        if (<# foreach (var arg in o.Arguments.Skip(1)) { #><#=arg.Enumerator#>.MoveNext()<#= arg.IsLast ? "" : " && " #><#}#>)
-                            yield return resultSelector(<# foreach (var arg in o.Arguments) { #><#=arg.Enumerator#>.Current<#= arg.IsLast ? "" : ", " #><#}#>);
-                        else
-                            break;
-                    }
-                    else
-                    {
-                        if (<# foreach (var arg in o.Arguments.Skip(1)) { #><#=arg.Enumerator#>.MoveNext()<#= arg.IsLast ? "" : " || " #><#}#>)
-                            break;
-                        else
-                            yield break;
-                    }
-                }
-
-                throw new InvalidOperationException($"Sequences differ in length.");
-            }
-        }
-
-        /// <summary>
-        /// Returns a sequence of tuples, where each tuple contains the N-th
-        /// element from each of the input sequences. An exception is thrown
-        /// if the input sequences are of different lengths.
-        /// </summary>
-<# foreach (var arg in o.Arguments) { #>
-        /// <typeparam name="<#=arg.Type#>">Type of elements in <#=arg.Name#> input sequence.</typeparam>
-<#} #>
-<# foreach (var arg in o.Arguments) { #>
-        /// <param name="<#=arg.Name#>">The <#=arg.Ordinal#> source sequence.</param>
-<#} #>
-        /// <returns>
-        /// A sequence of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <exception cref="InvalidOperationException">
-        /// The input sequences are of different lengths.
-        /// </exception>
-        /// <remarks>
-        /// This operator uses deferred execution and streams its results.
-        /// </remarks>
-        public static IEnumerable<(<#=o.TParams#>)> EquiZip<<#=o.TParams#>>(
-<# foreach (var arg in o.Arguments) { #>
-            <#= arg.IsFirst ? "this " : "" #>IEnumerable<<#=arg.Type#>> <#=arg.Name#><#= arg.IsLast ? ")" : "," #>
-<#}#>
-        {
-            return EquiZip(
-<# foreach (var arg in o.Arguments) { #>
-                <#=arg.Name#>,
-<#}#>
-                ValueTuple.Create);
-        }
-
-        /// <summary>
-        /// Returns a projection of tuples, where each tuple contains the N-th
-        /// element from each of the input 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>
-<# foreach (var arg in o.Arguments) { #>
-        /// <typeparam name="<#=arg.Type#>">Type of elements in <#=arg.Name#> input sequence.</typeparam>
-<#} #>
-        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-<# foreach (var arg in o.Arguments) { #>
-        /// <param name="<#=arg.Name#>">The <#=arg.Ordinal#> source sequence.</param>
-<#} #>
-        /// <param name="resultSelector">
-        /// Function to apply to each tuple of elements.</param>
-        /// <returns>
-        /// A projection of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <remarks>
-        /// This operator uses deferred execution and streams its results.
-        /// </remarks>
-        public static IEnumerable<TResult> ZipLongest<<#=o.TParams#>, TResult>(
-<# foreach (var arg in o.Arguments) { #>
-            <#= arg.IsFirst ? "this " : "" #>IEnumerable<<#=arg.Type#>> <#=arg.Name#>,
-<#}#>
-            Func<<#=o.TParams#>, TResult> resultSelector)
-        {
-<# foreach (var arg in o.Arguments) { #>
-            if (<#=arg.Name#> == null) throw new ArgumentNullException(nameof(<#=arg.Name#>));
-<#} #>
-            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
-
-            return _(); IEnumerable<TResult> _()
-            {
-<# foreach (var arg in o.Arguments) { #>
-                IEnumerator<<#=arg.Type#>> <#=arg.Enumerator#> = null;
-<#} #>
-
-                try
-                {
-<# foreach (var arg in o.Arguments) { #>
-                    <#=arg.Enumerator#> = <#=arg.Name#>.GetEnumerator();
-<#} #>
-
-<# foreach (var arg in o.Arguments) { #>
-                    var <#=arg.Value#> = default(<#=arg.Type#>);
-<#} #>
-
-                    while (
-<# foreach (var arg in o.Arguments) { #>
-                        ZipHelper.MoveNextOrDefault<<#=arg.Type#>>(ref <#=arg.Enumerator#>, ref <#=arg.Value#>)<#= arg.IsLast ? ")" : " |" #>
-<#}#>
-                    {
-                        yield return resultSelector(<# foreach (var arg in o.Arguments) { #><#=arg.Value#><#= arg.IsLast ? "" : ", " #><#}#>);
-                    }
-                }
-                finally
-                {
-<# foreach (var arg in o.Arguments) { #>
-                    <#=arg.Enumerator#>?.Dispose();
-<#} #>
-                }
-            }
-        }
-
-        /// <summary>
-        /// Returns a sequence of tuples, where each tuple contains the N-th
-        /// element from each of the input 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>
-<# foreach (var arg in o.Arguments) { #>
-        /// <typeparam name="<#=arg.Type#>">Type of elements in <#=arg.Name#> input sequence.</typeparam>
-<#} #>
-<# foreach (var arg in o.Arguments) { #>
-        /// <param name="<#=arg.Name#>">The <#=arg.Ordinal#> source sequence.</param>
-<#} #>
-        /// <returns>
-        /// A sequence of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <remarks>
-        /// This operator uses deferred execution and streams its results.
-        /// </remarks>
-        public static IEnumerable<(<#=o.TParams#>)> ZipLongest<<#=o.TParams#>>(
-<# foreach (var arg in o.Arguments) { #>
-            <#= arg.IsFirst ? "this " : "" #>IEnumerable<<#=arg.Type#>> <#=arg.Name#><#= arg.IsLast ? ")" : "," #>
-<#}#>
-        {
-            return ZipLongest(
-<# foreach (var arg in o.Arguments) { #>
-                <#=arg.Name#>,
-<#}#>
-                ValueTuple.Create);
-        }
-
-        /// <summary>
-        /// Returns a projection of tuples, where each tuple contains the N-th
-        /// element from each of the input sequences. The resulting sequence
-        /// is as short as the shortest input sequence.
-        /// </summary>
-<# foreach (var arg in o.Arguments) { #>
-        /// <typeparam name="<#=arg.Type#>">Type of elements in <#=arg.Name#> input sequence.</typeparam>
-<#} #>
-        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
-<# foreach (var arg in o.Arguments) { #>
-        /// <param name="<#=arg.Name#>">The <#=arg.Ordinal#> source sequence.</param>
-<#} #>
-        /// <param name="resultSelector">
-        /// Function to apply to each tuple of elements.</param>
-        /// <returns>
-        /// A projection of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <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<TResult> ZipShortest<<#=o.TParams#>, TResult>(
-<# foreach (var arg in o.Arguments) { #>
-            <#= arg.IsFirst ? "this " : "" #>IEnumerable<<#=arg.Type#>> <#=arg.Name#>,
-<#}#>
-            Func<<#=o.TParams#>, TResult> resultSelector)
-        {
-<# foreach (var arg in o.Arguments) { #>
-            if (<#=arg.Name#> == null) throw new ArgumentNullException(nameof(<#=arg.Name#>));
-<#} #>
-            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
-
-            return _(); IEnumerable<TResult> _()
-            {
-<# foreach (var arg in o.Arguments) { #>
-                using var <#=arg.Enumerator#> = <#=arg.Name#>.GetEnumerator();
-<#} #>
-
-                while (<# foreach (var arg in o.Arguments) { #><#=arg.Enumerator#>.MoveNext()<#= arg.IsLast ? "" : " && " #><#}#>)
-                {
-                    yield return resultSelector(<# foreach (var arg in o.Arguments) { #><#=arg.Enumerator#>.Current<#= arg.IsLast ? "" : ", " #><#}#>);
-                }
-            }
-        }
-
-        /// <summary>
-        /// Returns a sequence of tuples, where each tuple contains the N-th
-        /// element from each of the input sequences. The resulting sequence
-        /// is as short as the shortest input sequence.
-        /// </summary>
-<# foreach (var arg in o.Arguments) { #>
-        /// <typeparam name="<#=arg.Type#>">Type of elements in <#=arg.Name#> input sequence.</typeparam>
-<#} #>
-<# foreach (var arg in o.Arguments) { #>
-        /// <param name="<#=arg.Name#>">The <#=arg.Ordinal#> source sequence.</param>
-<#} #>
-        /// <returns>
-        /// A sequence of tuples, where each tuple contains the N-th element
-        /// from each of the argument sequences.</returns>
-        /// <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<(<#=o.TParams#>)> ZipShortest<<#=o.TParams#>>(
-<# foreach (var arg in o.Arguments) { #>
-            <#= arg.IsFirst ? "this " : "" #>IEnumerable<<#=arg.Type#>> <#=arg.Name#><#= arg.IsLast ? ")" : "," #>
-<#}#>
-        {
-            return ZipShortest(
-<# foreach (var arg in o.Arguments) { #>
-                <#=arg.Name#>,
-<#}#>
-                ValueTuple.Create);
-        }
-
-<#  } #>
-    }
-}
diff --git a/MoreLinq/ZipLongest.g.cs b/MoreLinq/ZipLongest.g.cs
new file mode 100644
index 000000000..d599fb105
--- /dev/null
+++ b/MoreLinq/ZipLongest.g.cs
@@ -0,0 +1,901 @@
+#region License and Terms
+// MoreLINQ - Extensions to LINQ to Objects
+// Copyright (c) 2019 Pierre Lando. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#endregion
+
+namespace MoreLinq
+{
+    using System;
+    using System.Collections.Generic;
+
+    static partial class MoreEnumerable
+    {
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input 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 input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+
+        public static IEnumerable<TResult> ZipLongest<T1, T2, TResult>(
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            Func<T1, T2, TResult> resultSelector)
+        {
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return _(); IEnumerable<TResult> _()
+            {
+                IEnumerator<T1> e1 = null;
+                IEnumerator<T2> e2 = null;
+
+                try
+                {
+                    e1 = first.GetEnumerator();
+                    e2 = second.GetEnumerator();
+
+                    var v1 = default(T1);
+                    var v2 = default(T2);
+
+                    while (
+                        ZipLongestHelper.MoveNextOrDefault<T1>(ref e1, ref v1) |
+                        ZipLongestHelper.MoveNextOrDefault<T2>(ref e2, ref v2))
+                    {
+                        yield return resultSelector(v1, v2);
+                    }
+                }
+                finally
+                {
+                    e1?.Dispose();
+                    e2?.Dispose();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input 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 input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+
+        public static IEnumerable<(T1, T2)> ZipLongest<T1, T2>(
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second)
+        {
+            return ZipLongest(
+                first,
+                second,
+                ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input 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 input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+
+        public static IEnumerable<TResult> ZipLongest<T1, T2, T3, TResult>(
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            Func<T1, T2, T3, TResult> resultSelector)
+        {
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
+            if (third == null) throw new ArgumentNullException(nameof(third));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return _(); IEnumerable<TResult> _()
+            {
+                IEnumerator<T1> e1 = null;
+                IEnumerator<T2> e2 = null;
+                IEnumerator<T3> e3 = null;
+
+                try
+                {
+                    e1 = first.GetEnumerator();
+                    e2 = second.GetEnumerator();
+                    e3 = third.GetEnumerator();
+
+                    var v1 = default(T1);
+                    var v2 = default(T2);
+                    var v3 = default(T3);
+
+                    while (
+                        ZipLongestHelper.MoveNextOrDefault<T1>(ref e1, ref v1) |
+                        ZipLongestHelper.MoveNextOrDefault<T2>(ref e2, ref v2) |
+                        ZipLongestHelper.MoveNextOrDefault<T3>(ref e3, ref v3))
+                    {
+                        yield return resultSelector(v1, v2, v3);
+                    }
+                }
+                finally
+                {
+                    e1?.Dispose();
+                    e2?.Dispose();
+                    e3?.Dispose();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input 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 input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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 ZipLongest(
+                first,
+                second,
+                third,
+                ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input 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 input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+
+        public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, TResult>(
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            Func<T1, T2, T3, T4, TResult> resultSelector)
+        {
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
+            if (third == null) throw new ArgumentNullException(nameof(third));
+            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return _(); IEnumerable<TResult> _()
+            {
+                IEnumerator<T1> e1 = null;
+                IEnumerator<T2> e2 = null;
+                IEnumerator<T3> e3 = null;
+                IEnumerator<T4> e4 = null;
+
+                try
+                {
+                    e1 = first.GetEnumerator();
+                    e2 = second.GetEnumerator();
+                    e3 = third.GetEnumerator();
+                    e4 = fourth.GetEnumerator();
+
+                    var v1 = default(T1);
+                    var v2 = default(T2);
+                    var v3 = default(T3);
+                    var v4 = default(T4);
+
+                    while (
+                        ZipLongestHelper.MoveNextOrDefault<T1>(ref e1, ref v1) |
+                        ZipLongestHelper.MoveNextOrDefault<T2>(ref e2, ref v2) |
+                        ZipLongestHelper.MoveNextOrDefault<T3>(ref e3, ref v3) |
+                        ZipLongestHelper.MoveNextOrDefault<T4>(ref e4, ref v4))
+                    {
+                        yield return resultSelector(v1, v2, v3, v4);
+                    }
+                }
+                finally
+                {
+                    e1?.Dispose();
+                    e2?.Dispose();
+                    e3?.Dispose();
+                    e4?.Dispose();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input 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 input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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 ZipLongest(
+                first,
+                second,
+                third,
+                fourth,
+                ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input 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 input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+
+        public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, TResult>(
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth,
+            Func<T1, T2, T3, T4, T5, TResult> resultSelector)
+        {
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
+            if (third == null) throw new ArgumentNullException(nameof(third));
+            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
+            if (fifth == null) throw new ArgumentNullException(nameof(fifth));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return _(); IEnumerable<TResult> _()
+            {
+                IEnumerator<T1> e1 = null;
+                IEnumerator<T2> e2 = null;
+                IEnumerator<T3> e3 = null;
+                IEnumerator<T4> e4 = null;
+                IEnumerator<T5> e5 = null;
+
+                try
+                {
+                    e1 = first.GetEnumerator();
+                    e2 = second.GetEnumerator();
+                    e3 = third.GetEnumerator();
+                    e4 = fourth.GetEnumerator();
+                    e5 = fifth.GetEnumerator();
+
+                    var v1 = default(T1);
+                    var v2 = default(T2);
+                    var v3 = default(T3);
+                    var v4 = default(T4);
+                    var v5 = default(T5);
+
+                    while (
+                        ZipLongestHelper.MoveNextOrDefault<T1>(ref e1, ref v1) |
+                        ZipLongestHelper.MoveNextOrDefault<T2>(ref e2, ref v2) |
+                        ZipLongestHelper.MoveNextOrDefault<T3>(ref e3, ref v3) |
+                        ZipLongestHelper.MoveNextOrDefault<T4>(ref e4, ref v4) |
+                        ZipLongestHelper.MoveNextOrDefault<T5>(ref e5, ref v5))
+                    {
+                        yield return resultSelector(v1, v2, v3, v4, v5);
+                    }
+                }
+                finally
+                {
+                    e1?.Dispose();
+                    e2?.Dispose();
+                    e3?.Dispose();
+                    e4?.Dispose();
+                    e5?.Dispose();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input 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 input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+
+        public static IEnumerable<(T1, T2, T3, T4, T5)> ZipLongest<T1, T2, T3, T4, T5>(
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth)
+        {
+            return ZipLongest(
+                first,
+                second,
+                third,
+                fourth,
+                fifth,
+                ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input 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 input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+
+        public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, TResult>(
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth,
+            IEnumerable<T6> sixth,
+            Func<T1, T2, T3, T4, T5, T6, TResult> resultSelector)
+        {
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
+            if (third == null) throw new ArgumentNullException(nameof(third));
+            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
+            if (fifth == null) throw new ArgumentNullException(nameof(fifth));
+            if (sixth == null) throw new ArgumentNullException(nameof(sixth));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return _(); IEnumerable<TResult> _()
+            {
+                IEnumerator<T1> e1 = null;
+                IEnumerator<T2> e2 = null;
+                IEnumerator<T3> e3 = null;
+                IEnumerator<T4> e4 = null;
+                IEnumerator<T5> e5 = null;
+                IEnumerator<T6> e6 = null;
+
+                try
+                {
+                    e1 = first.GetEnumerator();
+                    e2 = second.GetEnumerator();
+                    e3 = third.GetEnumerator();
+                    e4 = fourth.GetEnumerator();
+                    e5 = fifth.GetEnumerator();
+                    e6 = sixth.GetEnumerator();
+
+                    var v1 = default(T1);
+                    var v2 = default(T2);
+                    var v3 = default(T3);
+                    var v4 = default(T4);
+                    var v5 = default(T5);
+                    var v6 = default(T6);
+
+                    while (
+                        ZipLongestHelper.MoveNextOrDefault<T1>(ref e1, ref v1) |
+                        ZipLongestHelper.MoveNextOrDefault<T2>(ref e2, ref v2) |
+                        ZipLongestHelper.MoveNextOrDefault<T3>(ref e3, ref v3) |
+                        ZipLongestHelper.MoveNextOrDefault<T4>(ref e4, ref v4) |
+                        ZipLongestHelper.MoveNextOrDefault<T5>(ref e5, ref v5) |
+                        ZipLongestHelper.MoveNextOrDefault<T6>(ref e6, ref v6))
+                    {
+                        yield return resultSelector(v1, v2, v3, v4, v5, v6);
+                    }
+                }
+                finally
+                {
+                    e1?.Dispose();
+                    e2?.Dispose();
+                    e3?.Dispose();
+                    e4?.Dispose();
+                    e5?.Dispose();
+                    e6?.Dispose();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input 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 input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+
+        public static IEnumerable<(T1, T2, T3, T4, T5, T6)> ZipLongest<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 ZipLongest(
+                first,
+                second,
+                third,
+                fourth,
+                fifth,
+                sixth,
+                ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input 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 input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <param name="seventh">The seventh source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+
+        public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, T7, TResult>(
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth,
+            IEnumerable<T6> sixth,
+            IEnumerable<T7> seventh,
+            Func<T1, T2, T3, T4, T5, T6, T7, TResult> resultSelector)
+        {
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
+            if (third == null) throw new ArgumentNullException(nameof(third));
+            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
+            if (fifth == null) throw new ArgumentNullException(nameof(fifth));
+            if (sixth == null) throw new ArgumentNullException(nameof(sixth));
+            if (seventh == null) throw new ArgumentNullException(nameof(seventh));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return _(); IEnumerable<TResult> _()
+            {
+                IEnumerator<T1> e1 = null;
+                IEnumerator<T2> e2 = null;
+                IEnumerator<T3> e3 = null;
+                IEnumerator<T4> e4 = null;
+                IEnumerator<T5> e5 = null;
+                IEnumerator<T6> e6 = null;
+                IEnumerator<T7> e7 = null;
+
+                try
+                {
+                    e1 = first.GetEnumerator();
+                    e2 = second.GetEnumerator();
+                    e3 = third.GetEnumerator();
+                    e4 = fourth.GetEnumerator();
+                    e5 = fifth.GetEnumerator();
+                    e6 = sixth.GetEnumerator();
+                    e7 = seventh.GetEnumerator();
+
+                    var v1 = default(T1);
+                    var v2 = default(T2);
+                    var v3 = default(T3);
+                    var v4 = default(T4);
+                    var v5 = default(T5);
+                    var v6 = default(T6);
+                    var v7 = default(T7);
+
+                    while (
+                        ZipLongestHelper.MoveNextOrDefault<T1>(ref e1, ref v1) |
+                        ZipLongestHelper.MoveNextOrDefault<T2>(ref e2, ref v2) |
+                        ZipLongestHelper.MoveNextOrDefault<T3>(ref e3, ref v3) |
+                        ZipLongestHelper.MoveNextOrDefault<T4>(ref e4, ref v4) |
+                        ZipLongestHelper.MoveNextOrDefault<T5>(ref e5, ref v5) |
+                        ZipLongestHelper.MoveNextOrDefault<T6>(ref e6, ref v6) |
+                        ZipLongestHelper.MoveNextOrDefault<T7>(ref e7, ref v7))
+                    {
+                        yield return resultSelector(v1, v2, v3, v4, v5, v6, v7);
+                    }
+                }
+                finally
+                {
+                    e1?.Dispose();
+                    e2?.Dispose();
+                    e3?.Dispose();
+                    e4?.Dispose();
+                    e5?.Dispose();
+                    e6?.Dispose();
+                    e7?.Dispose();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input 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 input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <param name="seventh">The seventh source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+
+        public static IEnumerable<(T1, T2, T3, T4, T5, T6, T7)> ZipLongest<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 ZipLongest(
+                first,
+                second,
+                third,
+                fourth,
+                fifth,
+                sixth,
+                seventh,
+                ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input 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 input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
+        /// <typeparam name="T8">Type of elements in eighth input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <param name="seventh">The seventh source sequence.</param>
+        /// <param name="eighth">The eighth source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+
+        public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(
+            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,
+            Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> resultSelector)
+        {
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
+            if (third == null) throw new ArgumentNullException(nameof(third));
+            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
+            if (fifth == null) throw new ArgumentNullException(nameof(fifth));
+            if (sixth == null) throw new ArgumentNullException(nameof(sixth));
+            if (seventh == null) throw new ArgumentNullException(nameof(seventh));
+            if (eighth == null) throw new ArgumentNullException(nameof(eighth));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return _(); IEnumerable<TResult> _()
+            {
+                IEnumerator<T1> e1 = null;
+                IEnumerator<T2> e2 = null;
+                IEnumerator<T3> e3 = null;
+                IEnumerator<T4> e4 = null;
+                IEnumerator<T5> e5 = null;
+                IEnumerator<T6> e6 = null;
+                IEnumerator<T7> e7 = null;
+                IEnumerator<T8> e8 = null;
+
+                try
+                {
+                    e1 = first.GetEnumerator();
+                    e2 = second.GetEnumerator();
+                    e3 = third.GetEnumerator();
+                    e4 = fourth.GetEnumerator();
+                    e5 = fifth.GetEnumerator();
+                    e6 = sixth.GetEnumerator();
+                    e7 = seventh.GetEnumerator();
+                    e8 = eighth.GetEnumerator();
+
+                    var v1 = default(T1);
+                    var v2 = default(T2);
+                    var v3 = default(T3);
+                    var v4 = default(T4);
+                    var v5 = default(T5);
+                    var v6 = default(T6);
+                    var v7 = default(T7);
+                    var v8 = default(T8);
+
+                    while (
+                        ZipLongestHelper.MoveNextOrDefault<T1>(ref e1, ref v1) |
+                        ZipLongestHelper.MoveNextOrDefault<T2>(ref e2, ref v2) |
+                        ZipLongestHelper.MoveNextOrDefault<T3>(ref e3, ref v3) |
+                        ZipLongestHelper.MoveNextOrDefault<T4>(ref e4, ref v4) |
+                        ZipLongestHelper.MoveNextOrDefault<T5>(ref e5, ref v5) |
+                        ZipLongestHelper.MoveNextOrDefault<T6>(ref e6, ref v6) |
+                        ZipLongestHelper.MoveNextOrDefault<T7>(ref e7, ref v7) |
+                        ZipLongestHelper.MoveNextOrDefault<T8>(ref e8, ref v8))
+                    {
+                        yield return resultSelector(v1, v2, v3, v4, v5, v6, v7, v8);
+                    }
+                }
+                finally
+                {
+                    e1?.Dispose();
+                    e2?.Dispose();
+                    e3?.Dispose();
+                    e4?.Dispose();
+                    e5?.Dispose();
+                    e6?.Dispose();
+                    e7?.Dispose();
+                    e8?.Dispose();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input 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 input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
+        /// <typeparam name="T8">Type of elements in eighth input sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <param name="seventh">The seventh source sequence.</param>
+        /// <param name="eighth">The eighth source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+
+        public static IEnumerable<(T1, T2, T3, T4, T5, T6, T7, T8)> ZipLongest<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 ZipLongest(
+                first,
+                second,
+                third,
+                fourth,
+                fifth,
+                sixth,
+                seventh,
+                eighth,
+                ValueTuple.Create);
+        }
+
+    }
+}
diff --git a/MoreLinq/ZipLongest.g.tt b/MoreLinq/ZipLongest.g.tt
new file mode 100644
index 000000000..cd053a9d5
--- /dev/null
+++ b/MoreLinq/ZipLongest.g.tt
@@ -0,0 +1,166 @@
+<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ output extension=".cs" #>
+<#@ assembly name="System.Core" #>
+<#@ assembly name="System.Collections" #>
+<#@ import namespace="System.Globalization" #>
+<#@ import namespace="System.Linq" #>
+#region License and Terms
+// MoreLINQ - Extensions to LINQ to Objects
+// Copyright (c) 2019 Pierre Lando. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#endregion
+
+<#
+    var ordinals = new[]
+    {
+        "",
+        "first", "second", "third", "fourth",
+        "fifth", "sixth", "seventh", "eighth"
+    };
+
+    var overloads =
+        Enumerable.Range(2, 7)
+            .Select(argCount =>
+                Enumerable.Range(1, argCount).Select(argPosition =>
+                    new
+                    {
+                        IsFirst = argPosition == 1,
+                        IsLast = argPosition == argCount,
+                        Name = ordinals[argPosition],
+                        Ordinal = ordinals[argPosition],
+                        Type = $"T{argPosition}",
+                        // Objects associated with the argument
+                        Enumerator = $"e{argPosition}",
+                        Value = $"v{argPosition}"
+                    }))
+            .Select(args => args.ToList())
+            .Select(args =>
+                new
+                {
+                    Arguments = args,
+                    TParams = string.Join(", ", args.Select(arg => arg.Type))
+                });
+#>
+namespace MoreLinq
+{
+    using System;
+    using System.Collections.Generic;
+
+    static partial class MoreEnumerable
+    {
+<#  foreach (var o in overloads)
+    {
+#>
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input 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>
+<# foreach (var arg in o.Arguments) { #>
+        /// <typeparam name="<#=arg.Type#>">Type of elements in <#=arg.Name#> input sequence.</typeparam>
+<#} #>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+<# foreach (var arg in o.Arguments) { #>
+        /// <param name="<#=arg.Name#>">The <#=arg.Ordinal#> source sequence.</param>
+<#} #>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+
+        public static IEnumerable<TResult> ZipLongest<<#=o.TParams#>, TResult>(
+<# foreach (var arg in o.Arguments) { #>
+            <#= arg.IsFirst ? "this " : "" #>IEnumerable<<#=arg.Type#>> <#=arg.Name#>,
+<#}#>
+            Func<<#=o.TParams#>, TResult> resultSelector)
+        {
+<# foreach (var arg in o.Arguments) { #>
+            if (<#=arg.Name#> == null) throw new ArgumentNullException(nameof(<#=arg.Name#>));
+<#} #>
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return _(); IEnumerable<TResult> _()
+            {
+<# foreach (var arg in o.Arguments) { #>
+                IEnumerator<<#=arg.Type#>> <#=arg.Enumerator#> = null;
+<#} #>
+
+                try
+                {
+<# foreach (var arg in o.Arguments) { #>
+                    <#=arg.Enumerator#> = <#=arg.Name#>.GetEnumerator();
+<#} #>
+
+<# foreach (var arg in o.Arguments) { #>
+                    var <#=arg.Value#> = default(<#=arg.Type#>);
+<#} #>
+
+                    while (
+<# foreach (var arg in o.Arguments) { #>
+                        ZipLongestHelper.MoveNextOrDefault<<#=arg.Type#>>(ref <#=arg.Enumerator#>, ref <#=arg.Value#>)<#= arg.IsLast ? ")" : " |" #>
+<#}#>
+                    {
+                        yield return resultSelector(<# foreach (var arg in o.Arguments) { #><#=arg.Value#><#= arg.IsLast ? "" : ", " #><#}#>);
+                    }
+                }
+                finally
+                {
+<# foreach (var arg in o.Arguments) { #>
+                    <#=arg.Enumerator#>?.Dispose();
+<#} #>
+                }
+            }
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input 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>
+<# foreach (var arg in o.Arguments) { #>
+        /// <typeparam name="<#=arg.Type#>">Type of elements in <#=arg.Name#> input sequence.</typeparam>
+<#} #>
+<# foreach (var arg in o.Arguments) { #>
+        /// <param name="<#=arg.Name#>">The <#=arg.Ordinal#> source sequence.</param>
+<#} #>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <remarks>
+        /// This operator uses deferred execution and streams its results.
+        /// </remarks>
+
+        public static IEnumerable<(<#=o.TParams#>)> ZipLongest<<#=o.TParams#>>(
+<# foreach (var arg in o.Arguments) { #>
+            <#= arg.IsFirst ? "this " : "" #>IEnumerable<<#=arg.Type#>> <#=arg.Name#><#= arg.IsLast ? ")" : "," #>
+<#}#>
+        {
+            return ZipLongest(
+<# foreach (var arg in o.Arguments) { #>
+                <#=arg.Name#>,
+<#}#>
+                ValueTuple.Create);
+        }
+
+<#  } #>
+    }
+}
diff --git a/MoreLinq/Zip.cs b/MoreLinq/ZipLongestHelper.cs
similarity index 97%
rename from MoreLinq/Zip.cs
rename to MoreLinq/ZipLongestHelper.cs
index b03e3c9e0..fd570bd7a 100644
--- a/MoreLinq/Zip.cs
+++ b/MoreLinq/ZipLongestHelper.cs
@@ -19,7 +19,7 @@ namespace MoreLinq
 {
     using System.Collections.Generic;
 
-    static class ZipHelper
+    static class ZipLongestHelper
     {
         public static bool MoveNextOrDefault<T>(ref IEnumerator<T> enumerator, ref T value)
         {
diff --git a/MoreLinq/ZipShortest.g.cs b/MoreLinq/ZipShortest.g.cs
new file mode 100644
index 000000000..374f28cc2
--- /dev/null
+++ b/MoreLinq/ZipShortest.g.cs
@@ -0,0 +1,761 @@
+#region License and Terms
+// MoreLINQ - Extensions to LINQ to Objects
+// Copyright (c) 2019 Pierre Lando. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#endregion
+
+namespace MoreLinq
+{
+    using System;
+    using System.Collections.Generic;
+
+    static partial class MoreEnumerable
+    {
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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<TResult> ZipShortest<T1, T2, TResult>(
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            Func<T1, T2, TResult> resultSelector)
+        {
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return _(); IEnumerable<TResult> _()
+            {
+                using var e1 = first.GetEnumerator();
+                using var e2 = second.GetEnumerator();
+
+                while (e1.MoveNext() && e2.MoveNext())
+                {
+                    yield return resultSelector(e1.Current, e2.Current);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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)> ZipShortest<T1, T2>(
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second)
+        {
+            return ZipShortest(
+                first,
+                second,
+                ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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<TResult> ZipShortest<T1, T2, T3, TResult>(
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            Func<T1, T2, T3, TResult> resultSelector)
+        {
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
+            if (third == null) throw new ArgumentNullException(nameof(third));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return _(); IEnumerable<TResult> _()
+            {
+                using var e1 = first.GetEnumerator();
+                using var e2 = second.GetEnumerator();
+                using var e3 = third.GetEnumerator();
+
+                while (e1.MoveNext() && e2.MoveNext() && e3.MoveNext())
+                {
+                    yield return resultSelector(e1.Current, e2.Current, e3.Current);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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 ZipShortest(
+                first,
+                second,
+                third,
+                ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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<TResult> ZipShortest<T1, T2, T3, T4, TResult>(
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            Func<T1, T2, T3, T4, TResult> resultSelector)
+        {
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
+            if (third == null) throw new ArgumentNullException(nameof(third));
+            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return _(); IEnumerable<TResult> _()
+            {
+                using var e1 = first.GetEnumerator();
+                using var e2 = second.GetEnumerator();
+                using var e3 = third.GetEnumerator();
+                using var e4 = fourth.GetEnumerator();
+
+                while (e1.MoveNext() && e2.MoveNext() && e3.MoveNext() && e4.MoveNext())
+                {
+                    yield return resultSelector(e1.Current, e2.Current, e3.Current, e4.Current);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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 ZipShortest(
+                first,
+                second,
+                third,
+                fourth,
+                ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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<TResult> ZipShortest<T1, T2, T3, T4, T5, TResult>(
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth,
+            Func<T1, T2, T3, T4, T5, TResult> resultSelector)
+        {
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
+            if (third == null) throw new ArgumentNullException(nameof(third));
+            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
+            if (fifth == null) throw new ArgumentNullException(nameof(fifth));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return _(); IEnumerable<TResult> _()
+            {
+                using var e1 = first.GetEnumerator();
+                using var e2 = second.GetEnumerator();
+                using var e3 = third.GetEnumerator();
+                using var e4 = fourth.GetEnumerator();
+                using var e5 = fifth.GetEnumerator();
+
+                while (e1.MoveNext() && e2.MoveNext() && e3.MoveNext() && e4.MoveNext() && e5.MoveNext())
+                {
+                    yield return resultSelector(e1.Current, e2.Current, e3.Current, e4.Current, e5.Current);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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, T5)> ZipShortest<T1, T2, T3, T4, T5>(
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth)
+        {
+            return ZipShortest(
+                first,
+                second,
+                third,
+                fourth,
+                fifth,
+                ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, TResult>(
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth,
+            IEnumerable<T6> sixth,
+            Func<T1, T2, T3, T4, T5, T6, TResult> resultSelector)
+        {
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
+            if (third == null) throw new ArgumentNullException(nameof(third));
+            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
+            if (fifth == null) throw new ArgumentNullException(nameof(fifth));
+            if (sixth == null) throw new ArgumentNullException(nameof(sixth));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return _(); IEnumerable<TResult> _()
+            {
+                using var e1 = first.GetEnumerator();
+                using var e2 = second.GetEnumerator();
+                using var e3 = third.GetEnumerator();
+                using var e4 = fourth.GetEnumerator();
+                using var e5 = fifth.GetEnumerator();
+                using var e6 = sixth.GetEnumerator();
+
+                while (e1.MoveNext() && e2.MoveNext() && e3.MoveNext() && e4.MoveNext() && e5.MoveNext() && e6.MoveNext())
+                {
+                    yield return resultSelector(e1.Current, e2.Current, e3.Current, e4.Current, e5.Current, e6.Current);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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, T5, T6)> ZipShortest<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 ZipShortest(
+                first,
+                second,
+                third,
+                fourth,
+                fifth,
+                sixth,
+                ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <param name="seventh">The seventh source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, T7, TResult>(
+            this IEnumerable<T1> first,
+            IEnumerable<T2> second,
+            IEnumerable<T3> third,
+            IEnumerable<T4> fourth,
+            IEnumerable<T5> fifth,
+            IEnumerable<T6> sixth,
+            IEnumerable<T7> seventh,
+            Func<T1, T2, T3, T4, T5, T6, T7, TResult> resultSelector)
+        {
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
+            if (third == null) throw new ArgumentNullException(nameof(third));
+            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
+            if (fifth == null) throw new ArgumentNullException(nameof(fifth));
+            if (sixth == null) throw new ArgumentNullException(nameof(sixth));
+            if (seventh == null) throw new ArgumentNullException(nameof(seventh));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return _(); IEnumerable<TResult> _()
+            {
+                using var e1 = first.GetEnumerator();
+                using var e2 = second.GetEnumerator();
+                using var e3 = third.GetEnumerator();
+                using var e4 = fourth.GetEnumerator();
+                using var e5 = fifth.GetEnumerator();
+                using var e6 = sixth.GetEnumerator();
+                using var e7 = seventh.GetEnumerator();
+
+                while (e1.MoveNext() && e2.MoveNext() && e3.MoveNext() && e4.MoveNext() && e5.MoveNext() && e6.MoveNext() && e7.MoveNext())
+                {
+                    yield return resultSelector(e1.Current, e2.Current, e3.Current, e4.Current, e5.Current, e6.Current, e7.Current);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <param name="seventh">The seventh source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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, T5, T6, T7)> ZipShortest<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 ZipShortest(
+                first,
+                second,
+                third,
+                fourth,
+                fifth,
+                sixth,
+                seventh,
+                ValueTuple.Create);
+        }
+
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
+        /// <typeparam name="T8">Type of elements in eighth input sequence.</typeparam>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <param name="seventh">The seventh source sequence.</param>
+        /// <param name="eighth">The eighth source sequence.</param>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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<TResult> ZipShortest<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(
+            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,
+            Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> resultSelector)
+        {
+            if (first == null) throw new ArgumentNullException(nameof(first));
+            if (second == null) throw new ArgumentNullException(nameof(second));
+            if (third == null) throw new ArgumentNullException(nameof(third));
+            if (fourth == null) throw new ArgumentNullException(nameof(fourth));
+            if (fifth == null) throw new ArgumentNullException(nameof(fifth));
+            if (sixth == null) throw new ArgumentNullException(nameof(sixth));
+            if (seventh == null) throw new ArgumentNullException(nameof(seventh));
+            if (eighth == null) throw new ArgumentNullException(nameof(eighth));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return _(); IEnumerable<TResult> _()
+            {
+                using var e1 = first.GetEnumerator();
+                using var e2 = second.GetEnumerator();
+                using var e3 = third.GetEnumerator();
+                using var e4 = fourth.GetEnumerator();
+                using var e5 = fifth.GetEnumerator();
+                using var e6 = sixth.GetEnumerator();
+                using var e7 = seventh.GetEnumerator();
+                using var e8 = eighth.GetEnumerator();
+
+                while (e1.MoveNext() && e2.MoveNext() && e3.MoveNext() && e4.MoveNext() && e5.MoveNext() && e6.MoveNext() && e7.MoveNext() && e8.MoveNext())
+                {
+                    yield return resultSelector(e1.Current, e2.Current, e3.Current, e4.Current, e5.Current, e6.Current, e7.Current, e8.Current);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+        /// <typeparam name="T1">Type of elements in first input sequence.</typeparam>
+        /// <typeparam name="T2">Type of elements in second input sequence.</typeparam>
+        /// <typeparam name="T3">Type of elements in third input sequence.</typeparam>
+        /// <typeparam name="T4">Type of elements in fourth input sequence.</typeparam>
+        /// <typeparam name="T5">Type of elements in fifth input sequence.</typeparam>
+        /// <typeparam name="T6">Type of elements in sixth input sequence.</typeparam>
+        /// <typeparam name="T7">Type of elements in seventh input sequence.</typeparam>
+        /// <typeparam name="T8">Type of elements in eighth input sequence.</typeparam>
+        /// <param name="first">The first source sequence.</param>
+        /// <param name="second">The second source sequence.</param>
+        /// <param name="third">The third source sequence.</param>
+        /// <param name="fourth">The fourth source sequence.</param>
+        /// <param name="fifth">The fifth source sequence.</param>
+        /// <param name="sixth">The sixth source sequence.</param>
+        /// <param name="seventh">The seventh source sequence.</param>
+        /// <param name="eighth">The eighth source sequence.</param>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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, T5, T6, T7, T8)> ZipShortest<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 ZipShortest(
+                first,
+                second,
+                third,
+                fourth,
+                fifth,
+                sixth,
+                seventh,
+                eighth,
+                ValueTuple.Create);
+        }
+
+    }
+}
diff --git a/MoreLinq/ZipShortest.g.tt b/MoreLinq/ZipShortest.g.tt
new file mode 100644
index 000000000..d23f6cc97
--- /dev/null
+++ b/MoreLinq/ZipShortest.g.tt
@@ -0,0 +1,154 @@
+<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ output extension=".cs" #>
+<#@ assembly name="System.Core" #>
+<#@ assembly name="System.Collections" #>
+<#@ import namespace="System.Globalization" #>
+<#@ import namespace="System.Linq" #>
+#region License and Terms
+// MoreLINQ - Extensions to LINQ to Objects
+// Copyright (c) 2019 Pierre Lando. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#endregion
+
+<#
+    var ordinals = new[]
+    {
+        "",
+        "first", "second", "third", "fourth",
+        "fifth", "sixth", "seventh", "eighth"
+    };
+
+    var overloads =
+        Enumerable.Range(2, 7)
+            .Select(argCount =>
+                Enumerable.Range(1, argCount).Select(argPosition =>
+                    new
+                    {
+                        IsFirst = argPosition == 1,
+                        IsLast = argPosition == argCount,
+                        Name = ordinals[argPosition],
+                        Ordinal = ordinals[argPosition],
+                        Type = $"T{argPosition}",
+                        // Objects associated with the argument
+                        Enumerator = $"e{argPosition}",
+                        Value = $"v{argPosition}"
+                    }))
+            .Select(args => args.ToList())
+            .Select(args =>
+                new
+                {
+                    Arguments = args,
+                    TParams = string.Join(", ", args.Select(arg => arg.Type))
+                });
+#>
+namespace MoreLinq
+{
+    using System;
+    using System.Collections.Generic;
+
+    static partial class MoreEnumerable
+    {
+<#  foreach (var o in overloads)
+    {
+#>
+        /// <summary>
+        /// Returns a projection of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+<# foreach (var arg in o.Arguments) { #>
+        /// <typeparam name="<#=arg.Type#>">Type of elements in <#=arg.Name#> input sequence.</typeparam>
+<#} #>
+        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
+<# foreach (var arg in o.Arguments) { #>
+        /// <param name="<#=arg.Name#>">The <#=arg.Ordinal#> source sequence.</param>
+<#} #>
+        /// <param name="resultSelector">
+        /// Function to apply to each tuple of elements.</param>
+        /// <returns>
+        /// A projection of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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<TResult> ZipShortest<<#=o.TParams#>, TResult>(
+<# foreach (var arg in o.Arguments) { #>
+            <#= arg.IsFirst ? "this " : "" #>IEnumerable<<#=arg.Type#>> <#=arg.Name#>,
+<#}#>
+            Func<<#=o.TParams#>, TResult> resultSelector)
+        {
+<# foreach (var arg in o.Arguments) { #>
+            if (<#=arg.Name#> == null) throw new ArgumentNullException(nameof(<#=arg.Name#>));
+<#} #>
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return _(); IEnumerable<TResult> _()
+            {
+<# foreach (var arg in o.Arguments) { #>
+                using var <#=arg.Enumerator#> = <#=arg.Name#>.GetEnumerator();
+<#} #>
+
+                while (<# foreach (var arg in o.Arguments) { #><#=arg.Enumerator#>.MoveNext()<#= arg.IsLast ? "" : " && " #><#}#>)
+                {
+                    yield return resultSelector(<# foreach (var arg in o.Arguments) { #><#=arg.Enumerator#>.Current<#= arg.IsLast ? "" : ", " #><#}#>);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Returns a sequence of tuples, where each tuple contains the N-th
+        /// element from each of the input sequences. The resulting sequence
+        /// is as short as the shortest input sequence.
+        /// </summary>
+<# foreach (var arg in o.Arguments) { #>
+        /// <typeparam name="<#=arg.Type#>">Type of elements in <#=arg.Name#> input sequence.</typeparam>
+<#} #>
+<# foreach (var arg in o.Arguments) { #>
+        /// <param name="<#=arg.Name#>">The <#=arg.Ordinal#> source sequence.</param>
+<#} #>
+        /// <returns>
+        /// A sequence of tuples, where each tuple contains the N-th element
+        /// from each of the argument sequences.</returns>
+        /// <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<(<#=o.TParams#>)> ZipShortest<<#=o.TParams#>>(
+<# foreach (var arg in o.Arguments) { #>
+            <#= arg.IsFirst ? "this " : "" #>IEnumerable<<#=arg.Type#>> <#=arg.Name#><#= arg.IsLast ? ")" : "," #>
+<#}#>
+        {
+            return ZipShortest(
+<# foreach (var arg in o.Arguments) { #>
+                <#=arg.Name#>,
+<#}#>
+                ValueTuple.Create);
+        }
+
+<#  } #>
+    }
+}

From 917a64578ef4cf3eeb3e529f3ee75211aa7a1ed2 Mon Sep 17 00:00:00 2001
From: Orace <pierre.lando@gmail.com>
Date: Wed, 6 Nov 2019 11:08:09 +0100
Subject: [PATCH 09/11] Add comments on ZipLongest implementation.

---
 MoreLinq/ZipLongest.g.cs     | 77 ++++++++++++++++++++----------------
 MoreLinq/ZipLongest.g.tt     |  1 +
 MoreLinq/ZipLongestHelper.cs | 22 ++++++++++-
 3 files changed, 64 insertions(+), 36 deletions(-)

diff --git a/MoreLinq/ZipLongest.g.cs b/MoreLinq/ZipLongest.g.cs
index d599fb105..a98be8cd9 100644
--- a/MoreLinq/ZipLongest.g.cs
+++ b/MoreLinq/ZipLongest.g.cs
@@ -65,9 +65,10 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, TResult>(
                     var v1 = default(T1);
                     var v2 = default(T2);
 
+                    // | is used instead of || in purpose. All operands have to be evaluated.
                     while (
-                        ZipLongestHelper.MoveNextOrDefault<T1>(ref e1, ref v1) |
-                        ZipLongestHelper.MoveNextOrDefault<T2>(ref e2, ref v2))
+                        ZipLongestHelper.MoveNextOrDispose<T1>(ref e1, ref v1) |
+                        ZipLongestHelper.MoveNextOrDispose<T2>(ref e2, ref v2))
                     {
                         yield return resultSelector(v1, v2);
                     }
@@ -158,10 +159,11 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, TResult>(
                     var v2 = default(T2);
                     var v3 = default(T3);
 
+                    // | is used instead of || in purpose. All operands have to be evaluated.
                     while (
-                        ZipLongestHelper.MoveNextOrDefault<T1>(ref e1, ref v1) |
-                        ZipLongestHelper.MoveNextOrDefault<T2>(ref e2, ref v2) |
-                        ZipLongestHelper.MoveNextOrDefault<T3>(ref e3, ref v3))
+                        ZipLongestHelper.MoveNextOrDispose<T1>(ref e1, ref v1) |
+                        ZipLongestHelper.MoveNextOrDispose<T2>(ref e2, ref v2) |
+                        ZipLongestHelper.MoveNextOrDispose<T3>(ref e3, ref v3))
                     {
                         yield return resultSelector(v1, v2, v3);
                     }
@@ -264,11 +266,12 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, TResult>(
                     var v3 = default(T3);
                     var v4 = default(T4);
 
+                    // | is used instead of || in purpose. All operands have to be evaluated.
                     while (
-                        ZipLongestHelper.MoveNextOrDefault<T1>(ref e1, ref v1) |
-                        ZipLongestHelper.MoveNextOrDefault<T2>(ref e2, ref v2) |
-                        ZipLongestHelper.MoveNextOrDefault<T3>(ref e3, ref v3) |
-                        ZipLongestHelper.MoveNextOrDefault<T4>(ref e4, ref v4))
+                        ZipLongestHelper.MoveNextOrDispose<T1>(ref e1, ref v1) |
+                        ZipLongestHelper.MoveNextOrDispose<T2>(ref e2, ref v2) |
+                        ZipLongestHelper.MoveNextOrDispose<T3>(ref e3, ref v3) |
+                        ZipLongestHelper.MoveNextOrDispose<T4>(ref e4, ref v4))
                     {
                         yield return resultSelector(v1, v2, v3, v4);
                     }
@@ -383,12 +386,13 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, TResult>(
                     var v4 = default(T4);
                     var v5 = default(T5);
 
+                    // | is used instead of || in purpose. All operands have to be evaluated.
                     while (
-                        ZipLongestHelper.MoveNextOrDefault<T1>(ref e1, ref v1) |
-                        ZipLongestHelper.MoveNextOrDefault<T2>(ref e2, ref v2) |
-                        ZipLongestHelper.MoveNextOrDefault<T3>(ref e3, ref v3) |
-                        ZipLongestHelper.MoveNextOrDefault<T4>(ref e4, ref v4) |
-                        ZipLongestHelper.MoveNextOrDefault<T5>(ref e5, ref v5))
+                        ZipLongestHelper.MoveNextOrDispose<T1>(ref e1, ref v1) |
+                        ZipLongestHelper.MoveNextOrDispose<T2>(ref e2, ref v2) |
+                        ZipLongestHelper.MoveNextOrDispose<T3>(ref e3, ref v3) |
+                        ZipLongestHelper.MoveNextOrDispose<T4>(ref e4, ref v4) |
+                        ZipLongestHelper.MoveNextOrDispose<T5>(ref e5, ref v5))
                     {
                         yield return resultSelector(v1, v2, v3, v4, v5);
                     }
@@ -515,13 +519,14 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, TResult>(
                     var v5 = default(T5);
                     var v6 = default(T6);
 
+                    // | is used instead of || in purpose. All operands have to be evaluated.
                     while (
-                        ZipLongestHelper.MoveNextOrDefault<T1>(ref e1, ref v1) |
-                        ZipLongestHelper.MoveNextOrDefault<T2>(ref e2, ref v2) |
-                        ZipLongestHelper.MoveNextOrDefault<T3>(ref e3, ref v3) |
-                        ZipLongestHelper.MoveNextOrDefault<T4>(ref e4, ref v4) |
-                        ZipLongestHelper.MoveNextOrDefault<T5>(ref e5, ref v5) |
-                        ZipLongestHelper.MoveNextOrDefault<T6>(ref e6, ref v6))
+                        ZipLongestHelper.MoveNextOrDispose<T1>(ref e1, ref v1) |
+                        ZipLongestHelper.MoveNextOrDispose<T2>(ref e2, ref v2) |
+                        ZipLongestHelper.MoveNextOrDispose<T3>(ref e3, ref v3) |
+                        ZipLongestHelper.MoveNextOrDispose<T4>(ref e4, ref v4) |
+                        ZipLongestHelper.MoveNextOrDispose<T5>(ref e5, ref v5) |
+                        ZipLongestHelper.MoveNextOrDispose<T6>(ref e6, ref v6))
                     {
                         yield return resultSelector(v1, v2, v3, v4, v5, v6);
                     }
@@ -660,14 +665,15 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, T7, TResul
                     var v6 = default(T6);
                     var v7 = default(T7);
 
+                    // | is used instead of || in purpose. All operands have to be evaluated.
                     while (
-                        ZipLongestHelper.MoveNextOrDefault<T1>(ref e1, ref v1) |
-                        ZipLongestHelper.MoveNextOrDefault<T2>(ref e2, ref v2) |
-                        ZipLongestHelper.MoveNextOrDefault<T3>(ref e3, ref v3) |
-                        ZipLongestHelper.MoveNextOrDefault<T4>(ref e4, ref v4) |
-                        ZipLongestHelper.MoveNextOrDefault<T5>(ref e5, ref v5) |
-                        ZipLongestHelper.MoveNextOrDefault<T6>(ref e6, ref v6) |
-                        ZipLongestHelper.MoveNextOrDefault<T7>(ref e7, ref v7))
+                        ZipLongestHelper.MoveNextOrDispose<T1>(ref e1, ref v1) |
+                        ZipLongestHelper.MoveNextOrDispose<T2>(ref e2, ref v2) |
+                        ZipLongestHelper.MoveNextOrDispose<T3>(ref e3, ref v3) |
+                        ZipLongestHelper.MoveNextOrDispose<T4>(ref e4, ref v4) |
+                        ZipLongestHelper.MoveNextOrDispose<T5>(ref e5, ref v5) |
+                        ZipLongestHelper.MoveNextOrDispose<T6>(ref e6, ref v6) |
+                        ZipLongestHelper.MoveNextOrDispose<T7>(ref e7, ref v7))
                     {
                         yield return resultSelector(v1, v2, v3, v4, v5, v6, v7);
                     }
@@ -818,15 +824,16 @@ public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, T5, T6, T7, T8, TR
                     var v7 = default(T7);
                     var v8 = default(T8);
 
+                    // | is used instead of || in purpose. All operands have to be evaluated.
                     while (
-                        ZipLongestHelper.MoveNextOrDefault<T1>(ref e1, ref v1) |
-                        ZipLongestHelper.MoveNextOrDefault<T2>(ref e2, ref v2) |
-                        ZipLongestHelper.MoveNextOrDefault<T3>(ref e3, ref v3) |
-                        ZipLongestHelper.MoveNextOrDefault<T4>(ref e4, ref v4) |
-                        ZipLongestHelper.MoveNextOrDefault<T5>(ref e5, ref v5) |
-                        ZipLongestHelper.MoveNextOrDefault<T6>(ref e6, ref v6) |
-                        ZipLongestHelper.MoveNextOrDefault<T7>(ref e7, ref v7) |
-                        ZipLongestHelper.MoveNextOrDefault<T8>(ref e8, ref v8))
+                        ZipLongestHelper.MoveNextOrDispose<T1>(ref e1, ref v1) |
+                        ZipLongestHelper.MoveNextOrDispose<T2>(ref e2, ref v2) |
+                        ZipLongestHelper.MoveNextOrDispose<T3>(ref e3, ref v3) |
+                        ZipLongestHelper.MoveNextOrDispose<T4>(ref e4, ref v4) |
+                        ZipLongestHelper.MoveNextOrDispose<T5>(ref e5, ref v5) |
+                        ZipLongestHelper.MoveNextOrDispose<T6>(ref e6, ref v6) |
+                        ZipLongestHelper.MoveNextOrDispose<T7>(ref e7, ref v7) |
+                        ZipLongestHelper.MoveNextOrDispose<T8>(ref e8, ref v8))
                     {
                         yield return resultSelector(v1, v2, v3, v4, v5, v6, v7, v8);
                     }
diff --git a/MoreLinq/ZipLongest.g.tt b/MoreLinq/ZipLongest.g.tt
index cd053a9d5..8d57d6097 100644
--- a/MoreLinq/ZipLongest.g.tt
+++ b/MoreLinq/ZipLongest.g.tt
@@ -112,6 +112,7 @@ namespace MoreLinq
                     var <#=arg.Value#> = default(<#=arg.Type#>);
 <#} #>
 
+                    // | is used instead of || in purpose. All operands have to be evaluated.
                     while (
 <# foreach (var arg in o.Arguments) { #>
                         ZipLongestHelper.MoveNextOrDefault<<#=arg.Type#>>(ref <#=arg.Enumerator#>, ref <#=arg.Value#>)<#= arg.IsLast ? ")" : " |" #>
diff --git a/MoreLinq/ZipLongestHelper.cs b/MoreLinq/ZipLongestHelper.cs
index fd570bd7a..4a916dc19 100644
--- a/MoreLinq/ZipLongestHelper.cs
+++ b/MoreLinq/ZipLongestHelper.cs
@@ -21,7 +21,27 @@ namespace MoreLinq
 
     static class ZipLongestHelper
     {
-        public static bool MoveNextOrDefault<T>(ref IEnumerator<T> enumerator, ref T value)
+        /// <summary>
+        /// Move the <paramref name="enumerator"/> to the next position and put the
+        /// new current value into <paramref name="value"/>.
+        /// 
+        /// If the <paramref name="enumerator"/> has no more element it's disposed and
+        /// set to <c>null</c>, and <paramref name="value"/> is set to <c>default</c>.
+        /// 
+        /// If the <paramref name="enumerator"/> is <c>null</c> the method return immediately
+        /// and <paramref name="value"/> is not modified.
+        /// </summary>
+        /// <typeparam name="T">The type of element that are enumerated.</typeparam>
+        /// <param name="enumerator">The enumerator to iterate or dispose.</param>
+        /// <param name="value">The new current value of <paramref name="enumerator"/> or
+        /// <c>default</c> if <paramref name="enumerator"/> has no more element.
+        /// </param>
+        /// <remarks>
+        /// Because <paramref name="enumerator"/> and <paramref name="value"/> may both be modified
+        /// they are both passed by reference.
+        /// </remarks>
+        /// <returns>A <c>bool</c> value indicating if the enumerator has moved to the next element.</returns>
+        public static bool MoveNextOrDispose<T>(ref IEnumerator<T> enumerator, ref T value)
         {
             if (enumerator == null)
             {

From 43e0bd404a71cf98df7633ed1efd325ac600ed8d Mon Sep 17 00:00:00 2001
From: Orace <pierre.lando@gmail.com>
Date: Wed, 6 Nov 2019 11:20:04 +0100
Subject: [PATCH 10/11] Fix trailing white space

---
 MoreLinq/ZipLongestHelper.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/MoreLinq/ZipLongestHelper.cs b/MoreLinq/ZipLongestHelper.cs
index 4a916dc19..09676eb0d 100644
--- a/MoreLinq/ZipLongestHelper.cs
+++ b/MoreLinq/ZipLongestHelper.cs
@@ -24,10 +24,10 @@ static class ZipLongestHelper
         /// <summary>
         /// Move the <paramref name="enumerator"/> to the next position and put the
         /// new current value into <paramref name="value"/>.
-        /// 
+        ///
         /// If the <paramref name="enumerator"/> has no more element it's disposed and
         /// set to <c>null</c>, and <paramref name="value"/> is set to <c>default</c>.
-        /// 
+        ///
         /// If the <paramref name="enumerator"/> is <c>null</c> the method return immediately
         /// and <paramref name="value"/> is not modified.
         /// </summary>

From 30d92525ca444eab71dad027722a430e74afa786 Mon Sep 17 00:00:00 2001
From: Orace <pierre.lando@gmail.com>
Date: Wed, 6 Nov 2019 11:25:10 +0100
Subject: [PATCH 11/11] ZipLongestHelper.MoveNextOrDefault =>
 ZipLongestHelper.MoveNextOrDispose

---
 MoreLinq/ZipLongest.g.tt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/MoreLinq/ZipLongest.g.tt b/MoreLinq/ZipLongest.g.tt
index 8d57d6097..b45c1bebe 100644
--- a/MoreLinq/ZipLongest.g.tt
+++ b/MoreLinq/ZipLongest.g.tt
@@ -115,7 +115,7 @@ namespace MoreLinq
                     // | is used instead of || in purpose. All operands have to be evaluated.
                     while (
 <# foreach (var arg in o.Arguments) { #>
-                        ZipLongestHelper.MoveNextOrDefault<<#=arg.Type#>>(ref <#=arg.Enumerator#>, ref <#=arg.Value#>)<#= arg.IsLast ? ")" : " |" #>
+                        ZipLongestHelper.MoveNextOrDispose<<#=arg.Type#>>(ref <#=arg.Enumerator#>, ref <#=arg.Value#>)<#= arg.IsLast ? ")" : " |" #>
 <#}#>
                     {
                         yield return resultSelector(<# foreach (var arg in o.Arguments) { #><#=arg.Value#><#= arg.IsLast ? "" : ", " #><#}#>);