Proc composition in Ruby - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of composed Procs with chaining

What is the output of this Ruby code using Proc composition?

Ruby

add_two = Proc.new { |x| x + 2 }
double = Proc.new { |x| x * 2 }
composed = add_two >> double
puts composed.call(3)

A 8

B 10

C 7

D 11

💡 Hint

Remember that '>>' composes Procs so the first runs, then the second runs on the result.

The 'add_two' Proc adds 2 to 3, resulting in 5. Then 'double' multiplies 5 by 2, resulting in 10.

❓ Predict Output

intermediate

Output of composed Procs with reverse chaining

What is the output of this Ruby code using Proc composition with '<<' operator?

Ruby

add_two = Proc.new { |x| x + 2 }
double = Proc.new { |x| x * 2 }
composed = add_two << double
puts composed.call(3)

A 7

B 11

C 8

D 10

💡 Hint

The '<<' operator composes Procs so the second runs first, then the first runs on the result.

The 'double' Proc runs first on 3, giving 6. Then 'add_two' adds 2 to 6, resulting in 8.

🔧 Debug

advanced

Identify the error in Proc composition

What error does this Ruby code raise when trying to compose Procs?

Ruby

p1 = Proc.new { |x| x + 1 }
p2 = Proc.new { |x, y| x * y }
composed = p1 >> p2
puts composed.call(2)

A ArgumentError: wrong number of arguments (given 1, expected 2)

B NoMethodError: undefined method `>>' for Proc

C TypeError: Proc cannot be composed

D RuntimeError: incompatible Proc types

💡 Hint

Check the number of arguments each Proc expects and what is passed during composition.

The first Proc returns one value, but the second Proc expects two arguments, causing an ArgumentError when called with one argument.

🧠 Conceptual

advanced

Understanding Proc composition behavior

Which statement best describes the behavior of the '>>' operator when composing two Procs in Ruby?

A It creates a new Proc that calls both Procs in parallel and returns an array of results.

B It merges the two Procs into one that calls them sequentially but ignores the first Proc's result.

C It creates a new Proc that calls the second Proc first, then the first Proc with the result.

D It creates a new Proc that calls the first Proc, then passes its result to the second Proc.

💡 Hint

Think about the order of execution and how the output of one Proc is used.

The '>>' operator composes Procs so that the first runs, then its output is passed as input to the second Proc.

🚀 Application

expert

Compose Procs to transform and filter data

Given these Procs, which composed Proc will correctly double numbers, then keep only those greater than 10 when applied to an array?

Ruby

double = Proc.new { |x| x * 2 }
filter_gt_10 = Proc.new { |arr| arr.select { |n| n > 10 } }

A composed = Proc.new { |arr| filter_gt_10.call(arr.map(&double)) }

B composed = double >> filter_gt_10

C composed = filter_gt_10 >> double

D composed = Proc.new { |arr| arr.map(&double).select { |n| n > 10 } }

💡 Hint

Remember that 'double' works on single numbers, but 'filter_gt_10' works on arrays.

Option A correctly maps 'double' over the array, then filters with 'filter_gt_10'. Options A and B try to compose incompatible Procs. Option A is correct Ruby code but not using Proc composition.

Practice

1. What does the >> operator do when used with two Procs in Ruby?

easy

A. It merges two Procs into one that runs them both in parallel.

B. It creates a new Proc that runs the first Proc, then passes its result to the second Proc.

C. It swaps the order of execution of two Procs.

D. It deletes the second Proc and keeps only the first.

Solution

1. Step 1: Understand Proc composition operator

   The >> operator chains two Procs so the output of the first becomes input of the second.

2. Step 2: Explain the effect of chaining

   Calling the combined Proc runs the first, then passes its result to the second, producing a final result.

3. Final Answer:

   It creates a new Proc that runs the first Proc, then passes its result to the second Proc. -> Option B

4. Quick Check:

   Proc composition = chaining with >> [OK]

Hint: Remember >> chains Procs passing output as input [OK]

Common Mistakes:

• Thinking >> runs Procs in parallel
• Assuming >> swaps execution order
• Believing >> deletes one Proc

2. Which of the following is the correct syntax to compose two Procs p1 and p2 in Ruby?

easy

A. combined = p1 >> p2

B. combined = p1 >>> p2

C. combined = p1 << p2

D. combined = p1 >> p2.call

Solution

1. Step 1: Recall correct Proc composition operator

   The operator to compose Procs is >>, which is written as >> but in Ruby code it is >> (two greater-than signs).

2. Step 2: Check each option

   combined = p1 >> p2 uses >> correctly. combined = p1 >>> p2 uses three > which is invalid. combined = p1 << p2 uses << which is not for composition. combined = p1 >> p2.call calls p2 immediately, which is wrong.

3. Final Answer:

   combined = p1 >> p2 -> Option A

4. Quick Check:

   Proc composition syntax = p1 >> p2 [OK]

Hint: Use exactly two > signs to compose Procs [OK]

Common Mistakes:

• Using >>> instead of >>
• Using << instead of >>
• Calling Proc instead of composing

3. What is the output of this Ruby code?

p1 = Proc.new { |x| x + 2 }
p2 = Proc.new { |y| y * 3 }
combined = p1 >> p2
puts combined.call(4)

medium

A. 18

B. 14

C. 20

D. 12

Solution

1. Step 1: Evaluate first Proc with input 4

   p1 adds 2 to input: 4 + 2 = 6.

2. Step 2: Pass result 6 to second Proc

   p2 multiplies input by 3: 6 * 3 = 18.

3. Final Answer:

   18 -> Option A

4. Quick Check:

   (4 + 2) * 3 = 18 [OK]

Hint: Apply first Proc, then second on result [OK]

Common Mistakes:

• Adding instead of multiplying in second Proc
• Multiplying first, then adding
• Confusing order of Procs

4. Identify the error in this Ruby code that tries to compose two Procs:

p1 = Proc.new { |x| x * 2 }
p2 = Proc.new { |y| y + 5 }
combined = p1 >> p2.call
puts combined.call(3)

medium

A. Syntax error due to missing parentheses

B. Using wrong operator for composition

C. Missing block parameters in p1

D. Calling p2 immediately instead of composing

Solution

1. Step 1: Check how p2 is used in composition

   The code uses p2.call which calls p2 immediately, returning a value, not a Proc.

2. Step 2: Understand correct composition usage

   To compose, use p1 >> p2 without calling p2. Calling p2 breaks composition.

3. Final Answer:

   Calling p2 immediately instead of composing -> Option D

4. Quick Check:

   Compose Procs without calling them [OK]

Hint: Do not call Procs when composing, just use >> [OK]

Common Mistakes:

• Calling Proc instead of composing
• Using wrong operator like <<
• Forgetting block parameters

5. Given these Procs:

p1 = Proc.new { |x| x.to_s }
p2 = Proc.new { |s| s + "!" }
p3 = Proc.new { |str| str.reverse }

How do you compose them so that calling the combined Proc with 5 returns "5!"?

hard

A. combined = p3 >> p2 >> p1

B. combined = p1 >> p2 >> p3

C. combined = p1 >> p3 >> p2

D. combined = p2 >> p1 >> p3

Solution

1. Step 1: Understand each Proc's effect

   p1 converts number to string, p2 adds "!", p3 reverses string.

2. Step 2: Find composition order to get "5!"

   "5".reverse = "5", so p1 >> p3 >> p2 gives: "5" -> "5" -> "5!". But p1 >> p2 >> p3: "5" -> "5!" -> "!5". Only A produces "5!".

3. Final Answer:

   combined = p1 >> p3 >> p2 -> Option C

4. Quick Check:

   to_s, reverse, then add ! = "5!" [OK]

Hint: Order Procs by desired transformations stepwise [OK]

Common Mistakes:

• Putting p2 before p3 changes output to "!5"
• Reversing order causes errors on non-string
• Ignoring effect of reverse on "5!"