Cartesian.g.tt

<#@ template debug="false" hostspecific="false" language="C#" #>
<#@ output extension=".cs" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System.Globalization" #>
<#@ import namespace="System.Linq" #>
#region License and Terms
// MoreLINQ - Extensions to LINQ to Objects
// Copyright (c) 2010 Leopold Bushkin. 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

#nullable enable // required for auto-generated sources (see below why)

// > Older code generation strategies may not be nullable aware. Setting the
// > project-level nullable context to "enable" could result in many
// > warnings that a user is unable to fix. To support this scenario any syntax
// > tree that is determined to be generated will have its nullable state
// > implicitly set to "disable", regardless of the overall project state.
//
// Source: https://github.com/dotnet/roslyn/blob/70e158ba6c2c99bd3c3fc0754af0dbf82a6d353d/docs/features/nullable-reference-types.md#generated-code

namespace MoreLinq
{
    using System;
    using System.Collections.Generic;
    using Experimental;

    static partial class MoreEnumerable
    {<#
    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,
            OrdinalLower = a.Ordinal.ToLowerInvariant(),
            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,
            Arguments = args.Take(a.Count).ToList(),
            TypeParams = string.Join(", ", from aa in args.Take(a.Count) select $"T{aa.Number}")
        };

    foreach (var o in overloads)
    { #>

        /// <summary>
        /// Returns the Cartesian product of <#= o.Arity #> sequences by enumerating all
        /// possible combinations of one item from each sequence, and applying
        /// a user-defined projection to the items in a given combination.
        /// </summary>
<#      foreach (var arg in o.Arguments) { #>
        /// <typeparam name="T<#= arg.Number #>">
        /// The type of the elements of <paramref name="<#= arg.OrdinalLower #>"/>.</typeparam>
<#      } #>
        /// <typeparam name="TResult">
        /// The type of the elements of the result sequence.</typeparam>
<#      foreach (var arg in o.Arguments) {#>
        /// <param name="<#= arg.OrdinalLower #>">The <#= arg.OrdinalLower #> sequence of elements.</param>
<#      } #>
        /// <param name="resultSelector">A projection function that combines
        /// elements from all of the sequences.</param>
        /// <returns>A sequence of elements returned by
        /// <paramref name="resultSelector"/>.</returns>
        /// <remarks>
        /// <para>
        /// The method returns items in the same order as a nested foreach
        /// loop, but all sequences except for <paramref name="first"/> are
        /// cached when iterated over. The cache is then re-used for any
        /// subsequent iterations.</para>
        /// <para>
        /// This method uses deferred execution and stream its results.</para>
        /// </remarks>

        public static IEnumerable<TResult> Cartesian<<#= o.TypeParams #>, TResult>(
            this <#
        foreach (var arg in o.Arguments) { #>
IEnumerable<T<#= arg.Number #>> <#= arg.OrdinalLower #>,
            <#
        } #>
Func<<#= o.TypeParams #>, TResult> resultSelector)
        {
<#      foreach (var arg in o.Arguments) { #>
            if (<#= arg.OrdinalLower #> == null) throw new ArgumentNullException(nameof(<#= arg.OrdinalLower #>));
<#      } #>
            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));

            return _(); IEnumerable<TResult> _()
            {
<#      foreach (var arg in o.Arguments.Skip(1)) { #>
                IEnumerable<T<#= arg.Number #>> <#= arg.OrdinalLower #>Memo;
<#      } #>

<#      foreach (var arg in o.Arguments.Skip(1)) { #>
                using ((<#= arg.OrdinalLower #>Memo = <#= arg.OrdinalLower #>.Memoize()) as IDisposable)
<#      } #>
                {
                    foreach (var item1 in first)
<#      foreach (var arg in o.Arguments.Skip(1)) { #>
                    foreach (var item<#= arg.Number #> in <#= arg.OrdinalLower #>Memo)
<#      } #>
                        yield return resultSelector(<#= string.Join(", ", from x in o.Arguments select "item" + x.Number) #>);
                }
            }
        }

        /// <summary>
        /// Returns the Cartesian product of <#= o.Arity #> sequences by enumerating tuples
        /// of all possible combinations of one item from each sequence.
        /// </summary>
<#      foreach (var arg in o.Arguments) { #>
        /// <typeparam name="T<#= arg.Number #>">The type of the elements of <paramref name="<#= arg.OrdinalLower #>"/>.</typeparam>
<#      } #>
<#      foreach (var arg in o.Arguments) {#>
        /// <param name="<#= arg.OrdinalLower #>">The <#= arg.OrdinalLower #> sequence of elements.</param>
<#      } #>
        /// <returns>A sequence of tuples.</returns>
        /// <remarks>
        /// <para>
        /// The method returns items in the same order as a nested foreach
        /// loop, but all sequences except for <paramref name="first"/> are
        /// cached when iterated over. The cache is then re-used for any
        /// subsequent iterations.</para>
        /// <para>
        /// This method uses deferred execution and stream its results.</para>
        /// </remarks>

        public static IEnumerable<(<#= string.Join(", ", from a in o.Arguments select $"T{a.Number} {a.Ordinal}") #>)>
            Cartesian<<#= o.TypeParams #>>(
                this <#= string.Join($",{Environment.NewLine}                ",
                                     from arg in o.Arguments
                                     select $"IEnumerable<T{arg.Number}> {arg.OrdinalLower}") #>)
        {
            return Cartesian(<#= string.Join(", ", from a in o.Arguments select a.OrdinalLower) #>, ValueTuple.Create);
        }
<#  } #>
    }
}