Curry and partial application in Ruby

Introduction

Curry and partial application help you reuse functions by fixing some inputs early. This makes your code simpler and easier to understand.

When you want to create a new function by fixing some arguments of an existing function.

When you have a function that takes many inputs, but you often use it with some inputs the same.

When you want to break down complex tasks into smaller, reusable steps.

When you want to delay providing some inputs until later in your program.

When you want to write cleaner and more readable code by reusing functions.

Syntax

Ruby

curried_function = original_function.curry
partial_function = curried_function.call(fixed_arg1).call(fixed_arg2)

Use .curry on a Proc or lambda to enable currying.

Calling the curried function with fewer arguments returns a new function waiting for the rest.

Examples

This example creates a curried add function, then fixes the first number to 5, making a new function that adds 5 to any number.

Ruby

add = ->(a, b) { a + b }
curried_add = add.curry
add_five = curried_add.call(5)
puts add_five.call(3)  # Output: 8

Here, we fix the first two numbers (2 and 3) and get a new function that multiplies the result by the last number.

Ruby

multiply = ->(x, y, z) { x * y * z }
curried_multiply = multiply.curry
partial = curried_multiply.call(2).call(3)
puts partial.call(4)  # Output: 24

Sample Program

This program creates a greeting function, then fixes the greeting to "Hello". It then greets different people using the new function.

Ruby

greet = ->(greeting, name) { "#{greeting}, #{name}!" }
curried_greet = greet.curry
say_hello = curried_greet.call("Hello")
puts say_hello.call("Alice")
puts say_hello.call("Bob")

Important Notes

Currying works only on Procs or lambdas, not on regular methods directly.

Partial application is a practical use of currying where you fix some arguments early.

Currying helps make your code more modular and reusable.

Summary

Curry transforms a function so you can call it with fewer arguments and get a new function.

Partial application means fixing some arguments of a function to create a simpler function.

Ruby's .curry method makes currying easy with lambdas and Procs.

Practice

1. What does currying a function in Ruby allow you to do?

easy

A. Call the function with fewer arguments and get a new function

B. Run the function faster by optimizing code

C. Convert the function into a class method

D. Automatically memoize the function results

Solution

1. Step 1: Understand currying concept

   Currying transforms a function so you can call it with fewer arguments than it needs.

2. Step 2: Result of currying

   When called with fewer arguments, it returns a new function waiting for the rest.

3. Final Answer:

   Call the function with fewer arguments and get a new function -> Option A

4. Quick Check:

   Currying = call fewer args, get new function [OK]

Hint: Currying means breaking function calls into smaller steps [OK]

Common Mistakes:

• Thinking currying speeds up code
• Confusing currying with memoization
• Believing currying changes function to class method

2. Which of the following is the correct way to curry a lambda in Ruby?

easy

A. lambda.curry(my_lambda)

B. curry(my_lambda)

C. my_lambda.partial

D. my_lambda.curry

Solution

1. Step 1: Recall Ruby syntax for currying

   In Ruby, you call the .curry method on a lambda or Proc object.

2. Step 2: Identify correct usage

   Calling my_lambda.curry returns a curried version of the lambda.

3. Final Answer:

   my_lambda.curry -> Option D

4. Quick Check:

   Use .curry method on lambda object [OK]

Hint: Use .curry directly on lambda or Proc [OK]

Common Mistakes:

• Trying to call curry as a standalone function
• Using .partial instead of .curry
• Passing lambda as argument to curry method

3. What is the output of this Ruby code?

add = ->(x, y) { x + y }
curried_add = add.curry
add_five = curried_add.call(5)
puts add_five.call(3)

medium

A. 5

B. 3

C. 8

D. Error

Solution

1. Step 1: Understand currying and calls

   The lambda add takes two arguments and returns their sum. Currying allows calling with one argument to get a new function.

2. Step 2: Trace the calls

   curried_add.call(5) returns a new function that adds 5 to its argument. Calling add_five.call(3) returns 5 + 3 = 8.

3. Final Answer:

   8 -> Option C

4. Quick Check:

   Curried add with 5 then 3 = 8 [OK]

Hint: Currying splits args; add 5 + 3 = 8 [OK]

Common Mistakes:

• Expecting add_five to be a number, not a function
• Confusing call with direct invocation
• Thinking currying changes output type

4. Identify the error in this Ruby code using currying:

multiply = ->(x, y) { x * y }
curried_multiply = multiply.curry
result = curried_multiply(2)(3)
puts result

medium

A. multiply should be defined with def, not lambda

B. No error, code runs correctly and prints 6

C. curry method does not exist for lambdas

D. curried_multiply(2)(3) should be curried_multiply.call(2).call(3)

Solution

1. Step 1: Check syntax for currying and calling

   In Ruby, lambdas can be curried and called using parentheses like functions.

2. Step 2: Verify code behavior

   curried_multiply(2) returns a function that multiplies by 2; calling (3) returns 6. The code runs without error.

3. Final Answer:

   No error, code runs correctly and prints 6 -> Option B

4. Quick Check:

   Currying with lambdas and calls works as shown [OK]

Hint: Parentheses work for calling curried lambdas [OK]

Common Mistakes:

• Thinking .call is required for every call
• Believing curry is not available for lambdas
• Assuming lambdas must be defined with def

5. Given this code, what will be the output?

concat = ->(a, b, c) { "#{a}-#{b}-#{c}" }
curried_concat = concat.curry
partial = curried_concat.call('X').call('Y')
puts partial.call('Z')

What does this demonstrate about currying and partial application?

hard

A. You can fix some arguments step-by-step, creating simpler functions

B. Currying only works if all arguments are given at once

C. Partial application requires a special method, not currying

D. Calling curried functions with fewer arguments causes errors

Solution

1. Step 1: Analyze the currying calls

   The original lambda takes 3 arguments and joins them with dashes. Currying allows calling with one argument at a time.

2. Step 2: Understand partial application here

   Calling curried_concat.call('X') fixes the first argument. Then .call('Y') fixes the second. The resulting function waits for the third argument.

3. Step 3: Output and meaning

   Calling partial.call('Z') returns "X-Y-Z". This shows partial application by fixing some arguments step-by-step.

4. Final Answer:

   You can fix some arguments step-by-step, creating simpler functions -> Option A

5. Quick Check:

   Currying enables partial application stepwise [OK]

Hint: Currying lets you fix args one by one [OK]

Common Mistakes:

• Thinking all args must be given at once
• Confusing currying with separate partial method
• Assuming partial calls cause errors