Cannot apply == to ValueTuple<T> (one item ValueTuple)

[RyanLiu99]

Compile following code:


var tx = ValueTuple.Create("A1");
var ty = ValueTuple.Create("A1");
Console.WriteLine(tx == ty);


The last line will give compile error: 
Error CS0019  Operator '==' cannot be applied to operands of type 'ValueTuple<string>' and 'ValueTuple<string>' 
-----------
Similarly

            var t1 = ValueTuple.Create(1);
            var t2 = ValueTuple.Create(1);
            Assert.IsTrue(t1 == t2);  // won't compile

CS0019	Operator '==' cannot be applied to operands of type 'ValueTuple<int>' and 'ValueTuple<int>'	


This seems to me a language bug. 
=============
If it is 2 items ValueTuple, it works without any problem.  For example:


 var t1 = ValueTuple.Create("A1", "A1");
 var t2 = ValueTuple.Create("A1", "A1");
 Assert.IsTrue(t1 == t2);  // right

or

            var t1 = ("A1", 1);
            var t2 = ValueTuple.Create(t1.Item1,1);
            Assert.IsTrue(t1 == t2);   //right

[huoyaoyuan]

In metadata definition, both ValueTuple types don't implement the == operator, because it's not expressible in C# and IL for generic types.
For ValueTuple<T1, T2>, it's recognized as the tuple type (T1, T2), and the operator is synthesized by the compiler.
Although ValueTuple<T1> is somehow well-known by the compiler, there's no unary-tuple feature, so it is not treated as a tuple tupe and the compiler does not synthesize an operator for it.

This is a feature gap but not a bug.

[RyanLiu99]

Thanks Huoyaoyuan. In that case, if the compiler is not going to support unary-tuple feature, IMHO, rather there is NO ValueTuple<T> struct in the first place, so be consistent.

[theunrepentantgeek]

What do you mean? What are you trying to say? Your statement is ambiguous.

Are you saying that the runtime library shouldn't have ValueTuple at all?
ValueType type is the foundation of tuple support in the compiler, if we didn't have it, we wouldn't have allocation free tuples. Removing it would be a breaking change.

Or are you saying that the code shouldn't use ValueTuple?
But you wrote that code in the first place, wrapping single items in ValueTuple. The compiler doesn't do that - and, trivially, "A1" == "A1" works just fine.

Are you saying that the generic version of ValueTuple that takes exactly one parameter shouldn't exist?
That's arguable - but the way it is, the type is consistent with other generic types that take a variable arity of type parameters. And, removing it would be a breaking change.

[RyanLiu99]

theunrepentantg, right, I mean the 2nd option in your answer. 
I mean only provide ValueTuple<T1,T2>, ValueTuple<T1,T2, T3> ...etc  Struct, start with 2 Items.  
Do not define ValueTuple<T1> struct at all since it is not going to full support  unary tuple. 

It might to late to drop it.  But it is not too late to support  unary tuple even usually won't be that much useful, 
but IMO, nice to be consistent.  

BTW, formatter hided <T> so  ValueTuple<T> looks like  ValueTuple so it made my earlier post looks "ambiguous". 
I went back fixed that.

[HaloFour]

The BCL types are handled by a different team, that seemingly thought that tuple arities of 0 and 1 were worth including even if the C# language did not offer additional support for them, yet. That doesn't preclude that C# might support them in the future either.

[CyrusNajmabadi]

ValueTuple<T> is used in the encoding of larger tuples. For example, var v = (1, 2, 3, 4, 5, 6, 7, 8); is encoded as the type: ValueTuple`8<int32, int32, int32, int32, int32, int32, int32, ValueTuple`1<int32>>

[CyrusNajmabadi]

As mentioned, this is by design. The language has no concept of a unary tuple. So there's no synthesized == operator for a type the language doesn't care about.

[colejohnson66]

Why does the operator even need to be synthesized? Why not just have all ValueTuple types explicitly implement them? They already implement half a dozen other functions one-by-one.

I get that this is a BCL question, but the synthesis is a language one.

[CyrusNajmabadi]

Why does the operator even need to be synthesized?

To get the desired semantics, which are specific to the use site context the tuple is in, and cannot be described at the declaration point of the tuple.

Why not just have all ValueTuple types explicitly implement them?

It cannot. Consider how they are defined:

public struct ValueTuple<T1, T2>
{
    public T1 Item1;
    public T2 Item2;

    public static bool operator==(ValueTuple<T1, T2> t1, ValueTuple<T1, T2> t2)
    {
        // How would you implement this?
    }
}

In that body you can't do t1.Item1 == t2.Item2 (as type parameters don't support == either). And you don't want to emit .Equals in any way (as .Equals can have separate semantics from == (like with System.Double for example)).

Then consider something like:

Here the types of the tuples are entirely different. So how would you even try to write the operator== in source?