Dictionary equality question/problem

I wouldn't use toString for checking things. It's nice that it seems that it prints the keys sorted, but it might change between devices, between compiler versions, who knows.

Regarding Object.equals(): the documentation isn't very clear and even the given example is not very useful. Maybe they meant to say it's checking references? Not sure.

If you really need this to work and robust then you'll need to write your own comparsion (you'll know if it needs to be recursive, how deep it can be, etc)

toString() method doesn't work all the time. I was mentioning it as a curiosity. 

I believe it would be good to rely on the SDK/language for basic (native) operations as object comparison.

Writing code for such trivial tasks shouldn't be required.

I may be biased, hence the question here...

Do you need to know the differences, or just if they are different? There is a hashCode function that you could use to do a simple equality test. If you need to know the differences, then like it's been said you'll need to do that yourself.

Again, let's take a look a the docs (https://developer.garmin.com/connect-iq/api-docs/Toybox/Lang/Object.html#hashCode-instance_function):

If the documentation is right (and we understand "objects are equal" as value equality), hashCode() trick could work.

Let's check:

    var number1 = 3;
    var number2 = 3;
    System.println("number1.hashCode(): " + number1.hashCode());
    System.println("number1.hashCode(): " + number2.hashCode());
    System.println("number1 == number2:" + (number1 == number2));
    System.println("number1.equals(number2): " + number1.equals(number2));

    var dict1 = { "key1" => 1 };
    var dict2 = { "key1" => 1 };
    System.println("dict1.hashCode(): " + dict1.hashCode());
    System.println("dict2.hashCode(): " + dict2.hashCode());
    System.println("dict1 == dict2: " + (dict1 == dict2));
    System.println("dict1.equals(dict2): " + dict1.equals(dict2));
    System.println("dict2.equals(dict1): " + dict2.equals(dict1));

What we get is:

number1.hashCode(): 3
number1.hashCode(): 3
number1 == number2:true
number1.equals(number2): true

dict1.hashCode(): 132
dict2.hashCode(): 143
dict1 == dict2: false
dict1.equals(dict2): false
dict2.equals(dict1): false

For numbers, it seems right. number1 and number2 are equal (both value and reference) and they have the same hash.

Dictionaries behave differently. Dictionary with value { "key1" => 1 } is not equal to another dictionary { "key1" => 1 }, they hash codes are different.

As you can see, .equals() is inconsistent. Probably that's why hashCode() is "strange", too, for Dictionary objects.

It's not inconsistent. It's just different from what we think it should be. It might be a bug or a bug in the documentation. Seemingly a.equals(b) is the same as a == b. So you'll have to implement your own comparator.