{ :some_id => 1, :something => 'one' }.reject{|k, v| k =~ /_id/ }
#=> {:some_id=>1, :something=>"one"}

Which is totally different from Ruby 1.9.1

{ :some_id => 1, :something => 'one' }.reject{|k, v| k =~ /_id/ }
#=> {:something=>"one"}

If you just make it k.to_s, your gist will give the same result on both versions of Ruby.
On the other hand, I can’t see where pass by reference is taking place…. can you elaborate?

http://gist.github.com/225709

def foo(bar)
bar.replace “if you can see this, bar was passed by value reference”
end

foo(bar)

puts bar

Saying that b is passed by value is as incorrect as saying that b is passed by reference. I am able to change bar via the parameter bar. That means that I do have a reference to bar in some sense. If what i received was simply a value copy, then I would not be able to reach the outer scope bar. if it was an actual pointer to bar, then I would be able to simply manipulate it as I do in C/C++. I understand the argument about the object_id, but claiming ruby is simply pass by value misses an important distinction. I was able to alter bar within foo when bar was passed as a parameter.

All your gist does is prove that you can manipulate an object when passing said object as a parameter to a method. It does not change what the variable object points to. Look up (pass/call)-by-reference on wikipedia, and perhaps you will get a better idea of what pass-by-reference means. When you understand what it means, then perhaps we can argue about whether or not Ruby supports it.

If Ruby supported pass-by-reference then this could work:


def swap(a,b)
a,b = b,a
end
foo = 1
bar = 2
# notice that we are not capturing a return value because we
# wouldn't need to if Ruby used pass-by-reference.
swap(foo,bar)
puts foo # 2
puts bar # 1