I love the C# language. It’s clear, yet succinct. I do most of my work in it. That said, there have always been a few “nagging” things that I think would improve the C# language. My number one request for C# vNext (C#6?) is a syntax for creating Tuples easily.

F# (more appropriately OCaml in this case – but I was first exposed to it in F#) has dedicated syntax for tuples. For example:

let foo = (1, 1)

That is a tuple, which in this case is a pair of Int32s. In this case, it becomes a System.Tuple<int,int>, and the types are inferred with type inference. Functions can take tuples as arguments, too. Here is a more complete example:

let foo = (1,1)
let add (a, b) = 
    a + b
let answer = add foo

C# would need to do the syntax a little differently, but I don’t think it is far fetched. The syntax for declaring a tuple could more-or-less stay the same. I don’t believe there is any construct in C#, other than a method invocation / declaration where commas are allowed between expressions immediately within a set of parenthesis. C#’s type inference also works a lot differently, so I would imagine you would have to specify the type of the tuple explicitly if it were a method argument. For example:

This is purely fictitious syntax. 

public static void Main(string[] args)
{
    var foo = (1, 1);
    var answer = Add(foo, "Performing add");
}

private static int Add((int a, int b), string message)
{
    Console.WriteLine(message);
    return a + b;
}

I’m no Anders, so I am sure there are problems associated with that, however I think the general idea would be very useful. How it would work with other C# features like optional parameters, generics, constraints, etc. I am not so sure.

This would be a very helpful syntax when you need to return more than one thing from a method, which you can’t do with an anonymous type. For example:

private static (int * int) GetAddends()
{
    return (1, 2);
}

Currently, I would either need to construct my own return type or use Tuple.Create(1, 2). Anonymous types can’t be returned unless they are with object, and lose all type information, or as a dynamic, which just feels a little weird.