Ruby 1.9 with Symbol#to_proc and (soon) curried Procs

Next to Ruby 1.9's big new features such as threading changes or Fibers, it also added a host of smaller utility functions to the standard library. We already mentioned the Object.tap method, which adds a convenient way of spying on chained method calls.

Similarly to the tap method, the idea for the to_proc has been known in the Ruby community for some time - the feature is also available for pre-1.9 Ruby versions. Ruby 1.9 simply integrates this into the class Symbol, making the behavior available without any supporting libraries.

Reg Braithwaite gives a quick introduction to how to_proc makes code like (1..100).inject(&:+) work:

The & operator converts Proc objects into blocks and block into Proc objects. In this case, it tries to convert the symbol :+ into a block. The conversion uses Ruby's built-in coercion mechanism. That mechanism checks to see whether we have a Proc object. If not, it sends the #to_proc method to the argument to make a Proc. If the Symbol :+ has a #to_proc method, it will be called. In Ruby 1.9 it has a #to_proc method. That method returns a Proc that takes its first argument and sends the + method to it along with any other arguments that may be present.
So, &:+ really means { |x, y| x + y }.

This beheavior can be seen with code like this.:

plus = :+.to_proc
puts plus.call(1,2) # prints '3' 

Since the class Symbol has the to_proc method, this approach works for every symbol:

to_s = :to_s.to_proc
to_s.call(42) # results in the string "42" 

The implementation of to_proc is simple. Dave Thomas (PragDave) shows how it works:

def to_proc
 proc { |obj, *args| obj.send(self, *args) }
end 

It creates a Proc which, when called on an object, sends that object the symbol itself. So, when names.map(&:upcase) starts to iterate over the strings in names, it'll call the block, passing in the first name and invoking its upcase method.

While the feature might yield very succinct code, one question still remains: does this improve the readibility of code? The answer to this has probably changed with the addition of to_proc to standard Ruby 1.9, simply because the Symbol now always comes with to_proc.
 Previously, the availability of the method depended on whether some code or library had opened Symbol and added it. Also: understanding the code involved knowledge of the general Symbol#to_proc idiom, which in Ruby 1.9 has been officially added, and is now more likely to be mentioned in documentation.

This still leaves the question:

 (1..100).map(&:to_s) 

Vs.

 (1..100).map{|x| x.to_s } 

Saving five characters (for this example) - is it worth the extra complexity or not?

Another feature involving Procs has been added to Ruby 1.9 - albeit only in a very recent revision: Proc#curry. A recent ruby-core discussion shows what Proc#curry does:

 It's not difficult at all,
   proc {|x, y, z| x + y + z }.curry
 returns the proc object equivalent to
   proc {|x| proc {|y| proc {|z| x + y + z } } } 

The name of this method stems from the concept of Currying, which:

[..] is the technique of transforming a function that takes multiple arguments into a function that takes a single argument (the other arguments having been specified by the curry).

In other words: using currying, a Proc that takes x arguments, can be called with a single argument. Since, obviously, it can't return the result of it's code - it's missing arguments required to run the code - it returns a new Proc that takes (x - 1) arguments. Once this has been repeated enough times so the resulting Proc has all the arguments it needs, the code is evaluated and the result returned.

An example what this can be used for from the same ruby-core thread:

plus_five = proc { |x,y,z| x + y + z }.curry.call(2).call(3) 
plus_five[10] #=> 15 

Note: plus_five is a Proc - the [] operator for Proc is overloaded to invoke the Proc.

Caution: Proc#curry is a very recent addition to Ruby 1.9 - to try it, you'll have to use a recent revision.