Curry and partial application in Ruby - Deep Dive

Overview - Curry and partial application

What is it?

Currying and partial application are techniques to transform functions so they can be called with fewer arguments than they originally need. Currying turns a function that takes multiple arguments into a chain of functions each taking one argument. Partial application fixes some arguments of a function, creating a new function waiting for the rest. These help write clearer, reusable code by breaking down tasks into smaller steps.

Why it matters

Without currying and partial application, you often write repetitive code or complex functions that handle many inputs at once. These techniques let you create simpler, more flexible functions that can be reused in different situations. This reduces mistakes and makes your code easier to understand and maintain, especially in larger projects.

Where it fits

Before learning currying and partial application, you should understand how functions and arguments work in Ruby. After this, you can explore functional programming concepts like higher-order functions, lambdas, and method chaining to write more expressive code.

Mental Model

Core Idea

Currying and partial application let you break a multi-argument function into smaller functions by fixing some arguments early and waiting for the rest later.

Think of it like...

Imagine ordering a sandwich where you first choose the bread, then the filling, then the toppings, step by step. Currying is like taking your order one choice at a time, while partial application is like deciding the bread first and then asking for the rest later.

Function f(a, b, c)
  ↓ curry
f(a) → function waiting for b
  ↓
f(a)(b) → function waiting for c
  ↓
f(a)(b)(c) → final result

Partial application:
f(a, b, c)
  ↓ fix a=1
f_partial(b, c) = f(1, b, c)
  ↓ fix b=2
f_partial2(c) = f_partial(2, c)
  ↓ call with c=3
f_partial2(3) → final result

Build-Up - 7 Steps

1

Foundation

Understanding basic functions and arguments

Concept: Learn how Ruby functions take arguments and return values.

In Ruby, a method can take multiple arguments and return a value. For example: def add(a, b) a + b end add(2, 3) # returns 5 This is the starting point before we transform functions.

Result

You can call methods with all arguments at once and get results.

Knowing how functions accept arguments is essential before changing how you call them.

2

Foundation

Introducing lambdas and procs

Concept: Learn about Ruby's anonymous functions which support flexible argument handling.

Ruby has lambdas and procs which are like functions you can store in variables: add = ->(a, b) { a + b } add.call(2, 3) # returns 5 These let you pass functions around and prepare for currying.

Result

You can create and call functions stored in variables.

Understanding lambdas is key because currying works naturally with them.

3

Intermediate

Currying functions step-by-step

🤔Before reading on: do you think currying changes the function's behavior or just how you call it? Commit to your answer.

Concept: Currying transforms a function so it takes one argument at a time, returning new functions until all arguments are given.

Ruby lambdas can be curried using the `curry` method: add = ->(a, b) { a + b } curried_add = add.curry Now you can call: curried_add.call(2).call(3) # returns 5 Each call takes one argument and returns a new function until done.

Result

You can call a multi-argument function as a chain of single-argument calls.

Currying changes how you call functions without changing their core logic, enabling flexible argument passing.

4

Intermediate

Partial application by fixing arguments

🤔Before reading on: do you think partial application requires currying? Commit to your answer.

Concept: Partial application fixes some arguments of a function, creating a new function waiting for the rest.

You can use currying to partially apply arguments: add = ->(a, b, c) { a + b + c } curried_add = add.curry partial = curried_add.call(1).call(2) # fixes a=1, b=2 partial.call(3) # returns 6 This lets you reuse partial functions with some arguments preset.

Result

You get new functions with some arguments fixed, ready to complete later.

Partial application helps create specialized functions from general ones by presetting some inputs.

5

Intermediate

Using currying with methods and symbols

Concept: Currying works not only with lambdas but also with methods converted to procs.

You can curry methods by converting them: def multiply(a, b) a * b end curried_multiply = method(:multiply).to_proc.curry curried_multiply.call(4).call(5) # returns 20 This shows currying applies broadly in Ruby.

Result

You can curry existing methods for flexible calls.

Knowing how to curry methods expands currying's usefulness beyond lambdas.

6

Advanced

Combining multiple partial applications

🤔Before reading on: do you think applying partial arguments in different orders changes the final result? Commit to your answer.

Concept: You can partially apply arguments in steps, fixing some now and others later, in any order supported by currying.

Example: add = ->(a, b, c) { a + b + c } curried_add = add.curry partial1 = curried_add.call(1) # fixes a=1 partial2 = partial1.call(2) # fixes b=2 result = partial2.call(3) # returns 6 Or fix b first by rearranging arguments with lambdas. This flexibility helps build complex functions stepwise.

Result

You can build functions by fixing arguments in multiple stages.

Understanding argument order and partial application order prevents bugs in complex function chains.

7

Expert

Currying internals and performance considerations

🤔Before reading on: do you think currying creates new functions each call or reuses the same one? Commit to your answer.

Concept: Currying creates new function objects at each step, which can impact memory and performance if overused.

Each call to a curried function returns a new lambda waiting for the next argument. This means: - More objects are created - Deep chains can slow down execution Ruby's implementation balances flexibility with performance, but heavy currying in tight loops may need optimization or alternatives.

Result

Currying is powerful but can have hidden costs in resource use.

Knowing currying's runtime behavior helps write efficient code and avoid subtle performance issues.

Under the Hood

Currying works by transforming a multi-argument function into a chain of single-argument functions. Each call returns a new function that remembers the arguments given so far, waiting for the next one. Ruby implements this by creating new lambda objects at each step, capturing the fixed arguments in closures. When all arguments are collected, the original function logic runs with the full set.

Why designed this way?

Currying was introduced to support functional programming styles where functions are treated as values and composed flexibly. The design favors clarity and composability over raw speed. Alternatives like manually writing nested functions are error-prone and less reusable. Ruby's approach balances ease of use with the language's object-oriented nature.

Original function f(a, b, c)
  │
  ▼ curry
f_curried = f.curry
  │
  ├─ call(a) ──▶ returns function waiting for b and c
  │               │
  │               ├─ call(b) ──▶ returns function waiting for c
  │               │               │
  │               │               └─ call(c) ──▶ final result
  │               │
  │               └─ partial application fixes a
  │
  └─ partial application fixes some arguments early

Each call creates a new function object capturing fixed arguments.

Myth Busters - 4 Common Misconceptions

Quick: Does currying change what the function does or just how you call it? Commit to yes or no.

Common Belief: Currying changes the function's behavior or output.

Reality: Currying only changes how you call the function, not what it computes.

Why it matters: Thinking currying changes logic can confuse debugging and lead to unnecessary rewrites.

Quick: Is partial application only possible if a function is curried? Commit to yes or no.

Common Belief: Partial application requires currying first.

Reality: Partial application can be done without currying by manually fixing arguments or using other techniques.

Why it matters: Believing this limits how you can reuse functions and may cause overcomplicated code.

Quick: Does currying always improve performance? Commit to yes or no.

Common Belief: Currying makes code faster by simplifying calls.

Reality: Currying creates new function objects each call, which can slow down performance if overused.

Why it matters: Ignoring performance costs can cause slowdowns in critical code sections.

Quick: Can you partially apply arguments in any order with currying? Commit to yes or no.

Common Belief: You can fix arguments in any order freely with currying.

Reality: Currying fixes arguments in the order defined by the function's parameters; changing order requires extra work.

Why it matters: Misunderstanding argument order leads to bugs and unexpected results.

Expert Zone

1

Currying creates new closures at each step, so memory use grows with the number of partial calls.

2

Ruby's currying works best with lambdas because they enforce argument counts strictly, unlike procs.

3

Partial application can be combined with argument rearrangement using helper methods for more flexible APIs.

When NOT to use

Avoid currying when performance is critical and function calls are in tight loops; use direct calls or manual argument fixing instead. Also, if argument order flexibility is needed, consider libraries that support named parameters or argument reordering.

Production Patterns

In Ruby web frameworks, currying is used to create reusable filters or middleware by partially applying configuration. Functional gems use currying to build pipelines of transformations. Partial application helps create specialized callbacks or event handlers with preset context.

Connections

Function composition

Currying enables easier function composition by breaking functions into single-argument steps.

Understanding currying helps grasp how small functions combine smoothly to build complex behavior.

Closures in programming

Currying relies on closures to remember fixed arguments across calls.

Knowing closures clarifies how curried functions keep state between calls without global variables.

Manufacturing assembly lines

Currying is like an assembly line where each station adds one part until the product is complete.

Seeing currying as a stepwise assembly process reveals why breaking tasks into small steps improves flexibility and error handling.

Common Pitfalls

#1 Calling a curried function with all arguments at once.

Wrong approach:

add = ->(a, b) { a + b }
curried_add = add.curry
curried_add.call(2, 3) # wrong usage

Correct approach:

curried_add.call(2).call(3) # correct usage

Root cause:

Not realizing curried functions expect one argument per call, not all at once.

#2 Assuming partial application fixes arguments in any order without rearranging parameters.

Wrong approach:

add = ->(a, b, c) { a + b + c }
curried_add = add.curry
partial = curried_add.call(2).call(1) # wrong order

Correct approach:

partial = curried_add.call(1).call(2) # correct order

Root cause:

Misunderstanding that currying fixes arguments in parameter order.

#3 Using procs instead of lambdas for currying and expecting strict argument checking.

Wrong approach:

add = Proc.new { |a, b| a + b }
curried_add = add.curry
curried_add.call(2).call(3) # may behave unexpectedly

Correct approach:

add = ->(a, b) { a + b }
curried_add = add.curry
curried_add.call(2).call(3) # reliable behavior

Root cause:

Not knowing lambdas enforce argument counts strictly, unlike procs.

Key Takeaways

Currying transforms a multi-argument function into a chain of single-argument functions, enabling flexible calls.

Partial application fixes some arguments early, creating specialized functions for reuse.

Ruby's currying works best with lambdas and creates new function objects at each step.

Understanding argument order and closures is essential to use currying and partial application correctly.

While powerful, currying can impact performance and should be used thoughtfully in production code.