Why Proc creation and call in Ruby? - Purpose & Use Cases

The Big Idea

What if you could save a piece of your code and use it anytime without rewriting it?

The Scenario

Imagine you need to repeat a small task many times in your program, like greeting different people with slightly different messages. Without a way to save that task, you would have to write the same code again and again.

The Problem

Writing the same code repeatedly is slow and boring. It also makes mistakes more likely because if you want to change the task, you have to find and update every copy. This wastes time and can cause bugs.

The Solution

Using a Proc lets you save a chunk of code as an object. You can call it whenever you want, reuse it easily, and even pass it around like a variable. This keeps your code clean, short, and easy to change.

Before vs After

✗ Before

puts "Hello, Alice!"
puts "Hello, Bob!"
puts "Hello, Carol!"

✓ After

greet = Proc.new { |name| puts "Hello, #{name}!" }
greet.call("Alice")
greet.call("Bob")
greet.call("Carol")

What It Enables

It enables you to write flexible, reusable code blocks that can be stored, passed, and executed anytime, making your programs smarter and easier to manage.

Real Life Example

Think of a Proc as a recipe card you write once and use whenever you want to bake cookies. You don't rewrite the recipe each time; you just follow the saved instructions.

Key Takeaways

Repeating code manually is slow and error-prone.

Procs let you save and reuse code blocks easily.

This makes your code cleaner, shorter, and more flexible.

Practice

1. What does a Proc in Ruby do?

easy

A. Stores a block of code to run later

B. Creates a new variable

C. Defines a class

D. Starts a loop

Solution

1. Step 1: Understand what a Proc is and match description

   A Proc is a way to save some code to run later, like a recipe you keep for cooking. Only Stores a block of code to run later describes storing code to run later, which matches what a Proc does.

2. Final Answer:

   Stores a block of code to run later -> Option A

3. Quick Check:

   Proc = stored code block [OK]

Hint: Proc saves code to run later, like a saved recipe [OK]

Common Mistakes:

• Thinking Proc creates variables
• Confusing Proc with class definition
• Assuming Proc starts loops automatically

2. Which of the following is the correct way to create a Proc in Ruby?

easy

A. my_proc = Proc.new { |x| x * 2 }

B. my_proc = new Proc { |x| x * 2 }

C. my_proc = Proc.create { |x| x * 2 }

D. my_proc = Proc.call { |x| x * 2 }

Solution

1. Step 1: Recall Proc creation syntax and check options

   In Ruby, you create a Proc using Proc.new or proc with a block. Only my_proc = Proc.new { |x| x * 2 } uses the correct syntax Proc.new { |x| x * 2 }. Others use invalid methods like new Proc, Proc.create, or Proc.call.

2. Final Answer:

   my_proc = Proc.new { |x| x * 2 } -> Option A

3. Quick Check:

   Proc.new + block = correct Proc creation [OK]

Hint: Use Proc.new or proc with a block to create a Proc [OK]

Common Mistakes:

• Using 'new Proc' instead of 'Proc.new'
• Trying to call Proc.create or Proc.call to create
• Missing the block braces {}

3. What is the output of this Ruby code?

my_proc = proc { |x| x + 3 }
puts my_proc.call(4)

medium

A. 4

B. Error

C. 3

D. 7

Solution

1. Step 1: Trace the Proc definition and execution

   The Proc adds 3 to the input number: x + 3. Calling my_proc.call(4) computes 4 + 3 = 7.

2. Final Answer:

   7 -> Option D

3. Quick Check:

   4 + 3 = 7 [OK]

Hint: Proc.call runs code with given argument [OK]

Common Mistakes:

• Confusing Proc.call with Proc.new
• Forgetting to pass argument to call
• Expecting output without call

4. Identify the error in this code snippet:

my_proc = Proc.new { |x| x * 2 }
puts my_proc.call

medium

A. Proc.new syntax is incorrect

B. Missing argument when calling the Proc

C. Cannot call Proc with call method

D. Block should not have parameters

Solution

1. Step 1: Analyze Proc definition and call for errors

   The Proc expects one argument x to multiply by 2. The call is made without any argument, which causes an error because x is missing.

2. Final Answer:

   Missing argument when calling the Proc -> Option B

3. Quick Check:

   Proc needs argument when called [OK]

Hint: Always pass required arguments when calling a Proc [OK]

Common Mistakes:

• Calling Proc without required arguments
• Thinking Proc.new syntax is wrong
• Believing call method is invalid

5. Given this code, what will be the output?

def create_proc
  Proc.new { |x| x.nil? ? 'No value' : x * 10 }
end

my_proc = create_proc
puts my_proc.call(nil)
puts my_proc.call(5)

hard

A. nil\n50

B. Error\n50

C. No value\n50

D. No value\n5

Solution

1. Step 1: Analyze the Proc logic and trace both calls

   The Proc checks if x is nil; if yes, returns 'No value', else returns x * 10. Calling with nil returns 'No value'. Calling with 5 returns 5 * 10 = 50.

2. Final Answer:

   No value\n50 -> Option C

3. Quick Check:

   nil -> 'No value', 5 -> 50 [OK]

Hint: Proc can handle nil with conditional inside block [OK]

Common Mistakes:

• Expecting error when passing nil
• Forgetting ternary condition inside Proc
• Assuming multiplication by 10 applies to nil