Procs and the Four Ways of Calling Them

Unlike the language named after a certain serpent, Ruby embraces TMTOWTDI (pronounced as Tim Toady), or There’s more than one way to do it. The calling of Procs is a wonderful example. In fact, Ruby gives you four different ways:

1. Proc#call(args)

2. .(args)

3. Threequals

4. Lambdas

Fire up irb. Let’s begin by creating a very simple Proc:

There are two things to notice here. First, the return value tells you that a Proc has been created. Second, Ruby provides a shorthand to create Procs. This is really a method in the Kernel class:

Of course, since Proc is just like any other class, you can create an instance of it the usual way:

Now you know how to create a Proc. Time to make it do some work. The first way is to use Proc#call(args):

In fact, this is my preferred way of invoking Procs because it conveys the intent of invocation much better than the alternatives, which are presented next.

Ruby provides a shorthand for the call(args) method: .(args). Therefore, the previous example could have been rewritten as such:

Here’s an interesting Ruby tidbit. Turns out, the .() syntax works across any class that implements the call method. For example, here’s a class with only the call method:

You should avoid using .() if you can, because this could potentially confuse other people who might not be familiar with the syntax.

Ruby has an even quirkier syntax for invoking Procs:

The === operator is also known as the threequals operator. This operator makes it possible to use a Proc in a case statement. Look at the following code:

Here, even, when given a number, returns true or false depending on the case statement. For example:

Note that invoking a Proc that expects a single argument this way is incorrect and results in a confusing error message:

Next, let’s look at lambdas and how they relate to Procs.