Question

I was debugging an issue in an RoR application and came across with below code (where ‘map’ is a two dimensional array of integer). The code attempts to duplicate and append the last element of each sub-array:

map.each { |x| x << x[-1] }

Before this line of code,

    (rdb:29) p map
    [[1, 2, 1, 3, 4], [1, 2, 2, 3, 4], [1, 2, 2, 3, 4], [1, 2, 2, 3, 4],
    [1, 2, 2, 3, 4], [1, 2, 2, 3, 4]]
    (rdb:29) p map.class
    Array
    (rdb:29) p map.first.class
    Array
    (rdb:29) p map.last.class
    Array

After:

    (rdb:29) p map
    [[1, 2, 1, 3, 4, 4], [1, 2, 2, 3, 4, 4], [1, 2, 2, 3, 4, 4],
    [1, 2, 2, 3, 4, 4], [1, 2, 2, 3, 4, 4, 4], [1, 2, 2, 3, 4, 4, 4]]

The problem here is that the last 2 sub-arrays were appended with two integers instead of one, while it is correct for the first 4 sub-arrays. I changed the code to use Array.map instead, it was then working properly:

map = map.map { |x| x + [x[-1]] }

To sum up:
I know the iterating element in the Array.each block is not supposed to be changed. But why is it giving unpredictable results when doing so? The code actually works most of the time, the issue was just seen sometimes. Was it a bug in Ruby or RoR?

Answer 1

Modifying the sub-array within the each block isn’t your problem, there’s nothing wrong with that at all. Your problem is that your outer array, map, sometimes contains multiple references to the same sub-array object.

Consider this:

>> x = [[1, 2, 1, 3, 4], [1, 2, 2, 3, 4], [1, 2, 2, 3, 4]]
>> x.each { |a| a << a[-1] }
=> [[1, 2, 1, 3, 4, 4], [1, 2, 2, 3, 4, 4], [1, 2, 2, 3, 4, 4]]

The results will be the same every single time. But if you have this:

>> gotcha = [1, 2, 1, 3, 4]
>> x = [[1, 2, 1, 3, 4], gotcha, gotcha]
>> x.each { |a| a << a[-1] }
=> [[1, 2, 1, 3, 4, 4], [1, 2, 1, 3, 4, 4, 4], [1, 2, 1, 3, 4, 4, 4]]

Then you will get the extra trailing elements that you were seeing (every single time) because gotcha gets modified twice. The x in the second case will puts the same as the x in the first case but they are not the same.

Your Array#map approach always works because this:

x + [x[-1]]

essentially copies x and then appends x[-1] to that copy, it never modifies x at all so the gotcha behavior from above won’t happen.

You can’t get away from pointers, not even when they’re called references.