Procs and Lambdas in Ruby Explained

Introduction

When working with Ruby, you may come across the terms "procs" and "lambdas". These are both ways to create blocks of code that can be passed around and executed at a later time. In this article, we will explore the differences between procs and lambdas, how to create them, and how to use them in your Ruby code.

What are Procs?

A proc is a block of code that can be stored in a variable and passed around like an object. Procs are created using the Proc.new method or by using the proc shortcut. Here is an example of creating a proc:

my_proc = Proc.new { puts "Hello, world!" }
my_proc.call

In this example, we create a proc that simply prints out "Hello, world!" when called. We then use the call method to execute the code inside the proc.

What are Lambdas?

A lambda is similar to a proc, but with some subtle differences. Lambdas are created using the lambda keyword or by using the -> shortcut. Here is an example of creating a lambda:

my_lambda = lambda { |name| puts "Hello, #{name}!" }
my_lambda.call("Alice")

In this example, we create a lambda that takes a parameter name and prints out a personalized greeting. We then use the call method to execute the lambda, passing in the argument "Alice".

Differences Between Procs and Lambdas

While procs and lambdas may seem similar, there are some key differences between the two:

Argument Handling

Procs are more lenient when it comes to the number of arguments passed to them. If you pass the wrong number of arguments to a proc, it will simply ignore the extras or fill in missing arguments with nil. Lambdas, on the other hand, will raise an error if you pass the wrong number of arguments.

Return Behavior

Another difference between procs and lambdas is how they handle the return keyword. When a proc encounters a return statement, it will return from the method that called the proc. Lambdas, however, will only return from the lambda itself.

Scope

Procs and lambdas also differ in how they handle variable scope. Procs capture the surrounding scope when they are created, while lambdas create their own scope. This means that procs can access variables from the surrounding context, while lambdas cannot.

Using Procs and Lambdas in Ruby

Now that we understand the differences between procs and lambdas, let's see how we can use them in our Ruby code. Here is an example of using a proc to iterate over an array:

my_proc = Proc.new { |item| puts item }
[1, 2, 3].each(&my_proc)

In this example, we create a proc that takes an item and prints it out. We then use the & operator to convert the proc into a block that can be passed to the each method of an array.

Now, let's see how we can use a lambda to filter out even numbers from an array:

my_lambda = lambda { |item| item.even? }
[1, 2, 3, 4, 5].select(&my_lambda)

In this example, we create a lambda that checks if an item is even. We then use the & operator to convert the lambda into a block that can be passed to the select method of an array, filtering out the even numbers.

Conclusion

Procs and lambdas are powerful tools in Ruby that allow you to create reusable blocks of code. By understanding the differences between procs and lambdas, as well as how to create and use them, you can take your Ruby programming to the next level. Experiment with procs and lambdas in your own code to see the benefits they can bring to your projects.