You may have noticed code that looks like this:

  1. array.each(&:notify!)

What, you may ask yourself, does this do? Firstly, each, map/collect, select, reject, inject, etc. are all methods on Enumerable that are included by various classes, like Array. They are the basis for dealing with Arrays in Ruby, and each is the one on which all the others are built (whether literally true, I don’t know, but they could be).

All these methods expect to pass each element of the Array in turn to a block (anonymous function), which normally looks something like this:

  1. array.each {|item| puts item.inspect}

However, there are times when you want to use the same block many times, in many different places. In such cases, you don’t really want your block to be repeated over and over again, so you encapsulate it in a Proc instance:

  1. my_block = Proc.new {|item| puts item.inspect}
  2. array1.each(&my_block)
  3. array2.each(&my_block)

Notice that you use the method-passing syntax of parenthesis rather than block syntax when calling each, and that both calls prefix the block with an ampersand. This is the syntax Ruby uses to indicate that this argument (which must be the last) should be treated as the block for this method call.

In the above examples, my_block is a Proc instance, which is exactly what Ruby expects. So far, so good. However, what if you don’t pass it a Proc?

  1. array.each(&"some string")

Aside from human confusion over exactly what is intended here, what will Ruby do? It will see that the object you’re saying to use as the block is not a Proc instance, and will try to convert it to one by calling the object’s to_proc method, if it exists.

I think that in the core language only Proc instances have this method (they return self), but Rails adds something:

  1. # in active_support/core_ext/symbol.rb
  2.  
  3. class Symbol
  4. # Turns the symbol into a simple proc, which is especially useful for enumerations. Examples:
  5. #
  6. #   # The same as people.collect { |p| p.name }
  7. #   people.collect(&:name)
  8. #
  9. #   # The same as people.select { |p| p.manager? }.collect { |p| p.salary }
  10. #   people.select(&:manager?).collect(&:salary)
  11. def to_proc
  12. Proc.new { |obj, *args| obj.send(self, *args) }
  13. end
  14. end

This to_proc method returns a Proc instance whose contained block takes a target object and any number of trailing arguments. So here’s what we get:

  1. # these two are equivalent
  2. :name.to_proc
  3. Proc.new { |obj, *args| obj.name(*args) }

So we could do this:

  1. block = :name.to_proc
  2. array.map(&block)

However, as I said earlier, Ruby will call to_proc for us, so we can shorten it to this:

  1. array.map(&:name)

Remember that each, map, select, reject, etc. all only pass one argument: the item at the current point in the iteration. This means that in the block above args will be an empty array, so the block can usually be thought of as this:

  1. Proc.new { |obj| obj.send(self) }

And remember that self here is the symbol itself.