Allow names of tuple values in method return type to be based on input tuple value names

[ymassad]

If we have the following code:

static void Main(string[] args)
{
    (int x, int y) tuple = (1, 2);

    var result = Increment(tuple);
}

static (int a, int b) Increment((int a, int b) input)
{
    return (input.a + 1, input.b + 1);
}

, then the type of the result variable will be (int a, int b). What I would like to do is change the Increment method in a way that the result variable will be of type (int x, int y) (based on the names in the input tuple).

I know that these types are actually the same as far as the CLR is concerned. What I am asking here is related to C#, not the CLR.

Basically, I should be able to do something like this:

static (int [a], int [b]) Increment((int [a], int [b]) input)
{
    return (input.a + 1, input.b + 1);
}

Here I am surrounding the tuple value names with square brackets (this is probably bad syntax, I am just showing an example), to say that the name of the first value of the tuple in the return type should be the same name of the tuple value in the input parameter. And the same for the second tuple value.

I think that basically this can be done by creating something similar to TupleElementNamesAttribute that can map indexes of tuple values in the output to indexes of tuple values in the input. Or maybe TupleElementNamesAttribute can be used here and a special prefix can be used to distinguish simple named tuple values from indexed ones. For example, "$3" means that this tuple value should be named based on the third tuple value in the input. This is possible because "$3" is an invalid parameter name (or is it a valid one on the CLR level)?

[DavidArno]

Related: #829, #853 and #894.

[jnm2]

I like this, but I'm worried about people using it "just in case" and contributing to situations like this:

var fooTask = FooAsync();
var barTask = bar.DoAsync();
// ...
var x = await (fooTask, barTask);

// Foo result is called x.fooTask, bar result is called x.barTask

Or:

var x = await DownloadStringsAsync((fooUrl, barUrl));

// String results are called x.fooUrl and x.barUrl

[ymassad]

@jnm2 , I am not sure I understand the first example. Can a tuple be awaited? Is this an upcoming C# feature?

Regarding the second example, do you mean that people would write a method like this?

public static async Task<(string [x1], string [x2])> DownloadStringsAsync((string [x1], string [x2]) input)
{
//...
}

[jnm2]

@ymassad To make something awaitable, all you have to do is define a GetAwaiter extension method returning an awaiter-shaped type. https://github.com/dotnet/corefx/issues/16010 tracks adding it to the BCL, and @buvinghausen has very kindly provided a NuGet package in the meantime.

Yes, I'd be afraid people would be asked to do that when writing methods like that.

[ymassad]

@jnm2, I see your point. But I think that any feature can be also abused. One way to mitigate this is to enable something like this:

public static async Task<(string resultFor[x1], string resultFor[x2])> DownloadStringsAsync(
    (string [x1], string [x2]) input)
{
//...
}

What this means is that the name of the value in the output tuple can contain both a static part and another part that comes from the name of the values from the input tuples.

[HaloFour]

This seems like a fairly complicated language feature for something that is unlikely to be that common. The tuple element names for any input values are not related to the tuple element names for any output values and there are so many edge cases here that I don't think it's worth it.

[ymassad]

@HaloFour, I think that the scenarios where it would be used are for methods that would "modify" the input value. So basically, the output would be a modified version of the input. In this case, one would like to have the names in the modified input be the same names from the input.

One concrete example is partial invocation. A method called PartiallyInvoke would take in a function whose input is a tuple of size n and return a function whose input is a tuple of size n - 1. In this case, it is desirable to have the names of the tuple values untouched in the returned function.

[ymassad]

This is the code for the example I talked about in the previous comment:

public static IFunction<(TInput2 input2, TInput3 input3), TOutput> PartiallyInvoke1<TInput1, TInput2, TInput3, TOutput>(
    this IFunction<(TInput1 input1, TInput2 input2, TInput3 input3), TOutput> function,
    TInput1 value)
{
    return new PartiallyInvoke1In3<TInput1, TInput2, TInput3, TOutput>(function, value);
}