ENDS 12/4: Get 50% off your Pro annual membership using code [CYBER23](https://www.codecademy.com/checkout?periods=year&plan_id=proGoldAnnualV2&discountCode=CYBER23)


In this course, we'll cover three of the most powerful aspects of the Ruby programming language: blocks, procs, and lambdas.

Blocks, Procs, and Lambdas

You're basically a Ruby block master at this point. This should be pretty easy!

Been Around the Block a Few Times

We learned a bit about blocks in [Loops & Iterators](https://www.codecademy.com/courses/learn-ruby/lessons/loops-iterators/exercises/the-while-loop) and [Methods, Blocks, & Sorting](https://www.codecademy.com/courses/learn-ruby/lessons/methods-blocks-sorting/exercises/why-methods). We said earlier that a block is like a nameless method, but that's not *quite* true. (We'll get to actual nameless methods, called *lambdas*, later in this lesson.)

A Ruby block is just a bit of code that can be executed. Block syntax uses either `do`..`end` or curly braces (`{}`), like so:
```rb
[1, 2, 3].each do |num|
  puts num
end
# ==> Prints 1, 2, 3 on separate lines

[1, 2, 3].each { |num| puts num }
# ==> Prints 1, 2, 3 on separate lines
```
Blocks can be combined with methods like `.each` and `.times` to execute an instruction for each element in a collection (like a hash or array).

You Know This!

Procs are easy to define! You just call `Proc.new` and pass in the block you want to save. Here's how we'd create a proc called `cube` that cubes a number (raises it to the third power):
```rb
cube = Proc.new { |x| x ** 3 }
```
We can then pass the proc to a method that would otherwise take a block, and we don't have to rewrite the block over and over!
```rb
[1, 2, 3].collect!(&cube)
# ==> [1, 8, 27]
[4, 5, 6].map!(&cube)
# ==> [64, 125, 216]
```
(The `.collect!` and `.map!` methods do the exact same thing.)

The `&` is used to convert the `cube` proc into a block (since `.collect!` and `.map!` normally take a block). We'll do this any time we pass a proc to a method that expects a block.

Proc Syntax

Now that you're learning some of the more complex parts of the Ruby language, you can combine them to work some truly arcane magicks. For instance, remember when we told you that you could [pass a Ruby method name around with a symbol](https://www.codecademy.com/courses/learn-ruby/lessons/hashes-and-symbols/exercises/what-are-symbols-used-for)? Well, you can *also* convert symbols to procs using that handy little `&`.

Check it out:
```rb
strings = ["1", "2", "3"]
nums = strings.map(&:to_i)
# ==> [1, 2, 3]
```
By mapping `&:to_i` over every element of `strings`, we turned each string into an integer!

Symbols, Meet Procs

Nice work! Calling a proc with a method isn't too tricky. However, there's an even easier way.

Unlike blocks, we can call procs directly by using Ruby's `.call` method. Check it out!
```rb
test = Proc.new { # does something }
test.call
# does that something!
```
Remember: there's *always* more than one way to do something in Ruby.

Call Me Maybe

Good! There are a bunch of really useful Ruby methods that take blocks. One we haven't covered yet is `collect`.

The `collect` method takes a block and applies the expression in the block to every element in an array. Check it out:
```rb
my_nums = [1, 2, 3]
my_nums.collect { |num| num ** 2 }
# ==> [1, 4, 9]
```
If we look at the value of `my_nums`, though, we'll see it hasn't changed:
```rb
my_nums
# ==> [1, 2, 3]
```
This is because `.collect` returns a *copy* of `my_nums`, but doesn't change (or **mutate**) the original `my_nums` array. If we want to do that, we can use `.collect!` with an exclamation point:
```rb
my_nums.collect! { |num| num ** 2 }
# ==> [1, 4, 9]
my_nums
# ==> [1, 4, 9]
```
Recall that the `!` in Ruby means "this method could do something dangerous or unexpected!" In this case, it mutates the original array instead of creating a new one.

Collect 'Em All

Great work! You've written your own lambda and seen how to pass it to a method. Now it's time for you to write a lambda *and* pass it to a method!

If you think this will be a lot like what you've already done with procs, you're exactly right. Just like with procs, we'll need to put `&` at the beginning of our lambda name when we pass it to the method, since this will convert the lambda into the block the method expects.

That `symbolize` lambda was pretty cool. Let's riff on it with a lambda that checks to see if each element in an array is a symbol. We can do this checking with the `.is_a?` method, which returns `true` if an object is the type of object named and `false` otherwise:
```rb
:hello.is_a? Symbol
# ==> true
```
The word `Symbol` has to be capitalized when you're doing an `.is_a?` check!

Now You Try!

Why do some methods accept a block and others don't? It's because methods that accept blocks have a way of transferring control from the calling method to the block and back again. We can build this into the methods we define by using the `yield` keyword.

Learning to Yield

Remember when we told you that everything is an object in Ruby? Well, we sort of fibbed. Blocks *are not* objects, and this is one of the very few exceptions to the "everything is an object" rule in Ruby.

Because of this, blocks can't be saved to variables and don't have all the powers and abilities of a real object. For that, we'll need... procs!

You can think of a proc as a "saved" block: just like you can give a bit of code a name and turn it into a method, you can name a block and turn it into a proc. Procs are great for keeping your code **DRY**, which stands for **D**on't **R**epeat **Y**ourself. With blocks, you have to write your code out each time you need it; with a proc, you write your code once and can use it many times!

Keeping Your Code DRY

Lambdas are defined using the following syntax:
```rb
lambda { |param| block }
```
Lambdas are useful in the same situations in which you'd use a proc. We'll cover the differences between lambdas and procs in the next exercise; in the meantime, let's get a little practice in with the `lambda` syntax.

Lambda Syntax

Why bother saving our blocks as procs? There are two main advantages:

1. Procs are full-fledged objects, so they have all the powers and abilities of objects. (Blocks do not.)
2. Unlike blocks, procs can be called over and over without rewriting them. This prevents you from having to retype the contents of your block every time you need to execute a particular bit of code.

Why Procs?

All this talk of blocks, procs, and lambdas might have your head spinning. Let's take a minute to clarify exactly what each one is:

1. A block is just a bit of code between `do`..`end` or `{}`. It's not an object on its own, but it can be passed to methods like `.each` or `.select`.
2. A proc is a saved block we can use over and over.
3. A lambda is just like a proc, only it cares about the number of arguments it gets and it returns to its calling method rather than returning immediately.

There are obviously lots of cases in which blocks, procs, and lambdas can do similar work, but the exact circumstances of your program will help you decide which one you want to use.

Quick Review

You can also pass parameters to `yield`! Check out the example in the editor. 

1. The `yield_name` method is defined with one parameter, `name`.
2. On line 9, we call the `yield_name` method and supply the argument `"Eric"` for the `name` parameter. Since `yield_name` has a `yield` statement, we will also need to supply a block.
3. Inside the method, on line 2, we first `puts` an introductory statement.
4. Then we yield to the block and pass in `"Kim"`. 
5. In the block, `n` is now equal to `"Kim"` and we `puts` out "My name is Kim."
6. Back in the method, we `puts` out that we are in between the yields.
6. Then we yield to the block again. This time, we pass in `"Eric"` which we stored in the `name` parameter.
7. In the block, `n` is now equal to `"Eric"` and we `puts` out "My name is Eric."
8. Finally, we `puts` out a closing statement.

Yielding With Parameters

Perfect! Now let's pass our proc to a method.

Passing Your Proc to a Method

Now let's tackle procs. First step: create one!

Creating a Proc

Okay! Time to take off the training wheels.

```rb
cube = Proc.new { |x| x ** 3 }
[1, 2, 3].map(&cube)
# [1, 8, 27]
```

You're going to create your very own method that calls your very own proc! We'll do this in two steps. Use the example above as a syntax reminder.

Create Your Own!

Second verse: same as the first! Let's go ahead and make ourselves a `lambda`.

Creating a Lambda

See? Even though this block business has a little more going on under the hood than we thought, it's still pretty straightforward.

Now that we know how methods accept blocks using the `yield` keyword, let's define our own method and pass it a block!

Try It Yourself!

Like procs, lambdas are objects. The similarities don't stop there: with the exception of a bit of syntax and a few behavioral quirks, lambdas are identical to procs.

Check out the code in the editor. See the `lambda` bit? Typing
```rb
lambda { puts "Hello!" }
```
Is just about the same as
```rb
Proc.new { puts "Hello!" }
```
In the example to the right, when we pass the lambda to `lambda_demo`, the method calls the lambda and executes its code.

The Ruby Lambda

If you're thinking that procs and lambdas look super similar, that's because they are! There are only two main differences.

First, a lambda checks the number of arguments passed to it, while a proc does not. This means that a lambda will throw an error if you pass it the wrong number of arguments, whereas a proc will ignore unexpected arguments and assign `nil` to any that are missing.

Second, when a lambda returns, it passes control back to the calling method; when a proc returns, it does so immediately, without going back to the calling method.

To see how this works, take a look at the code in the editor. Our first method calls a proc; the second calls a lambda.

Lambdas vs. Procs

Home stretch! Now let's pass our lambda to a method, as well.