Amar Prakash Pandey Amar Prakash Pandey aka @amarlearning

Currying and Partial Application: Shaping Intent

banner

Why this topic is confusing

Currying and partial application are concepts that almost every Python developer has seen, but very few feel confident using. For a long time, I understood what they did, but I didn’t know when using them actually made code better.


A clear distinction: currying vs partial application

Currying transforms a function that takes multiple arguments into a chain of functions that each take a single argument:

python
def multiply(a):
    def by(b):
        return a * b
    return by

# Usage: multiply(3)(4) returns 12
triple = multiply(3)
result = triple(4)  # 12

Partial application fixes some arguments of an existing function and returns a new callable:

python
from functools import partial

def multiply(a, b):
    return a * b

# Create specialized functions
double = partial(multiply, 2)
triple = partial(multiply, 3)

print(double(5))  # 10
print(triple(4))  # 12

Currying changes the shape of a function; partial application configures a function.


Where functools.partial actually helps

Partial application became useful to me once I started seeing it as a way to name behavior.

python
from functools import partial

# Instead of repeating the same sorting logic
fruits = ["apple", "banana", "cherry", "date"]
words = ["hello", "world", "python", "code"]

# Create reusable, named behaviors
sort_by_length = partial(sorted, key=len)
sort_reverse = partial(sorted, reverse=True)

print(sort_by_length(fruits))   # ['date', 'apple', 'banana', 'cherry']
print(sort_reverse(words))      # ['world', 'python', 'hello', 'code']

sort_by_length and sort_reverse communicate purpose clearly - no mental parsing required.


Reducing lambda noise

Partial application helps clean up map and filter operations:

python
from functools import partial

def add_tax(price, tax_rate):
    return price * (1 + tax_rate)

prices = [100, 200, 150, 300]

# Before - lambda creates noise and repetition
with_sales_tax = list(map(lambda p: add_tax(p, 0.08), prices))

# After - partial creates clarity and reusability
add_sales_tax = partial(add_tax, tax_rate=0.08)
with_sales_tax = list(map(add_sales_tax, prices))

print(with_sales_tax)  # [108.0, 216.0, 162.0, 324.0]

The add_sales_tax function can be reused anywhere, and the intent is crystal clear.


Configuration now, execution later

One of the most practical uses of partial is separating configuration from execution:

python
import logging
from functools import partial

# Set up logger
logger = logging.getLogger("PaymentService")

# Configure different log levels with context
log_payment_error = partial(logger.error, extra={"service": "payment"})
log_payment_info = partial(logger.info, extra={"service": "payment"})

# Usage throughout your code - clean and consistent
def process_payment(amount):
    try:
        # payment logic here
        log_payment_info(f"Payment processed: ${amount}")
    except Exception as e:
        log_payment_error(f"Payment failed: {e}")
        
# Another example: API client configuration
import requests
from functools import partial

# Configure once
api_get = partial(requests.get, timeout=30, headers={"User-Agent": "MyApp/1.0"})
api_post = partial(requests.post, timeout=30, headers={"User-Agent": "MyApp/1.0"})

# Use everywhere without repeating configuration
response = api_get("https://api.example.com/users")

This keeps call sites clean and configuration centralized.


When NOT to use these tools

Don’t use partial application when it makes code harder to understand:

python
# BAD - Over-engineered for simple cases
from functools import partial
add_one = partial(lambda x, y: x + y, 1)
result = add_one(5)  # Just write: result = 5 + 1

# BAD - Too many layers of abstraction
process_data = partial(partial(map, str.upper), ["hello", "world"])

# GOOD - Simple and direct
data = ["hello", "world"]
result = [item.upper() for item in data]

Use partial application when it names intent and reduces repetition. Skip it when a direct approach is clearer.

Thanks for reading! If this one was useful, there's more where it came from in the archive, and you can see what I'm building next on GitHub.

Comments