Buggy Symbol to Proc Implementation

     Ruby 1.9 seems to have introduced symbol to proc into the core language itself. I'm not sure whether this is implemented natively or as Ruby code, so if anyone knows that, please do let me know. For people who don't know what symbol to proc is (which is, I suspect, a very small part of the ruby community), click here

     Symbol to proc, was a really interesting feature that was built into the Symbol class in ruby that really helped right very idiomatic code. You're probably aware that Ruby allows you to pass blocks of code around and a lot of core objects in ruby accept blocks as part of their methods. So for example if you had a list of integers and you wanted to make them all positive you'd write [1,-3,5].map{|i| i.abs}

   

      The map method on arrays takes a block. It passes each element in the block and expects you to return to it something else. So it creates a new array where for each element you get a corresponding new element. The way you choose to do so is what your block decides. Clearly there are a lot of very complex things you can do, but very often what you want to do is as simple as in this example. You just want to call some function on each object in the array.  the to_proc method in Symbol allowed you to write code like this instead [1,-3,5].map(&:abs). So map expected a block. The & in the argument being passed indicated a block followed the &. But instead what followed was :abs, which is a symbol. But the default to_proc method added to symbol is enough to do the right thing.

      Naturally, when I first heard of this like a lot of people I was really curious about how it worked. And there are tons of people who have written about it. Most of us have tried it and seen how it works.

     Recently I was doing something on irb 1.8 and I missed having symbol to proc around. Rather than require ActiveSupport, the gem which includes this enhancement to symbol, I just googled for the code and found this, which was the first hit in google when I searched for "symbol to proc". I pasted the code into irb and continued ... and then I suddenly faced a strange error.

class Symbol
def to_proc
Proc.new { |obj, *args| obj.send(self, *args) }
end
end
>> [[1],[-3,4]].map(&:size)
ArgumentError: wrong number of arguments (1 for 0)
from (irb):58:in `size'
from (irb):58:in `send'
from (irb):58:in `to_proc'
from (irb):71:in `map'
from (irb):71

     I was quite mystified by this error. Now this does not happen when you use the symbol to proc implementation currently in Rails (listed below), or the Ruby 1.9 implementation.

class Symbol
def to_proc
Proc.new { |*args| args.shift.__send__(self, *args) }
end
end

     Modifying the buggy symbol to proc implementation a bit, we get more insight into the problem.

class Symbol
def to_proc
Proc.new { |obj, *args| puts "obj is #{obj}"; puts "args has #{args.size} elements"; obj.send(self, *args) }
end
end
>> [1,-3,4].map(&:abs)
obj is 1
args has 0 elements
obj is -3
args has 0 elements
obj is 4
args has 0 elements
=> [1, 3, 4]
>> [[1],[-3,4]].map(&:size)
obj is 1
args has 0 elements
obj is -3
args has 1 elements
ArgumentError: wrong number of arguments (1 for 0)
from (irb):58:in `size'
from (irb):58:in `send'
from (irb):58:in `to_proc'
from (irb):71:in `map'
from (irb):71

      Notice how in the second case, obj seems to be not the array, but the head of the array. And the remaining elements have become arguments. I'm not sure if the symbol to proc implementation on that page was always wrong, or if ActiveSupport once had a buggy implementation that was subsequently fixed. One thing I've been unable to do is to write some sample code to recreate the problem without using symbol to proc at all. Just writing a couple of functions with varargs and invoking them with array arguments. If anyone is able to construct such an example, that would be great. Here is an additional issue with symbol to proc (performance related). And here is a workaround.