Tuple and extension methods

[alrz]

using System;
using System.Linq;
using System.Collections.Generic;
static class C
{
    static IEnumerable<(T, U)> AsEnumerable<T, U>(
        this (IEnumerable<T> xs, IEnumerable<U> ys) source)
	=> source.xs.Zip(source.ys, (x, y) => (x, y));

    static void Main()
    {
        foreach(var (x, y) in AsEnumerable((new int[1], new byte[2]))) // OK
        {          
        }      

        foreach(var (x, y) in (new int[1], new byte[2]).AsEnumerable()) // ERROR; needs cast
        {    
        }  
    }   
}

In fact, an extension GetEnumerator should be sufficient without the explicit call.

[jnm2]

Aside: AsEnumerable means something else; I'd definitely call that extension method Zip.

[alrz]

@jnm2 Thas is just an example, As I said this should be possible with a GetEnumerator extension method,

foreach(var (x, y) in (new int[1], new byte[2])) { }

[jnm2]

@alrz I see what you're doing there, but I'd call it GetEnumerator if it was going to return IEnumerator<(T, U)> and Zip if it was going to return IEnumerable<(T, U)>.

[gafter]

This does not work because an extension method is only applicable when "An implicit identity, reference or boxing conversion exists from expr to the type of the first parameter of [the method]." In this case none of those conversions are applicable; it requires an implicit tuple conversion. This is therefore a decision that required an explicit change from the LDM.

@dotnet/ldm Do you want to make a change here to the interaction of tuples with extension methods? If so, it is now or never.

[HaloFour]

What are the scenarios under which this doesn't currently work? I was toying with a joining extension method for ValueTuple<Task<T1>, Task<T2>> and it seemed to compile just fine (using Dec 14th build on tryroslyn)

public static class TaskJoinExtensions {
    public static TaskAwaiter<(T1, T2)> GetAwaiter<T1, T2>(this (Task<T1>, Task<T2>) tasks) {
        // join implementation here
    }
}
// later

var (result1, result2) = await (task1, task2);

[alrz]

@HaloFour Because what GetAwaiter accepts and (task1, task2) type both are (Task<T1>, Task<T2>). In the case above we are upcasting T[] to IEnumerable<T>. that's where it breaks. i.e. if you cast arrays to IEnumerable<T> or change the extension method to accept arrays, it compiles just as expected.

[HaloFour]

@alrz

Oh, I see. You're relying on variance/coercion of the generic type parameters of the tuple. Messy, but I agree that it would be useful.

[alrz]

While changing the types would satisfy the compiler,

public static IEnumerable<(T, U)> AsEnumerable<T, U>(
  this (T[] xs, U[] ys) source)
  => source.xs.Zip(source.ys, (x, y) => (x, y));

foreach(var (x, y) in (new int[1], new byte[2]).AsEnumerable()) // OK

It still doesn't find GetEnumerator method,

public static IEnumerator<(T, U)> GetEnumerator<T, U>(
  this (T[] xs, U[] ys) source)
  => source.xs.Zip(source.ys, (x, y) => (x, y)).GetEnumerator();

foreach(var (x, y) in (new int[1], new byte[2])) // ERROR

Am I missing something?

[gafter]

@alrz That should work. But it is a separate issue from the OP (which is a language design feature request). I'll file a bug report.

[EDIT 2017-01-03] Checking the C# language spec, I see that extension methods are not specified to work for foreach loops.