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 ? "" : ", " #><#}#>);