Skip to content

Commit 236123a

Browse files
committed
Refactor Zip.g.tt
1 parent 48720bf commit 236123a

File tree

1 file changed

+76
-81
lines changed

1 file changed

+76
-81
lines changed

MoreLinq/Zip.g.tt

Lines changed: 76 additions & 81 deletions
Original file line numberDiff line numberDiff line change
@@ -22,40 +22,35 @@
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
#>
6055
namespace 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

Comments
 (0)