Why do structs and a mutable structs have different default equality operators?

Question

I have the following code:

julia> struct Point
           x
           y
       end

julia> Point(1,2) == Point(1,2)
true

julia> mutable struct Points
           x
           y
       end

julia> Points(1,2) == Points(1,2)
false

Why are the two objects equal when it is a normal struct but not equal when it is a mutable struct?

Answer 1

The reason is that by default == falls back to ===. Now the way === works is (citing the documentation):

First the types of x and y are compared. If those are identical, mutable objects are compared by address in memory and immutable objects (such as numbers) are compared by contents at the bit level.

So for Point, which is immutable, the comparison of contents is performed (and it is identical in your case). While Points is mutable, so memory addresses of passed objects are compared and they are different as you have created two distinct objects.

Answer 2

Bogumił Kamiński is correct, but you might as why that difference in the definition of === exists between mutable and immutable types. The reason is that your immutable structs Point are actually indistinguishable. Since they can't change, their values will always be the same, and so they might as well be two names for the same object. Therefore, In the language they are defined by only their value.

In contrast, for mutabke structs there are at least two ways you can distinguish them. First, since mutable structs can't usually be stack allocated, they have a memory location, and you can compare the memory location of the two mutable structs and see they are different. Second, you can simply mutate one of them, and see that only one object changes whereas the other doesn't.

So, the reason for the difference in the definition of === is that two identitcal mutable structs can be distinguished, but two immutable ones cannot.