More arities for tuple returning zip extension method

[Logerfo]

Background and Motivation

#43687 (comment)

Proposed API

namespace System.Linq
{
    public static class Enumerable
    {
+       public static IEnumerable<(TFirst First, TSecond Second, TThird Third)> Zip<TFirst, TSecond, TThird>(this IEnumerable<TFirst> first, IEnumerable<TSecond> second, IEnumerable<TThird> third);
    }

    public static class Queryable
    {
+       public static IQueryable<(TFirst First, TSecond Second, TThird Third)> Zip<TFirst, TSecond, TThird>(this IQueryable<TFirst> source1, IEnumerable<TSecond> source2, IEnumerable<TThird> source3);
    }
}

Usage Examples

foreach(var (a, b, c) in first.Zip(second, third))
{
   //...
}

Alternative Designs

public static IEnumerator<(T1, T2, T3)> GetEnumerator<T1, T2, T3>(this (IEnumerable<T1> a, IEnumerable<T2> b, IEnumerable<T3> c) pair)
    => pair.a.Zip(pair.b, (a, b) => (a, b)).Zip(pair.c, (a, c) => (a.a, a.b, c)).GetEnumerator();

foreach(var (a, b, c) in (collectionA, collectionB, collectionC)) 
{
	// This block will execute only while both `a`, `b` and `c` continue to yield values

	// Code goes here
}

[ghost]

Tagging subscribers to this area: @eiriktsarpalis, @jeffhandley
See info in area-owners.md if you want to be subscribed.

[eiriktsarpalis]

Proposal looks good to me. To be determined: what is the maximum arity we are willing to support?

[eiriktsarpalis]

Note that we would also need to include the reducing selecting overloads:

namespace System.Linq
{
    public static class Enumerable
    {
        public static IEnumerable<TResult> Zip<TFirst, TSecond, TThird, TResult>(this IEnumerable<TFirst> first, IEnumerable<TSecond> second, IEnumerable<TThird> third, Func<TFirst, TSecond, TThird, TResult> resultSelector);
        public static IEnumerable<TResult> Zip<TFirst, TSecond, TThird, TFourth, TResult>(this IEnumerable<TFirst> first, IEnumerable<TSecond> second, IEnumerable<TThird> third, IEnumerable<TFourth> fourth, Func<TFirst, TSecond, TThird, TFourth, TResult> resultSelector);
        ...
    }
}

as well as the IQueryable variants:

namespace System.Linq
{
    public static class Queryable
    {
        public static IQueryable<(TFirst First, TSecond Second, TThird Third)> Zip<TFirst, TSecond, TThird>(this IQueryable<TFirst> source1, IEnumerable<TSecond> source2, IEnumerable<TThird> source3);
        public static IQueryable<(TFirst First, TSecond Second, TThird Third, TFourth Fourth)> Zip<TFirst, TSecond, TThird, TFourth>(this IQueryable<TFirst> source1, IEnumerable<TSecond> source2, IEnumerable<TThird> source3, IEnumerable<TFourth> source4);
        ...

        public static IQueryable<TResult> Zip<TFirst, TSecond, TThird, TResult>(this IQueryable<TFirst> first, IEnumerable<TSecond> second, IEnumerable<TThird> third, Expression<Func<TFirst, TSecond, TThird, TResult>> resultSelector);
        public static IQueryable<TResult> Zip<TFirst, TSecond, TThird, TFourth, TResult>(this IQueryable<TFirst> first, IEnumerable<TSecond> second, IEnumerable<TThird> third, IEnumerable<TFourth> fourth, Expression<Func<TFirst, TSecond, TThird, TFourth, TResult>> resultSelector);
        ...
    }
}

@Logerfo would you be able to update your proposal?

[Logerfo]

@eiriktsarpalis
I think that a good starting point on the maximum arity is the System.Tuple arities. It goes up to 7 type arguments until it starts nesting the tuples.
I have updated the proposal to contain the method groups you pointed out.
Thanks.

[svick]

I'm not against this proposal, but I'm not sure how much value it adds, since you can do the following today:

foreach (var ((a, b), c) in first.Zip(second).Zip(third))

[Logerfo]

@svick it adds value on legibility and succinctness and it grows with the arity:

foreach (var ((((((a, b), c), d), e), f), g) in first.Zip(second).Zip(third).Zip(fourth).Zip(fifth).Zip(sixth).Zip(seventh))
foreach (var (a, b, c, d, e, f, g) in first.Zip(second, third, fourth, fifth, sixth, seventh))

[terrajobst]

Video

• Let's support only three for now as four seems fairly rare.
• We decided to not add an overload for the one taking the result selector.

namespace System.Linq
{
    public static class Enumerable
    {
        public static IEnumerable<(TFirst First, TSecond Second, TThird Third)> Zip<TFirst, TSecond, TThird>(this IEnumerable<TFirst> first, IEnumerable<TSecond> second, IEnumerable<TThird> third);
    }

    public static class Queryable
    {
        public static IQueryable<(TFirst First, TSecond Second, TThird Third)> Zip<TFirst, TSecond, TThird>(this IQueryable<TFirst> source1, IEnumerable<TSecond> source2, IEnumerable<TThird> source3);
    }
}

[GSPP]

I think that's a great decision. Zip itself is a fairly rare operation and zipping many sequences becomes rarer as the number grows.

I also find the workaround var ((((((a, b), c), d), e), f), g) to be rather clear. That seems very practical.

[eiriktsarpalis]

@terrajobst your post still contains the resultSelector overloads. I've removed them to reflect the api review decision.

[Logerfo]

OP updated.