Curry and partial application in Ruby - Step-by-Step Execution

Concept Flow - Curry and partial application

Define multi-arg function

↓

Apply curry method

↓

Get curried function

↓

Call with one argument

↓

Return new function waiting for next arg

↓

Call with next argument

↓

Execute original function with all args

↓

Result

Currying transforms a function so you can call it with fewer arguments, returning a new function waiting for the rest.

Execution Sample

Ruby

def add(a, b)
  a + b
end
curried_add = method(:add).curry
add_five = curried_add.call(5)
result = add_five.call(3)

This code creates a curried version of add, then partially applies 5, and finally adds 3 to get 8.

Execution Table

Step	Action	Function State	Arguments Given	Result / Next Function
1	Define add method	add(a,b)	none	method(:add) created
2	Apply curry	curried_add	none	curried function expecting 2 args
3	Call curried_add with 5	waiting for 1 more arg	5	function waiting for 1 more arg
4	Call returned function with 3	waiting for 1 arg	3	executes add(5,3) = 8
5	Result stored	none	none	8

💡 All arguments provided, original function executed and returned 8

Variable Tracker

Variable	Start	After Step 3	After Step 4	Final
curried_add	curried function	curried function	curried function	curried function
add_five	undefined	function waiting for 1 arg	function waiting for 1 arg	function waiting for 1 arg
result	undefined	undefined	8	8

Key Moments - 2 Insights

Why does calling curried_add.call(5) not immediately give the sum?

Because currying returns a new function waiting for the remaining arguments, as shown in execution_table step 3.

What happens if you call the curried function with all arguments at once?

It executes immediately and returns the result, unlike partial calls that return new functions (see step 4).

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what does the function returned by curried_add.call(5) expect?

A No more arguments, it returns the result immediately

B One more argument to complete the call

C Two more arguments to complete the call

D It expects a block instead of arguments

💡 Hint

Check the 'Arguments Given' and 'Result / Next Function' columns at step 3

At which step does the original add method actually execute?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look for when the result 8 appears in the 'Result / Next Function' column

If you changed add_five = curried_add.call(5) to curried_add.call(5, 3), what would happen?

A add_five immediately becomes 8

B add_five becomes a function waiting for one argument

C An error occurs because too many arguments are given

D add_five becomes a function waiting for two arguments

💡 Hint

Recall that calling curried function with all arguments executes immediately (see key_moments answer 2)

Concept Snapshot

Currying in Ruby transforms a multi-argument method into a chain of single-argument functions.
Use method(:name).curry to get a curried function.
Calling it with fewer args returns a new function waiting for the rest.
Calling with all args executes the original method.
Partial application means calling with some args to get a new function.
Example: add_five = curried_add.call(5) creates a function adding 5.

Full Transcript

Currying changes a method so you can give arguments one at a time. First, you define a method with multiple arguments. Then you get a curried version using method(:name).curry. Calling this curried function with one argument returns a new function waiting for the next argument. When all arguments are given, the original method runs and returns the result. Partial application means giving some arguments early to get a new function that remembers those arguments. For example, calling curried_add.call(5) returns a function that adds 5 to its input. Calling that function with 3 returns 8. This step-by-step process helps break down complex calls into simpler parts.