ValueTuple.Equals issue

I tried this code:

Dim t1 As (Double, Single) = (1.0R, 2.0F)
Dim t2 As (Integer, Integer) = (1, 2)
Console.WriteLine(t1 = t2)

But VB.NET says:

Operator '=' is not defined for types '(Double, Single)' and '(Integer, Integer)'.

The unusual thing is that C# accepts this:

(double, float) t1 = (1d, 2f);
(int, int) t2 = (1, 2);
Console.WriteLine(t1 == t2);

Why can't VB.NET compare the two tuples, while C# can?
Note that VB.NET has no problem in assigning one of the tuples to the other one:
t1 = t2

[reduckted]

Very interesting. For reference, here's the original C# code, the IL that it compiled to, and the C# that it decompiles to:

static void Main()
{
    (double, float) t1 = (1d, 2f);
    (int, int) t2 = (1, 2);
    Console.WriteLine(t1 == t2);
}

.method private hidebysig static 
    void Main () cil managed 
{
    // Method begins at RVA 0x2050
    // Code size 70 (0x46)
    .maxstack 3
    .entrypoint
    .locals init (
        [0] valuetype [System.Runtime]System.ValueTuple`2<float64, float32>,
        [1] valuetype [System.Runtime]System.ValueTuple`2<float64, float32>,
        [2] valuetype [System.Runtime]System.ValueTuple`2<int32, int32>
    )

    IL_0000: ldloca.s 0
    IL_0002: ldc.r8 1
    IL_000b: ldc.r4 2
    IL_0010: call instance void valuetype [System.Runtime]System.ValueTuple`2<float64, float32>::.ctor(!0, !1)
    IL_0015: ldc.i4.1
    IL_0016: ldc.i4.2
    IL_0017: newobj instance void valuetype [System.Runtime]System.ValueTuple`2<int32, int32>::.ctor(!0, !1)
    IL_001c: ldloc.0
    IL_001d: stloc.1
    IL_001e: stloc.2
    IL_001f: ldloc.1
    IL_0020: ldfld !0 valuetype [System.Runtime]System.ValueTuple`2<float64, float32>::Item1
    IL_0025: ldloc.2
    IL_0026: ldfld !0 valuetype [System.Runtime]System.ValueTuple`2<int32, int32>::Item1
    IL_002b: conv.r8
    IL_002c: bne.un.s IL_003f

    IL_002e: ldloc.1
    IL_002f: ldfld !1 valuetype [System.Runtime]System.ValueTuple`2<float64, float32>::Item2
    IL_0034: ldloc.2
    IL_0035: ldfld !1 valuetype [System.Runtime]System.ValueTuple`2<int32, int32>::Item2
    IL_003a: conv.r4
    IL_003b: ceq
    IL_003d: br.s IL_0040

    IL_003f: ldc.i4.0

    IL_0040: call void [System.Console]System.Console::WriteLine(bool)
    IL_0045: ret
} // end of method Program::Main

private static void Main()
{
    ValueTuple<double, float> valueTuple = new ValueTuple<double, float>(1.0, 2f);
    ValueTuple<int, int> valueTuple2 = new ValueTuple<int, int>(1, 2);
    ValueTuple<double, float> valueTuple3 = valueTuple;
    ValueTuple<int, int> valueTuple4 = valueTuple2;
    Console.WriteLine(valueTuple3.Item1 == (double)valueTuple4.Item1 && valueTuple3.Item2 == (float)valueTuple4.Item2);
}

Not really sure why it's copying the tuples before it compares them, but whatever. ¯\_(ツ)_/¯

Interestingly, you can use the .Equals() method in VB as a workaround for now, which actually seems to compile to what you'd kind of expect the = operator to compile to:

Sub Main()
    Dim t1 As (Double, Single) = (1.0R, 2.0F)
    Dim t2 As (Integer, Integer) = (1, 2)
    Console.WriteLine(t1.Equals(t2))
End Sub

.method public static 
    void Main () cil managed 
{
    .custom instance void [mscorlib]System.STAThreadAttribute::.ctor() = (
        01 00 00 00
    )
    // Method begins at RVA 0x2128
    // Code size 64 (0x40)
    .maxstack 3
    .entrypoint
    .locals init (
        [0] valuetype [mscorlib]System.ValueTuple`2<float64, float32>,
        [1] valuetype [mscorlib]System.ValueTuple`2<int32, int32>,
        [2] valuetype [mscorlib]System.ValueTuple`2<int32, int32>
    )

    IL_0000: ldloca.s 0
    IL_0002: ldc.r8 1
    IL_000b: ldc.r4 2
    IL_0010: call instance void valuetype [mscorlib]System.ValueTuple`2<float64, float32>::.ctor(!0, !1)
    IL_0015: ldloca.s 1
    IL_0017: ldc.i4.1
    IL_0018: ldc.i4.2
    IL_0019: call instance void valuetype [mscorlib]System.ValueTuple`2<int32, int32>::.ctor(!0, !1)
    IL_001e: ldloca.s 0
    IL_0020: ldloc.1
    IL_0021: stloc.2
    IL_0022: ldloc.2
    IL_0023: ldfld !0 valuetype [mscorlib]System.ValueTuple`2<int32, int32>::Item1
    IL_0028: conv.r8
    IL_0029: ldloc.2
    IL_002a: ldfld !1 valuetype [mscorlib]System.ValueTuple`2<int32, int32>::Item2
    IL_002f: conv.r4
    IL_0030: newobj instance void valuetype [mscorlib]System.ValueTuple`2<float64, float32>::.ctor(!0, !1)
    IL_0035: call instance bool valuetype [mscorlib]System.ValueTuple`2<float64, float32>::Equals(valuetype [mscorlib]System.ValueTuple`2<!0, !1>)
    IL_003a: call void [mscorlib]System.Console::WriteLine(bool)
    IL_003f: ret
} // end of method Module1::Main

And for completeness, here's the C# code that the VB code decompiles to:

[STAThread]
public static void Main()
{
    ValueTuple<double, float> valueTuple = new ValueTuple<double, float>(1.0, 2f);
    ValueTuple<int, int> valueTuple2 = new ValueTuple<int, int>(1, 2);
    ValueTuple<int, int> valueTuple3 = valueTuple2;
    Console.WriteLine(valueTuple.Equals(new ValueTuple<double, float>((double)valueTuple3.Item1, (float)valueTuple3.Item2)));
}

@reduckted
Thanks for the info. I am aware that equals work fine.
I don't think it is a problem in compiling code to IL code, because = operator uses Equals method internally. I think that VB.NET sees two deffirent types of tuples and has no rule to convert between them, so it can't find a suitable = operator to use. This is wrong, becuase = operator should be safely used betwwen any two tuples, even they differ in length and element types (it can return false). This is the first time I see C# smarter than VB.NET!
I think the overload = operator should be defined in ValueTuple class, and VB.NET should accept it between any two tuples.

[reduckted]

@MohammadHamdyGhanem I don't think it is a problem in compiling code to IL code, because = operator uses Equals method internally.

The = operator only works if it's been defined on the type. It doesn't get automatically converted into the .Equals() method. For example, if we use the old-style Tuple(Of T1, T2) class, you get the same error when you try to use the = operator.

Dim t As Tuple(Of Double, Single)
Console.WriteLine(t = t)
                  ~~~~~ ' Operator '=' is not defined for types 'Tuple(Of Double, Single)' and 'Tuple(Of Double, Single)'.

In fact, take your original code, and compare t1 with itself and it still doesn't work.

Dim t1 As (Double, Single) = (1.0R, 2.0F)
Console.WriteLine(t1 = t1)
                  ~~~~~~~ ' Operator '=' is not defined for types '(Double, Single)' and '(Double, Single)'.

So the issue isn't that you can't compare different types of ValueTuple with the = operator - it's that you can't compare ValueTuple with the = operator at all!

Perhaps someone with more knowledge of the compiler could explain how it handles ValueTuple internally. I assume it does some sort of special handling. I've looked through dotnet/roslyn#347, but like so many roslyn issues, it was just magically implemented and closed without any documentation or a referenced PR. 😢

[Berrysoft]

The comparison of ValueTuple with the == and != operators is a new feature in C# 7.3, but not in Visual Basic.

[Nukepayload2]

I think we can't copy c#'s implementation of this feature to VB directly. Because the equality and the inequality compare operators are special in VB. For example, Nothing = String.Empty is True in VB, but null == string.Empty is false in C#.

[Nukepayload2]

@reduckted The Operator = can't be defined in the ValueTuple itself. They should be handled by compilers, because each programming languages have different rules of comparison. The following codes shows the difference between the expected VB equality behavior and the existing C# behavior.

VB

' Compile with /optioncompare:text
Dim a As (Object, String) = (Nothing, "ABC")
Dim b As (String, String) = ("", "aBc")
MsgBox(a = b) ' The output should be True. Because a.GetType.GenericTypeArguments.Length = b.GetType.GenericTypeArguments.Length AndAlso Nothing = "" AndAlso "ABC" = "aBc".

C#

(Object, String) a = (null, "ABC");
(String, String) b = ("", "ABC");
Console.WriteLine(a == b); // The output should be False. Because !a.GetType().Equals(b.GetType()) .

@reduckted @Berrysoft @Nukepayload2
Thanks, I got it. Is this issue going to be solved?

[Nukepayload2]

I've found a related LDM note. https://github.com/dotnet/vblang/blob/master/meetings/2018/vbldm-notes-2018.02.28.md

@reduckted @Berrysoft @Nukepayload2 @srivatsn @migueldeicaza
The issue of comparing empty string and null string can be solved in another way: Any null string should be implicitly converted to empty string. This will eliminate the need for extra work in = operator.
VB.NET programmers treat null string and empty string equally, so I think this will not break anything.

[Nukepayload2]

The extra work in Operator = can't be eliminated in this way, because Option Compare Text should be implemented as well. String equality and inequality operators should be replaced with Operators.CompareString by the compiler.

@Nukepayload2
OK. There is something I can't get: ValueTuple.= should just call ValueTuple.Equals which already works fine! I see no problem!
Besides: Whatever rules VB.NEt uses, the already implemented in each type.=, and ValueTuple.= eventually is a sum of checking for element types eauality. If two elements T1.Item1 and t2.Item1. are string, so (T1 = T2) code will contain T1.Item1 = T2.Item1 part, which will use VB.NET rules of compairing strings.
I don't really see any problem!

[Nukepayload2]

@MohammadHamdyGhanem
ValueTuple.Equals does not have parameters to pass Option Strict and Option Compare, so it can't be used as the equality operator.
You can compile and run the following program, and decompile it to learn the differences between Equals and the equality operator.

Option Strict Off
Option Compare Text
Module Program
    Sub Main(args As String())
        Dim a = (1, "ABC", Nothing)
        Dim b = ("1", "abc", "")
        Dim tupleEquals = a.Equals(b)
        Dim vbEquality = a.Item1 = b.Item1 AndAlso a.Item2 = b.Item2 AndAlso a.Item3 = b.Item3
        Console.WriteLine(tupleEquals)
        Console.WriteLine(vbEquality)
    End Sub
End Module

Decompiled:

Imports Microsoft.VisualBasic.CompilerServices
Imports System.Runtime.CompilerServices
Friend Module Program
    <STAThread>
    Public Sub Main(args As String())
        Dim valueTuple As ValueTuple(Of Integer, String, Object) = New ValueTuple(Of Integer, String, Object)(1, "ABC", Nothing)
        Dim valueTuple1 As ValueTuple(Of String, String, String) = New ValueTuple(Of String, String, String)("1", "abc", "")
        Dim flag As Boolean = valueTuple.Equals(valueTuple1)
        Dim obj As Object = If(CDbl(valueTuple.Item1) <> Conversions.ToDouble(valueTuple1.Item1) OrElse EmbeddedOperators.CompareString(valueTuple.Item2, valueTuple1.Item2, True) <> 0, False, Conversions.ToBoolean(Operators.CompareObjectEqual(valueTuple.Item3, valueTuple1.Item3, True)))
        Console.WriteLine(flag)
        Console.WriteLine(RuntimeHelpers.GetObjectValue(obj))
    End Sub
End Module

[KathleenDollard]

Tuple equality was not initially added for value tuples, because there are some gnarly corners. Check out the Support for == and != for ValueTuple. I recall gnarly corners, but the resulting proposal is rather clean.

I'd love to see us work together on a proposal that makes sense to Visual Basic.

Note: it does need to be strict in the language sense - Visual Basic programmers often don't care about the difference between an empty string and null, but the language must. And how to handle Option Binary/Text, Option Explicit and Option Strict.

[KathleenDollard]

@MohammadHamdyGhanem

Equals can be overridden on a type to return a different value than the equals operator. It's certainly a bad idea, but the language still needs to handle it correctly.

In this case, it would be weird for the = operator on a tuple to follow Equals, and not =. That's why C# chose to recursively compare each item with the == operator.

It could be that VB just needs identical rules with extra paragraphs for the Option cases. I believe that the less subtle differences with C# the better.

@reduckted @Berrysoft @Nukepayload2 @KathleenDollard @srivatsn
I wrote this:

    Function AreEqual(T1 As ITuple, T2 As ITuple) As Boolean
        If T1.Length <> T2.Length Then Return False
        For i = 0 To T1.Length - 1
            If T1(i) <> T2(i) Then Return False
        Next
        Return True
    End Function

And used it like this:

Dim T1 = (2, 1.3, "")
Dim T2 = (2, 1.3, Nothing)
Console.WriteLine(AreEqual(T1, T2)) ' True
Console.WriteLine(T1.Equals(T2)) ' False

As I said: I see no problem at all. We need to do nothing more. We just compare each pair with = operator or <> operator, and VB.NET will apply all its roles!
You can usr the AreEqual function to implement the = operator for ValueTuples.
Thanks.