Object identity - Githubissues

In Chapter 10 it is written:

In this example, Julia only created one string object, and both a and b refer to it. But when you create two arrays, you get two objects:

Actually, this is a misunderstanding of the === operator. For fully immutable values (for example isbitstype types), the objects don't really have any identity to worry about and === will just compare the literal binary bits of the value. For example if you pass a Bool or Int64 from one function to another, these will generally be copied but different copies are ===.

Functionally, the === actually does something similar for objects with identity, or those objects containing pointers to other mutable objects - it compares the bit value of the pointers. If they literally are the same bits of data, then there is no distinction that could be observed by the user, and the objects are ===.

Where the explanation goes wrong is it fails to note that String is a built-in type that is enforced to be immutable, and === compares the contents of two strings not the pointers. (You can observe the difference if you grab the pointers and use unsafe operations to manipulate the underlying RAM). At this level of discussion it might be helpful to focus on really obviously mutable values like Array. Something like this:

To check whether two variables refer to the same object, you can use the ≡ (\equiv TAB) or === operator.
julia> a = [1, 2, 3];

julia> b = b;

julia> a ≡ b
true
In this example, Julia only created one array object, and both a and b refer to it. But when you create two arrays, you get two objects:
julia> a = [1, 2, 3];

julia> b = [1, 2, 3];

julia> a ≡ b
false

BenLauwens / ThinkJulia.jl

Object identity #60