EquiZip.sbntxt

{{~
	$arity = arity
	$ordinals = ordinals
	$cardinals = cardinals
~}}
namespace SuperLinq;

#nullable enable

public static partial class SuperEnumerable
{
	{{~ for $i in 2..4 ~}}
	/// <summary>
	/// <para>
	///	    Applies a specified function to the corresponding elements of second sequences, producing a sequence of the
	///     results.
	/// </para>
	/// <para>
	///	    The resulting sequence has the same length as the input sequences. If the input sequences are of different
	///     lengths, an exception is thrown.
	/// </para>
	/// </summary>
	/// <typeparam name = "TResult">
	///	    The type of the elements of the result sequence.
	/// </typeparam>
	/// <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>
	///	    This method uses deferred execution and stream its results.
	/// </remarks>
	/// <exception cref = "global::System.ArgumentNullException">
	///	    <paramref name = "resultSelector"/> or any of the input sequences is <see langword = "null"/>.
	/// </exception>
	/// <exception cref = "global::System.InvalidOperationException">
	///	    Any of the input sequences are shorter than the others.
	/// </exception>
	{{~ for $j in 1..$i ~}}
	/// <typeparam name = "T{{ $cardinals[$j] }}">
	///		The type of the elements of <paramref name = "{{ $ordinals[$j] }}" />.
	/// </typeparam>
	/// <param name = "{{ $ordinals[$j] }}">
	///		The {{ $ordinals[$j] }} sequence of elements.
	/// </param>
	{{~ end ~}}
	public static global::System.Collections.Generic.IEnumerable<TResult> EquiZip<{{ for $j in 1..$i }}T{{ $cardinals[$j] }}, {{ end }}TResult>(this 
		{{~ for $j in 1..$i ~}}
		global::System.Collections.Generic.IEnumerable<T{{ $cardinals[$j] }}> {{ $ordinals[$j] }},
		{{~ end ~}}
		global::System.Func<{{ for $j in 1..$i }}T{{ $cardinals[$j] }}, {{ end }}TResult> resultSelector
	)
	{
		{{~ for $j in 1..$i ~}}
		ArgumentNullException.ThrowIfNull({{ $ordinals[$j] }});
		{{~ end ~}}

		ArgumentNullException.ThrowIfNull(resultSelector);

		if (
			{{~ for $j in 1..$i ~}}
			{{ $ordinals[$j] }} is global::System.Collections.Generic.IList<T{{ $cardinals[$j] }}> list{{ $j }}{{ if !for.last }}&&{{ else }}){{ end }}
			{{~ end ~}}
		{
			return new EquiZipIterator<{{ for $j in 1..$i }}T{{ $cardinals[$j] }}, {{ end }}TResult>(
				{{~ for $j in 1..$i ~}}
				list{{ $j }},
				{{~ end ~}}
				resultSelector
			);
		}

		return Core(
			{{~ for $j in 1..$i ~}}
			{{ $ordinals[$j] }},
			{{~ end ~}}
			resultSelector
		);

		static global::System.Collections.Generic.IEnumerable<TResult> Core(
			{{~ for $j in 1..$i ~}}
			global::System.Collections.Generic.IEnumerable<T{{ $cardinals[$j] }}> {{ $ordinals[$j] }},
			{{~ end ~}}
			global::System.Func<{{ for $j in 1..$i }}T{{ $cardinals[$j] }}, {{ end }}TResult> resultSelector
		)
		{
			{{~ for $j in 1..$i ~}}
			using var e{{ $j }} = {{ $ordinals[$j] }}.GetEnumerator();
			{{~ end ~}}

			while (true)
			{
				if (!e1.MoveNext())
				{
					if (e2.MoveNext()
						{{~
							if $i >= 3
							for $j in 3..$i ~}}
						|| e{{$j}}.MoveNext()
						{{~ end
							end ~}}
					)
					{
						ThrowHelper.ThrowInvalidOperationException("First sequence too short.");
					}

					yield break;
				}

				{{~ for $j in 2..$i ~}}
				if (!e{{$j}}.MoveNext())
					ThrowHelper.ThrowInvalidOperationException(
						"{{ $cardinals[$j] }} sequence too short.");
				{{~ end ~}}

				yield return resultSelector(
					{{~ for $j in 1..$i ~}}
					e{{$j}}.Current{{ if !for.last }},{{ end }}
					{{~ end ~}}
				);
			}
		}
	}

	/// <summary>
	///	    Joins the corresponding elements of second sequences, producing a sequence of tuples containing them.
	/// </summary>
	/// <returns>
	///	    A sequence of <see cref="global::System.ValueTuple{ {{~ for $j in 1..$i ~}}T{{$j}}{{ if !for.last }},{{ end }}{{ end }} }" /> 
	///	    containing corresponding elements from each of the sequences.
	/// </returns>
	/// <remarks>
	///	    This method uses deferred execution and stream its results.
	/// </remarks>
	/// <exception cref = "global::System.ArgumentNullException">
	/// Any of the input sequences is null.
	///	    </exception>
	/// <exception cref = "global::System.InvalidOperationException">
	///	    Any of the input sequences are shorter than the others.
	/// </exception>
	{{~ for $j in 1..$i ~}}
	/// <typeparam name="T{{ $cardinals[$j] }}">
	///     The type of the elements of <paramref name="{{ $ordinals[$j] }}" />.
	/// </typeparam>
	/// <param name="{{ $ordinals[$j] }}">
	///     The {{ $ordinals[$j] }} sequence of elements.
	/// </param>
	{{~ end ~}}
	public static global::System.Collections.Generic.IEnumerable<({{~ for $j in 1..$i ~}}T{{ $cardinals[$j] }}{{ if !for.last }},{{ end }}{{ end }})> 
		EquiZip<{{~ for $j in 1..$i ~}}T{{ $cardinals[$j] }}{{ if !for.last }},{{ end }}{{ end }}>(this
			{{~ for $j in 1..$i ~}}
			global::System.Collections.Generic.IEnumerable<T{{ $cardinals[$j] }}> {{ $ordinals[$j] }}{{ if !for.last }},{{ end }}
			{{~ end ~}}
	) => EquiZip({{~ for $j in 1..$i ~}}{{ $ordinals[$j] }}, {{ end }}global::System.ValueTuple.Create);

	private sealed class EquiZipIterator<{{ for $j in 1..$i }}T{{ $j }}, {{ end }}TResult> : ListIterator<TResult>
	{
		{{~ for $j in 1..$i ~}}
		private readonly global::System.Collections.Generic.IList<T{{ $j }}> _list{{ $j }};
		{{~ end ~}}
		private readonly global::System.Func<{{ for $j in 1..$i }}T{{ $j }}, {{ end }}TResult> _resultSelector;
		
		public EquiZipIterator(
			{{~ for $j in 1..$i ~}}
			global::System.Collections.Generic.IList<T{{ $j }}> {{ $ordinals[$j] }},
			{{~ end ~}}
			global::System.Func<{{ for $j in 1..$i }}T{{ $j }}, {{ end }}TResult> resultSelector
		)
		{
			{{~ for $j in 1..$i ~}}
			_list{{ $j }} = {{ $ordinals[$j] }};
			{{~ end ~}}
			_resultSelector	= resultSelector;
		}

		public override int Count
		{
			get
			{
				var count = _list1.Count;

				{{~ for $j in 2..$i ~}}
				if (_list{{ $j }}.Count != count)
				{
					ThrowHelper.ThrowInvalidOperationException(
						(count < _list{{ $j }}.Count ? "First" : "{{ $cardinals[$j] }}") + " sequence too short.");
				}
				{{~ end ~}}

				return count;
			}
		}

		protected override IEnumerable<TResult> GetEnumerable()
		{
			var cnt = (uint)Count;
			for (var i = 0; i < cnt; i++)
			{
				yield return _resultSelector(
					{{~ for $j in 1..$i ~}}
					_list{{ $j }}[i]{{ if !for.last }}, {{ end }}
					{{~ end ~}}
				);
			}
		}

		protected override TResult ElementAt(int index)
		{
			ArgumentOutOfRangeException.ThrowIfNegative(index);
			ArgumentOutOfRangeException.ThrowIfGreaterThanOrEqual(index, Count);

			return _resultSelector(
				{{~ for $j in 1..$i ~}}
				_list{{ $j }}[index]{{ if !for.last }}, {{ end }}
				{{~ end ~}}
			);
		}
	}

	{{~ end ~}}
}