Proc composition in Ruby - Deep Dive

Overview - Proc composition

What is it?

Proc composition is a way to combine small pieces of code called Procs into a new Proc that runs them one after another. Each Proc is like a mini function that can be stored and passed around. By composing Procs, you create a chain where the output of one becomes the input of the next. This helps build complex behavior from simple, reusable parts.

Why it matters

Without Proc composition, you would have to write big, complicated functions that do everything at once. This makes code harder to read, test, and reuse. Proc composition lets you break problems into small steps and connect them cleanly. It makes your code more flexible and easier to change, which saves time and reduces bugs in real projects.

Where it fits

Before learning Proc composition, you should understand basic Ruby syntax, how to define and call Procs, and how functions work. After mastering Proc composition, you can explore functional programming concepts like currying, lambdas, and higher-order functions to write even more powerful and elegant code.

Mental Model

Core Idea

Proc composition is like linking small machines so the output of one feeds directly into the next, creating a smooth assembly line of actions.

Think of it like...

Imagine a factory assembly line where each worker adds something to a product before passing it on. Each worker is a Proc, and composing Procs is setting up the line so the product moves through all workers automatically.

┌─────────┐    ┌─────────┐    ┌─────────┐
│ Proc A  │ -> │ Proc B  │ -> │ Proc C  │
└─────────┘    └─────────┘    └─────────┘
       │             │             │
       └─────────────┴─────────────┘
                 Output

Build-Up - 7 Steps

1

Foundation

Understanding Ruby Procs Basics

Concept: Learn what a Proc is and how to create and call one in Ruby.

A Proc is a block of code saved in a variable. You can call it later with .call. For example: add_one = Proc.new { |x| x + 1 } puts add_one.call(5) # prints 6 This lets you store behavior and reuse it.

Result

The program prints 6 because the Proc adds 1 to the input 5.

Understanding that Procs are objects holding code lets you treat functions like data, opening doors to flexible programming.

2

Foundation

Passing Arguments to Procs

Concept: Learn how Procs accept inputs and return outputs.

Procs can take parameters just like methods. For example: multiply = Proc.new { |a, b| a * b } result = multiply.call(3, 4) puts result # prints 12 This shows Procs can do calculations with inputs.

Result

The output is 12 because 3 times 4 equals 12.

Knowing Procs accept arguments means you can build small reusable functions that work with different data.

3

Intermediate

Combining Two Procs Manually

Concept: Learn how to run one Proc after another by calling them in sequence.

You can create a new Proc that calls two Procs one after the other, passing the output of the first as input to the second: add_one = Proc.new { |x| x + 1 } double = Proc.new { |x| x * 2 } combined = Proc.new { |x| double.call(add_one.call(x)) } puts combined.call(3) # prints 8 Here, 3 + 1 = 4, then 4 * 2 = 8.

Result

The output is 8, showing the two Procs worked together in order.

Seeing how to chain Procs manually helps understand the core idea behind composition: linking outputs to inputs.

4

Intermediate

Creating a Reusable Compose Method

🤔Before reading on: do you think a method can take two Procs and return a new Proc that composes them? Commit to yes or no.

Concept: Learn to write a method that takes two Procs and returns their composition as a new Proc.

You can define a method that returns a Proc which runs two Procs in sequence: def compose(f, g) Proc.new { |x| f.call(g.call(x)) } end add_one = Proc.new { |x| x + 1 } double = Proc.new { |x| x * 2 } combined = compose(double, add_one) puts combined.call(3) # prints 8 This makes composition reusable.

Result

The output is 8, same as before, but now composition is a reusable tool.

Knowing you can build functions that create new functions is a powerful step toward functional programming.

5

Intermediate

Composing Multiple Procs with Reduce

🤔Before reading on: do you think you can compose many Procs at once using Ruby's Enumerable methods? Commit to yes or no.

Concept: Learn to compose a list of Procs into one Proc using Enumerable#reduce for scalability.

You can chain many Procs by reducing them with compose: procs = [Proc.new { |x| x + 1 }, Proc.new { |x| x * 2 }, Proc.new { |x| x - 3 }] composed = procs.reduce { |f, g| Proc.new { |x| f.call(g.call(x)) } } puts composed.call(5) # prints 5 Step by step: 5 - 3 = 2, 2 * 2 = 4, 4 + 1 = 5.

Result

The output is 5, showing all Procs applied in order.

Understanding how to compose many Procs at once lets you build complex pipelines from simple steps.

6

Advanced

Handling Multiple Arguments in Composition

🤔Before reading on: do you think Proc composition works the same when Procs take multiple arguments? Commit to yes or no.

Concept: Learn how to compose Procs that accept multiple arguments by adjusting the composition logic.

When Procs take multiple arguments, you must pass them correctly: def compose_multi(f, g) Proc.new { |*args| f.call(g.call(*args)) } end add = Proc.new { |a, b| a + b } double = Proc.new { |x| x * 2 } combined = compose_multi(double, add) puts combined.call(2, 3) # prints 10 Here, add(2,3)=5, double(5)=10.

Result

The output is 10, showing composition works with multiple inputs.

Knowing how to handle multiple arguments prevents bugs and expands composition to real-world functions.

7

Expert

Understanding Proc Composition Limitations and Performance

🤔Before reading on: do you think composing many Procs deeply affects performance or stack usage? Commit to yes or no.

Concept: Explore how deep Proc composition can impact performance and how Ruby handles call stacks in this context.

Each composed Proc calls another Proc inside it, creating nested calls. If you compose many Procs, this nesting grows and can slow down execution or risk stack overflow in extreme cases. Ruby does not optimize tail calls by default, so very deep composition chains may cause issues. To avoid this, flatten your logic or use iterative approaches when needed.

Result

Understanding these limits helps write safer, more efficient code.

Knowing the internal cost of composition helps balance elegance with performance in production code.

Under the Hood

Proc composition works by creating a new Proc that calls one Proc inside another. When you call the composed Proc, it first calls the inner Proc with the input, then passes that result to the outer Proc. This nesting creates a chain of calls. Internally, Ruby stores each Proc as an object with its own environment and code block. Calling a Proc executes its block with given arguments, returning a value. Composition links these calls so data flows through each Proc in order.

Why designed this way?

Ruby treats Procs as first-class objects to enable flexible code reuse and functional patterns. Composition is designed as nested calls because it naturally models function chaining and data flow. Alternatives like macros or special syntax would complicate the language. This design balances simplicity, power, and Ruby's object-oriented nature.

┌───────────────┐
│ Composed Proc │
└──────┬────────┘
       │ call
       ▼
┌───────────────┐
│ Outer Proc (f)│
└──────┬────────┘
       │ call with result of inner
       ▼
┌───────────────┐
│ Inner Proc (g)│
└───────────────┘
       │ call with input
       ▼
     Input
       │
       ▼
     Output

Myth Busters - 3 Common Misconceptions

Quick: Does composing Procs always run them in the order they appear in the array? Commit to yes or no.

Common Belief: Composing Procs runs them in the order they are listed, left to right.

Reality: Proc composition runs Procs right to left, meaning the last Proc runs first, then its output goes to the previous Proc.

Why it matters: Misunderstanding order leads to bugs where data is transformed incorrectly, causing wrong results in pipelines.

Quick: Do you think Procs and lambdas behave the same when composed? Commit to yes or no.

Common Belief: Procs and lambdas are interchangeable and compose the same way.

Reality: Lambdas check argument counts strictly and behave more like methods, while Procs are lenient. This difference affects composition, especially with argument mismatches.

Why it matters: Ignoring this can cause runtime errors or unexpected behavior when composing mixed Proc and lambda objects.

Quick: Is it true that composing many Procs has no performance impact? Commit to yes or no.

Common Belief: Composing many Procs is free and has no effect on speed or memory.

Reality: Each composed Proc adds a nested call, increasing call stack depth and overhead, which can slow down execution and risk stack overflow in extreme cases.

Why it matters: Not knowing this can lead to slow or crashing programs when composing large chains without care.

Expert Zone

1

Proc composition order is right-to-left, which can confuse beginners expecting left-to-right execution.

2

Using Proc#curry with composition enables partial application combined with chaining, a powerful functional pattern.

3

Mixing Procs and lambdas in composition requires careful handling due to differences in argument checking and return behavior.

When NOT to use

Avoid Proc composition when performance is critical and the chain is very long, as nested calls add overhead. Instead, use iterative loops or specialized pipeline libraries. Also, avoid composition if Procs have side effects that depend on execution order or external state, as this breaks functional purity.

Production Patterns

In real-world Ruby apps, Proc composition is used to build middleware stacks, data transformation pipelines, and event processing chains. Frameworks like Rack use similar patterns to compose request handlers. Experts often combine composition with currying and memoization for efficient, reusable code.

Connections

Function composition in mathematics

Proc composition in Ruby directly models mathematical function composition where f(g(x)) applies one function after another.

Understanding mathematical function composition clarifies why Proc composition chains outputs to inputs and why order matters.

Unix shell pipelines

Proc composition is like chaining shell commands with pipes, where output of one command feeds into the next.

Knowing shell pipelines helps grasp how data flows through composed Procs step-by-step.

Assembly line manufacturing

Proc composition mirrors an assembly line where each station adds value before passing the product along.

Seeing Proc composition as an assembly line highlights modularity and clear data flow in programming.

Common Pitfalls

#1 Forgetting that Proc composition runs right to left, causing unexpected results.

Wrong approach:

procs = [proc1, proc2, proc3]
composed = procs.reduce { |f, g| Proc.new { |x| f.call(g.call(x)) } }
# Assuming proc1 runs first, then proc2, then proc3

Correct approach:

procs = [proc1, proc2, proc3]
composed = procs.reverse.reduce { |f, g| Proc.new { |x| f.call(g.call(x)) } }
# Reverse to run proc1 first, then proc2, then proc3

Root cause:

Misunderstanding that reduce composes functions right to left, not left to right.

#2 Composing Procs that expect different numbers of arguments without handling them properly.

Wrong approach:

def compose(f, g)
Proc.new { |x| f.call(g.call(x)) }
end

add = Proc.new { |a, b| a + b }
double = Proc.new { |x| x * 2 }
combined = compose(double, add)
combined.call(2, 3) # Error due to argument mismatch

Correct approach:

def compose_multi(f, g)
Proc.new { |*args| f.call(g.call(*args)) }
end

add = Proc.new { |a, b| a + b }
double = Proc.new { |x| x * 2 }
combined = compose_multi(double, add)
combined.call(2, 3) # Works correctly

Root cause:

Not using splat operator to forward multiple arguments causes argument errors.

#3 Mixing Procs and lambdas without considering their different behaviors.

Wrong approach:

proc_obj = Proc.new { |x| x + 1 }
lambda_obj = ->(x) { x * 2 }
composed = Proc.new { |x| proc_obj.call(lambda_obj.call(x)) }
composed.call() # No arguments given, but lambda expects one

Correct approach:

proc_obj = Proc.new { |x| x + 1 }
lambda_obj = ->(x) { x * 2 }
composed = Proc.new { |x| proc_obj.call(lambda_obj.call(x)) }
composed.call(5) # Pass argument to satisfy lambda

Root cause:

Lambdas enforce argument count strictly, unlike Procs, causing errors if arguments are missing.

Key Takeaways

Proc composition lets you build complex behavior by chaining small reusable code blocks.

Composition runs Procs right to left, so order matters and can affect results.

Handling multiple arguments in composed Procs requires forwarding arguments carefully.

Deep composition can impact performance due to nested calls and stack usage.

Understanding Proc vs lambda differences is crucial for safe and predictable composition.