The most amusingly weird thing I can think of is INTERCAL's COMEFROM: http://en.wikipedia.org/wiki/COMEFROM
By definition, the subscript operator [] is interpreted in such a
way that ‘‘E1[E2]’’ is identical to ‘‘*((E1) + (E2))’’. Because
of the conversion rules which apply to +, if E1 is an array and
E2 an integer, then E1[E2] refers to the E2th member of E1.
Therefore, despite its asymmetric appearance, subscripting is a
commutative operation.¹
a[10] 10[a]
This is because a[10] is equivalent to (a + 10), and 10[a] is equivalent to (10 + a), as the first comment on this answer explains.
[1] http://stackoverflow.com/questions/1995113/strangest-languag...
> The definition of the subscript operator [] is that E1[E2] is identical to (* ((E1)+(E2))).
Since * (E1 + E2) is commutative, E1[E2] == E2[E1].
[~~~~~~~~~~~~~~~~[a~~~~~~~b~~]~~~] Memory
^–––––––––––––––––^ Address
^–––––––^ Offset
address[offset] => *(address + offset) => getValueAtAddress(valueIn(address) + valueIn(offset))
a[b] => *(a + b) => getValueAtAddress(valueIn(a) + valueIn(b))
b[a] => *(b + a) => getValueAtAddress(valueIn(a) + valueIn(b))
It's confusing because array[i] makes sense but i[array] doesn't (how the hell can you use an array as an index on an integer?)
It works because array is a pointer to a memory address and i (or index) is an offset. array[i] will add the index to the memory address and return the value there, where as i[array] will add the memory address to the index. Since array+index == index+array, they point to the same memory and return the same value.