Curry and partial application in Ruby - Mini Project: Build & Apply

Curry and partial application

📖 Scenario: Imagine you run a small bakery. You want to create a simple way to calculate the price of different baked goods with tax included. Instead of writing the tax calculation every time, you will use a technique called currying to make your code cleaner and easier to reuse.

🎯 Goal: Build a Ruby program that uses currying to create a function for calculating the price of baked goods including tax. You will start by creating a basic price calculator, then use currying to fix the tax rate, and finally calculate prices for different items.

📋 What You'll Learn

Create a method called calculate_price that takes two arguments: tax_rate and price.

Create a curried version of calculate_price called curried_calculate_price.

Use partial application to fix the tax rate at 0.08 (8%) and create a new function called price_with_tax.

Calculate the price with tax for an item costing 100 using price_with_tax.

Print the final price with tax.

💡 Why This Matters

🌍 Real World

Currying and partial application help programmers write cleaner and reusable code, especially when some inputs stay the same across many calculations, like tax rates in pricing.

💼 Career

Understanding currying is useful in functional programming and can improve your ability to write modular, maintainable code in Ruby and other languages.

1

Create the basic price calculator method

Write a method called calculate_price that takes two parameters: tax_rate and price. It should return the total price including tax by calculating price + price * tax_rate.

Ruby

# Define the calculate_price method with tax_rate and price parameters
# Your code here

Hint

Remember, a method in Ruby starts with def and ends with end. Use price + price * tax_rate to calculate the total.

2

Create a curried version of the method

Create a variable called curried_calculate_price that stores the curried version of the calculate_price method. Use the method(:calculate_price).to_proc.curry syntax.

Ruby

def calculate_price(tax_rate, price)
  price + price * tax_rate
end

# Create curried_calculate_price from calculate_price method
# Your code here

Hint

Use method(:calculate_price).to_proc.curry to get the curried version of the method.

3

Fix the tax rate using partial application

Create a new variable called price_with_tax by calling curried_calculate_price with the tax rate fixed at 0.08 (8%).

Ruby

def calculate_price(tax_rate, price)
  price + price * tax_rate
end

curried_calculate_price = method(:calculate_price).to_proc.curry

# Fix tax rate at 0.08 using partial application
# Your code here

Hint

Call curried_calculate_price with 0.08 to fix the tax rate.

4

Calculate and print the final price with tax

Use the price_with_tax function to calculate the price including tax for an item costing 100. Store the result in a variable called final_price. Then print final_price.

Ruby

def calculate_price(tax_rate, price)
  price + price * tax_rate
end

curried_calculate_price = method(:calculate_price).to_proc.curry

price_with_tax = curried_calculate_price.call(0.08)

# Calculate final_price for price 100 and print it
# Your code here

Hint

Call price_with_tax.call(100) to get the final price, then print it with puts.

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