Identical is not equivalent to reference equality. Let's assume that isEqualTo implements reference equality, and consider a trivial IL transformation of the earlier code, as would happen in a standard compiler.

[1,2,3] isEqualTo [1,2,3]

becomes

a=[1,2,3]

b=[1,2,3]

rval = isEqualTo a, b

Now, let's assume that the compiler is smart enough to know that a and b are not aliased in isEqualTo, and stores their arrays in program memory. Then, this would become a notional in-memory form (with made-up indices) of

0x60000: 1

0x60004: 2

0x60008: 3

0x6000C: 1

0x60010: 2

0x60014: 3

Then, a = 0x60000 and b = 0x6000C. Then, while every element in the arrays is the same, a != b (assume that a = b, then 0x60000 = 0x6000C iff 0 = 12, which is patently false). Therefore, a isEqualTo b, if isEqualTo implements reference equality, should be false.

However, isEqualTo clearly does not implement reference equality. In the above example, it doesn't compare 0x60000 and 0x6000C, rather, it compares 1=1, 2=2, and 3=3. This means that it's arbitrarily slower (in big omega of n) than the reference equality implementation - to see why, make two identical arrays of a billion elements, and run isEqualTo on them. The notional reference equality implementation is instant - it doesn't depend on the size of the arrays, but isEqualTo could take a very long time indeed.

Note that the actual implementation of the arrays will cause code that looks more like

a=Array.create(1,2,3)

b=Array.create(1,2,3)

to be generated. This means that the pointers are actually looking at heap elements, but the same idea holds.