Tapping method chains with Ruby 1.9

The idea for the tap method has been around for some time - but it has now been added to the standard Ruby library in Ruby 1.9. MenTaLguY, who blogged about the idea behind tap shows the simple code:

class Object
 def tap
  yield self
  self
 end
end 

In Ruby 1.9, the tap method is defined in Object, making it available for every object in Ruby by default. The method takes a Block as argument, which it calls with self as argument - then the object is returned.

The indirection through the tap method seems like a complicated way of doing something with an object. The real benefit of this becomes clear when the object of interest is passed from one method to another without ever being assigned to a variable. This is common whenever methods are chained, particularly if the chain is long.
An example: without tap, a temporary variable is needed:

xs = blah.sort.grep( /foo/ )
p xs
# do whatever we had been doing with the original expression 
xs.map { |x| x.blah } 

With tap:

blah.sort.grep( /foo/ ).tap { |xs| p xs }.map { |x| x.blah } 

This shows where tap is useful: without it, it's necessary to assign the object of interest to a local variable to use it - with tap it's possible to insert the Block that inspects the object right where the handover between the chained methods happens. This gets particularly useful with APIs that expose so called Fluent Interfaces - i.e. APIs that encourage method chaining. Here a Java example from Martin Fowler's website:

customer.newOrder()
 .with(6, "TAL")
 .with(5, "HPK").skippable()
 .with(3, "LGV")
 .priorityRush(); 

In case this code has a bug, tap allows to look at the object at an arbitrary stage (i.e. between every call) by simply inserting a tap block. This is also useful with debugging tools, which often don't support looking at anonymous return values of methods.

It's important to mention that tap is normally about causing some kind of side effect without changing the object (the Block's return value is ignored). However, it is of course possible to modify the object as long as it's mutable.

Users of Rails' ActiveSupport are already familiar with a similar method in the form of the returning method .

Of course, the tap method is not restricted to Ruby 1.9 - Ruby's Open Classes allow to do this on non-1.9 Ruby versions too.