Blocks, Procs, and Lambdas

So far with Ruby, we have mainly been using blocks when looping through data. This refers to the code that is contained between curly braces or the "do" and "end" keywords. We've seem this used with many things such as .select. Let's say we have two hashes filled with names and genders, like this:

	greendale = {"Jeff"=>:male, "Britta"=>:female, "Troy"=>:male,
	            "Abed"=>:male, "Shirley"=>:female, "Annie"=>:female}

	parksrec = {"Ron"=>:male, "Leslie"=>:female, "April"=>:female,
	            "Andy"=>:male, "Donna"=>:female, "Tom"=>:male}
	

What if we want to select only girls whose name starts with the letter A? We could use a block with the same code twice, like this:

		selected_greendale = greendale.select do |name, gender|
		    gender==:female && name[0]=="A"
		end

		selected_parksrec = parksrec.select do |name, gender|
		    gender==:female && name[0]=="A"
		end
	

But this gets a little repetitive. One way we could you would be to create a method that we could call a number of times. But there is an even easier way to do this when a method is not necessary needed.

Procs are one way to do it. The above code can be replaced with a proc like this:

		a_women = Proc.new {|name, gender| gender==:female && name[0]=="A"}

		selected_greendale = greendale.select(&a_women)
		selected_parksrec = parksrec.select(&a_women)
	

This will give us the name "Annie" for the some_greendale hash and "April" for the some_parksrec hash.

Essentially, Proc.new creates a new object. The code that normally appears in the block of the select method can be added instead when defining the new Proc object. The select method is then called using (&a_women) as the parameter. The & character is being used to denote that an object is being passed in.

Another way of doing this would be with a lamda. These are similar to Procs, as they are objects. The syntax looks almost exactly the same, like this:

		a_women = lambda{|name, gender| gender==:female && name[0]=="A"}

		selected_greendale = greendale.select(&a_women)
		selected_parksrec = parksrec.select(&a_women)
	

The only change was replacing "Proc.new" with "lambda" in the creation of a_women. So what is the difference between lambdas and procs? We can see the difference best if we use procs and lambas inside methods. In the example below, we can use .call to call the proc and the lambda immediately after they have been created.

		def lambda_method
			 lambda { return "inside the lambda block" }.call
			 return "inside the lambda method"
		end

		def proc_method
			 Proc.new { return "inside the proc block" }.call
			 return "inside the proc method"
		end

		p lambda_method
		p proc_method
	

The output of the code above is:

		"inside the lambda method"
		"inside the proc block"
	

When a lambda has a return, it passes control back to the calling method. But when a proc has a return, it returns and then breaks, without executing the rest of the method. In short, blocks, procs, and lambdas all work for iterating through data, but procs and lambdas can make a block reusable without having to define it in a method.