Proposal: New Zip LINQ Tuple Overload API

[jcouv]

(By @agocke) Rewriting this issue to focus on exactly one API:

class System.Linq.Enumerable
{
    public static IEnumerable<(T1, T2)> Zip<T1, T2>(this IEnumerable<T1> first, IEnumerable<T2> second)
    {
        return first.Zip(second, (x, y) => (x, y));
    }
    // Already EXISTS:
    public static IEnumerable<TResult> Zip<TFirst, TSecond, TResult>(this IEnumerable<TFirst> first, IEnumerable<TSecond> second, Func<TFirst, TSecond, TResult> resultSelector);
}

There will also be a matching IQueryable API:

class System.Linq.Queryable
{
    public static IQueryable<(T1, T2)> Zip<T1, T2>(this IQueryable<T1 first, IQueryable<T2> second);
    // Already EXISTS:
    public static IQueryable<TResult> Zip<TFirst, TSecond, TResult>(this IQueryable<TFirst> source1, IEnumerable<TSecond> source2, Expression<Func<TFirst, TSecond, TResult>> resultSelector);
}

[EDIT] Add class names and existing Zip method for context by @karelz

[svick]

How would Unzip work when it comes to laziness? Would it be similar to GroupBy, which I belive iterates the whole input before yielding the first result? Or something more lazy, where iterating first would iterate input at the same time, while saving second results to a queue (and vice versa)?

Also, considering that with this change, there would be tuple and non-tuple Zip, but only tuple Unzip, would it make sense to also add "non-tuple" Unzip? The API would be:

(IEnumerable<T1> first, IEnumerable<T2> second) Unzip<TInput, T1, T2>(this IEnumerable<TInput> input, Func<TInput, (T1, T2)> selector)

(It does use tuple, but only for multiple returns, not for the collection itself.)

[karelz]

@jcouv please check our issue guide for assigning issues. And API review process.

[VSadov]

CC:@agocke

[cartermp]

Related info:

• Seq.zip functions in FSharp.Core: https://github.com/Microsoft/visualfsharp/blob/master/src/fsharp/FSharp.Core/seq.fs#L626

• List.zip functions: https://github.com/Microsoft/visualfsharp/blob/44fa027b308681a1b78a089e44fa1ab35ff77b41/src/fsharp/FSharp.Core/local.fs#L851

• List.unzip functions: https://github.com/Microsoft/visualfsharp/blob/44fa027b308681a1b78a089e44fa1ab35ff77b41/src/fsharp/FSharp.Core/local.fs#L724

• Array.zip functions: https://github.com/Microsoft/visualfsharp/blob/master/src/fsharp/FSharp.Core/array.fs#L816

• Array.unzip functions: https://github.com/Microsoft/visualfsharp/blob/master/src/fsharp/FSharp.Core/array.fs#L863

Note that we do not offer Seq.unzip functionality, which would be the the analogue to IEnumerable.Unzip. This is because we would need to drop laziness to accomplish the task, thus breaking one of the assumptions people have about working with F# sequences (which are just type aliases for IEnumerable<T>.

[agocke]

I've create a PR (dotnet/corefx#26582) that adds the Zip functionality described in the issue.

One thing that I'm considering but haven't decided upon: would it be OK to return a concrete struct-iterator type instead of IEnumerable? It seems like forcing the IEnumerable overhead is something that many users would prefer not to do.

[agocke]

Note: I have not implemented Unzip. I don't think that API is nearly as useful and I'd prefer to decide on the new Zip API without it.

[agocke]

@VSadov and @OmarTawfik you're listed as experts for System.Linq. What would you like me to do here? Just publish a PR? The Zip API from above is still accurate.

[OmarTawfik]

@agocke we will need to prepare the API proposal first:
guide: https://github.com/dotnet/corefx/blob/master/Documentation/project-docs/api-review-process.md
example: https://github.com/dotnet/corefx/issues/14220
Then it will go through a design review, and after approval, you can submit the PR for normal code review process.

[svick]

@agocke

would it be OK to return a concrete struct-iterator type instead of IEnumerable? It seems like forcing the IEnumerable overhead is something that many users would prefer not to do.

For better or worse, returning IEnumerable<T> is the pattern LINQ uses. What makes Zip special? Why should it be different?

[agocke]

@karelz I think this is ready for review. I want to add exactly one IEnumerable API: the overload of Zip`2 that returns an IEnumerable of 2-tuples.

[karelz]

@agocke please get agreement with @VSadov @OmarTawfik first - they should mark it ready for review.

[OmarTawfik]

@karelz I think this is ready to be reviewed next week.