2222#endregion
2323
2424<#
25+     var ordinals = new[]
26+     {
27+         "",
28+         "first", "second", "third", "fourth",
29+         "fifth", "sixth", "seventh", "eighth"
30+     };
31+ 
2532    var overloads =
26-         from args in new[]
27-         {
28-             new[]
29-             {
30-                 new { Ordinal = "first"  , Arity = "one"   },
31-                 new { Ordinal = "second" , Arity = "two"   },
32-                 new { Ordinal = "third"  , Arity = "three" },
33-                 new { Ordinal = "fourth" , Arity = "four"  },
34-                 new { Ordinal = "fifth"  , Arity = "five"  },
35-                 new { Ordinal = "sixth"  , Arity = "six"   },
36-                 new { Ordinal = "seventh", Arity = "seven" },
37-                 new { Ordinal = "eighth" , Arity = "eight" },
38-             }
39-         }
40-         select args.Select((a, i) => new
41-         {
42-             a.Ordinal,
43-             a.Arity,
44-             Count = i + 1,
45-             Number = (i + 1).ToString(CultureInfo.InvariantCulture),
46-         })
47-         into args
48-         select args.ToList() into args
49-         from a in args.Skip(1)
50-         select new
51-         {
52-             a.Arity,
53-             a.Count,
54-             Arguments = args.Take(a.Count)
55-                             .Select(aa => new { aa.Number, Num = aa.Count, aa.Ordinal })
56-                             .ToList(),
57-             Types = string.Join(", ", Enumerable.Range(1, a.Count).Select(i => $"T{i}")),
58-         };
33+         Enumerable.Range(2, 7)
34+             .Select(argCount =>
35+                 Enumerable.Range(1, argCount).Select(argPosition =>
36+                     new
37+                     {
38+                         IsFirst = argPosition == 1,
39+                         IsLast = argPosition == argCount,
40+                         Name = ordinals[argPosition],
41+                         Ordinal = ordinals[argPosition],
42+                         Type = $"T{argPosition}",
43+                         // Objects associated with the argument
44+                         Enumerator = $"e{argPosition}",
45+                         Value = $"v{argPosition}"
46+                     }))
47+             .Select(args => args.ToList())
48+             .Select(args =>
49+                 new
50+                 {
51+                     Arguments = args,
52+                     TParams = string.Join(", ", args.Select(arg => arg.Type))
53+                 });
5954#>
6055namespace MoreLinq
6156{
@@ -73,11 +68,11 @@ namespace MoreLinq
7368        /// if the input sequences are of different lengths.
7469        /// </summary>
7570<# foreach (var arg in o.Arguments) { #>
76-         /// <typeparam name="T <#=  arg.Number  #>">Type of elements in <#=  arg.Ordinal  #> input sequence.</typeparam>
71+         /// <typeparam name="<#=arg.Type #>">Type of elements in <#=arg.Name #> input sequence.</typeparam>
7772<#} #>
7873        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
7974<# foreach (var arg in o.Arguments) { #>
80-         /// <param name="<#=  arg.Ordinal  #>">The <#=  arg.Ordinal  #> source sequence.</param>
75+         /// <param name="<#=arg.Name #>">The <#=arg.Ordinal#> source sequence.</param>
8176<#} #>
8277        /// <param name="resultSelector">
8378        /// Function to apply to each tuple of elements.</param>
@@ -91,35 +86,35 @@ namespace MoreLinq
9186        /// This operator uses deferred execution and streams its results.
9287        /// </remarks>
9388
94-         public static IEnumerable<TResult> EquiZip<<#= o.Types #>, TResult>(
89+         public static IEnumerable<TResult> EquiZip<<#=o.TParams #>, TResult>(
9590<# foreach (var arg in o.Arguments) { #>
96-             <#= arg.Num == 1  ? "this " : "" #>IEnumerable<T <#=  arg.Number  #>> <#=  arg.Ordinal  #>,
97- <#}#>
98-             Func<<#= o.Types #>, TResult> resultSelector)
91+             <#= arg.IsFirst  ? "this " : "" #>IEnumerable<<#=arg.Type #>> <#=arg.Name #>,
92+ <#}  #>
93+             Func<<#=o.TParams #>, TResult> resultSelector)
9994        {
10095<# foreach (var arg in o.Arguments) { #>
101-             if (<#=  arg.Ordinal  #> == null) throw new ArgumentNullException(nameof(<#=  arg.Ordinal  #>));
96+             if (<#=arg.Name #> == null) throw new ArgumentNullException(nameof(<#=arg.Name #>));
10297<#} #>
10398            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
10499
105100            return _(); IEnumerable<TResult> _()
106101            {
107102<# foreach (var arg in o.Arguments) { #>
108-                 using var e <#=  arg.Number  #> = <#=  arg.Ordinal  #>.GetEnumerator();
103+                 using var <#=arg.Enumerator #> = <#=arg.Name #>.GetEnumerator();
109104<#} #>
110105
111106                for (;;)
112107                {
113-                     if (e <#=  o.Arguments.First().Number  #>.MoveNext())
108+                     if (<#=o.Arguments.First().Enumerator #>.MoveNext())
114109                    {
115-                         if (<# foreach (var arg in o.Arguments.Skip(1)) { #>e <#=  arg.Number  #>.MoveNext()<#= arg.Num < o.Count  ? " &&  " : "" #><#}#>)
116-                             yield return resultSelector(<# foreach (var arg in o.Arguments) { #>e <#=  arg.Number  #>.Current<#= arg.Num < o.Count  ? ",  " : "" #><#}#>);
110+                         if (<# foreach (var arg in o.Arguments.Skip(1)) { #><#=arg.Enumerator #>.MoveNext()<#= arg.IsLast  ? "" : " &&  " #><#}#>)
111+                             yield return resultSelector(<# foreach (var arg in o.Arguments) { #><#=arg.Enumerator #>.Current<#= arg.IsLast  ? "" : ",  " #><#}#>);
117112                        else
118113                            break;
119114                    }
120115                    else
121116                    {
122-                         if (<# foreach (var arg in o.Arguments.Skip(1)) { #>e <#=  arg.Number  #>.MoveNext()<#= arg.Num < o.Count  ? " ||  " : "" #><#}#>)
117+                         if (<# foreach (var arg in o.Arguments.Skip(1)) { #><#=arg.Enumerator #>.MoveNext()<#= arg.IsLast  ? "" : " ||  " #><#}#>)
123118                            break;
124119                        else
125120                            yield break;
@@ -136,10 +131,10 @@ namespace MoreLinq
136131        /// if the input sequences are of different lengths.
137132        /// </summary>
138133<# foreach (var arg in o.Arguments) { #>
139-         /// <typeparam name="T <#=  arg.Number  #>">Type of elements in <#=  arg.Ordinal  #> input sequence.</typeparam>
134+         /// <typeparam name="<#=arg.Type #>">Type of elements in <#=arg.Name #> input sequence.</typeparam>
140135<#} #>
141136<# foreach (var arg in o.Arguments) { #>
142-         /// <param name="<#=  arg.Ordinal  #>">The <#=  arg.Ordinal  #> source sequence.</param>
137+         /// <param name="<#=arg.Name #>">The <#=arg.Ordinal#> source sequence.</param>
143138<#} #>
144139        /// <returns>
145140        /// A sequence of tuples, where each tuple contains the N-th element
@@ -150,14 +145,14 @@ namespace MoreLinq
150145        /// <remarks>
151146        /// This operator uses deferred execution and streams its results.
152147        /// </remarks>
153-         public static IEnumerable<(<#= o.Types #>)> EquiZip<<#= o.Types #>>(
148+         public static IEnumerable<(<#=o.TParams #>)> EquiZip<<#=o.TParams #>>(
154149<# foreach (var arg in o.Arguments) { #>
155-             <#= arg.Num == 1  ? "this " : "" #>IEnumerable<T <#=  arg.Number  #>> <#=  arg.Ordinal  #><#= arg.Num < o.Count  ? ", " : ") " #>
150+             <#= arg.IsFirst  ? "this " : "" #>IEnumerable<<#=arg.Type #>> <#=arg.Name #><#= arg.IsLast  ? ") " : ", " #>
156151<#}#>
157152        {
158153            return EquiZip(
159154<# foreach (var arg in o.Arguments) { #>
160-                 <#=  arg.Ordinal  #>,
155+                 <#=arg.Name #>,
161156<#}#>
162157                ValueTuple.Create);
163158        }
@@ -170,11 +165,11 @@ namespace MoreLinq
170165        /// for padding.
171166        /// </summary>
172167<# foreach (var arg in o.Arguments) { #>
173-         /// <typeparam name="T <#=  arg.Number  #>">Type of elements in <#=  arg.Ordinal  #> input sequence.</typeparam>
168+         /// <typeparam name="<#=arg.Type #>">Type of elements in <#=arg.Name #> input sequence.</typeparam>
174169<#} #>
175170        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
176171<# foreach (var arg in o.Arguments) { #>
177-         /// <param name="<#=  arg.Ordinal  #>">The <#=  arg.Ordinal  #> source sequence.</param>
172+         /// <param name="<#=arg.Name #>">The <#=arg.Ordinal#> source sequence.</param>
178173<#} #>
179174        /// <param name="resultSelector">
180175        /// Function to apply to each tuple of elements.</param>
@@ -184,45 +179,45 @@ namespace MoreLinq
184179        /// <remarks>
185180        /// This operator uses deferred execution and streams its results.
186181        /// </remarks>
187-         public static IEnumerable<TResult> ZipLongest<<#= o.Types #>, TResult>(
182+         public static IEnumerable<TResult> ZipLongest<<#=o.TParams #>, TResult>(
188183<# foreach (var arg in o.Arguments) { #>
189-             <#= arg.Num == 1  ? "this " : "" #>IEnumerable<T <#=  arg.Number  #>> <#=  arg.Ordinal  #>,
184+             <#= arg.IsFirst  ? "this " : "" #>IEnumerable<<#=arg.Type #>> <#=arg.Name #>,
190185<#}#>
191-             Func<<#= o.Types #>, TResult> resultSelector)
186+             Func<<#=o.TParams #>, TResult> resultSelector)
192187        {
193188<# foreach (var arg in o.Arguments) { #>
194-             if (<#=  arg.Ordinal  #> == null) throw new ArgumentNullException(nameof(<#=  arg.Ordinal  #>));
189+             if (<#=arg.Name #> == null) throw new ArgumentNullException(nameof(<#=arg.Name #>));
195190<#} #>
196191            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
197192
198193            return _(); IEnumerable<TResult> _()
199194            {
200195<# foreach (var arg in o.Arguments) { #>
201-                 IEnumerator<T <#=  arg.Number  #>> e <#=  arg.Number  #> = null;
196+                 IEnumerator<<#=arg.Type #>> <#=arg.Enumerator #> = null;
202197<#} #>
203198
204199                try
205200                {
206201<# foreach (var arg in o.Arguments) { #>
207-                     e <#=  arg.Number  #> = <#=  arg.Ordinal  #>.GetEnumerator();
202+                     <#=arg.Enumerator #> = <#=arg.Name #>.GetEnumerator();
208203<#} #>
209204
210205<# foreach (var arg in o.Arguments) { #>
211-                     var v <#=  arg.Number  #> = default(T <#=  arg.Number  #>);
206+                     var <#=arg.Value #> = default(<#=arg.Type #>);
212207<#} #>
213208
214209                    while (
215210<# foreach (var arg in o.Arguments) { #>
216-                         ZipHelper.MoveNextOrDefault<T <#=  arg.Number  #>>(ref e <#=  arg.Number  #>, ref v <#=  arg.Number  #>)<#= arg.Num < o.Count  ? " | " : ") " #>
211+                         ZipHelper.MoveNextOrDefault<<#=arg.Type #>>(ref <#=arg.Enumerator #>, ref <#=arg.Value #>)<#= arg.IsLast  ? ") " : " | " #>
217212<#}#>
218213                    {
219-                         yield return resultSelector(<# foreach (var arg in o.Arguments) { #>v <#=  arg.Number  #><#= arg.Num < o.Count  ? ",  " : "" #><#}#>);
214+                         yield return resultSelector(<# foreach (var arg in o.Arguments) { #><#=arg.Value #><#= arg.IsLast  ? "" : ",  " #><#}#>);
220215                    }
221216                }
222217                finally
223218                {
224219<# foreach (var arg in o.Arguments) { #>
225-                     e <#=  arg.Number  #>?.Dispose();
220+                     <#=arg.Enumerator #>?.Dispose();
226221<#} #>
227222                }
228223            }
@@ -236,25 +231,25 @@ namespace MoreLinq
236231        /// for padding.
237232        /// </summary>
238233<# foreach (var arg in o.Arguments) { #>
239-         /// <typeparam name="T <#=  arg.Number  #>">Type of elements in <#=  arg.Ordinal  #> input sequence.</typeparam>
234+         /// <typeparam name="<#=arg.Type #>">Type of elements in <#=arg.Name #> input sequence.</typeparam>
240235<#} #>
241236<# foreach (var arg in o.Arguments) { #>
242-         /// <param name="<#=  arg.Ordinal  #>">The <#=  arg.Ordinal  #> source sequence.</param>
237+         /// <param name="<#=arg.Name #>">The <#=arg.Ordinal#> source sequence.</param>
243238<#} #>
244239        /// <returns>
245240        /// A sequence of tuples, where each tuple contains the N-th element
246241        /// from each of the argument sequences.</returns>
247242        /// <remarks>
248243        /// This operator uses deferred execution and streams its results.
249244        /// </remarks>
250-         public static IEnumerable<(<#= o.Types #>)> ZipLongest<<#= o.Types #>>(
245+         public static IEnumerable<(<#=o.TParams #>)> ZipLongest<<#=o.TParams #>>(
251246<# foreach (var arg in o.Arguments) { #>
252-             <#= arg.Num == 1  ? "this " : "" #>IEnumerable<T <#=  arg.Number  #>> <#=  arg.Ordinal  #><#= arg.Num < o.Count  ? ", " : ") " #>
247+             <#= arg.IsFirst  ? "this " : "" #>IEnumerable<<#=arg.Type #>> <#=arg.Name #><#= arg.IsLast  ? ") " : ", " #>
253248<#}#>
254249        {
255250            return ZipLongest(
256251<# foreach (var arg in o.Arguments) { #>
257-                 <#=  arg.Ordinal  #>,
252+                 <#=arg.Name #>,
258253<#}#>
259254                ValueTuple.Create);
260255        }
@@ -265,11 +260,11 @@ namespace MoreLinq
265260        /// is as short as the shortest input sequence.
266261        /// </summary>
267262<# foreach (var arg in o.Arguments) { #>
268-         /// <typeparam name="T <#=  arg.Number  #>">Type of elements in <#=  arg.Ordinal  #> input sequence.</typeparam>
263+         /// <typeparam name="<#=arg.Type #>">Type of elements in <#=arg.Name #> input sequence.</typeparam>
269264<#} #>
270265        /// <typeparam name="TResult">Type of elements in result sequence.</typeparam>
271266<# foreach (var arg in o.Arguments) { #>
272-         /// <param name="<#=  arg.Ordinal  #>">The <#=  arg.Ordinal  #> source sequence.</param>
267+         /// <param name="<#=arg.Name #>">The <#=arg.Ordinal#> source sequence.</param>
273268<#} #>
274269        /// <param name="resultSelector">
275270        /// Function to apply to each tuple of elements.</param>
@@ -286,26 +281,26 @@ namespace MoreLinq
286281        /// This operator uses deferred execution and streams its results.</para>
287282        /// </remarks>
288283
289-         public static IEnumerable<TResult> ZipShortest<<#= o.Types #>, TResult>(
284+         public static IEnumerable<TResult> ZipShortest<<#=o.TParams #>, TResult>(
290285<# foreach (var arg in o.Arguments) { #>
291-             <#= arg.Num == 1  ? "this " : "" #>IEnumerable<T <#=  arg.Number  #>> <#=  arg.Ordinal  #>,
286+             <#= arg.IsFirst  ? "this " : "" #>IEnumerable<<#=arg.Type #>> <#=arg.Name #>,
292287<#}#>
293-             Func<<#= o.Types #>, TResult> resultSelector)
288+             Func<<#=o.TParams #>, TResult> resultSelector)
294289        {
295290<# foreach (var arg in o.Arguments) { #>
296-             if (<#=  arg.Ordinal  #> == null) throw new ArgumentNullException(nameof(<#=  arg.Ordinal  #>));
291+             if (<#=arg.Name #> == null) throw new ArgumentNullException(nameof(<#=arg.Name #>));
297292<#} #>
298293            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
299294
300295            return _(); IEnumerable<TResult> _()
301296            {
302297<# foreach (var arg in o.Arguments) { #>
303-                 using var e <#=  arg.Number  #> = <#=  arg.Ordinal  #>.GetEnumerator();
298+                 using var <#=arg.Enumerator #> = <#=arg.Name #>.GetEnumerator();
304299<#} #>
305300
306-                 while (<# foreach (var arg in o.Arguments) { #>e <#=  arg.Number  #>.MoveNext()<#= arg.Num < o.Count  ? " &&  " : "" #><#}#>)
301+                 while (<# foreach (var arg in o.Arguments) { #><#=arg.Enumerator #>.MoveNext()<#= arg.IsLast  ? "" : " &&  " #><#}#>)
307302                {
308-                     yield return resultSelector(<# foreach (var arg in o.Arguments) { #>e <#=  arg.Number  #>.Current<#= arg.Num < o.Count  ? ",  " : "" #><#}#>);
303+                     yield return resultSelector(<# foreach (var arg in o.Arguments) { #><#=arg.Enumerator #>.Current<#= arg.IsLast  ? "" : ",  " #><#}#>);
309304                }
310305            }
311306        }
@@ -316,10 +311,10 @@ namespace MoreLinq
316311        /// is as short as the shortest input sequence.
317312        /// </summary>
318313<# foreach (var arg in o.Arguments) { #>
319-         /// <typeparam name="T <#=  arg.Number  #>">Type of elements in <#=  arg.Ordinal  #> input sequence.</typeparam>
314+         /// <typeparam name="<#=arg.Type #>">Type of elements in <#=arg.Name #> input sequence.</typeparam>
320315<#} #>
321316<# foreach (var arg in o.Arguments) { #>
322-         /// <param name="<#=  arg.Ordinal  #>">The <#=  arg.Ordinal  #> source sequence.</param>
317+         /// <param name="<#=arg.Name #>">The <#=arg.Ordinal#> source sequence.</param>
323318<#} #>
324319        /// <returns>
325320        /// A sequence of tuples, where each tuple contains the N-th element
@@ -334,14 +329,14 @@ namespace MoreLinq
334329        /// This operator uses deferred execution and streams its results.</para>
335330        /// </remarks>
336331
337-         public static IEnumerable<(<#= o.Types #>)> ZipShortest<<#= o.Types #>>(
332+         public static IEnumerable<(<#=o.TParams #>)> ZipShortest<<#=o.TParams #>>(
338333<# foreach (var arg in o.Arguments) { #>
339-             <#= arg.Num == 1  ? "this " : "" #>IEnumerable<T <#=  arg.Number  #>> <#=  arg.Ordinal  #><#= arg.Num < o.Count  ? ", " : ") " #>
334+             <#= arg.IsFirst  ? "this " : "" #>IEnumerable<<#=arg.Type #>> <#=arg.Name #><#= arg.IsLast  ? ") " : ", " #>
340335<#}#>
341336        {
342337            return ZipShortest(
343338<# foreach (var arg in o.Arguments) { #>
344-                 <#=  arg.Ordinal  #>,
339+                 <#=arg.Name #>,
345340<#}#>
346341                ValueTuple.Create);
347342        }
0 commit comments