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.