Currying Function in Python

Currying is a functional programming technique where a function with multiple arguments is transformed into a sequence of functions, each taking a single argument.

Mathematical Illustration

In currying, a function that takes multiple inputs is broken down into a series of single-argument functions, each processing one input at a time and ultimately returning the final result. For example:

f(x, y) = (x³) + (y³)
h(x) = x³
h(y) = y³
f(x, y) = h(x) + h(y)

Notice that, the use of currying avoids unnecessary repetition and makes the transformation clearer.

Let’s create a composite function where a(x) = b(c(d(x))), meaning that function d(x) is executed first, its output is passed to c(x) and finally, b(x) processes the result.

# Function to create a composite function using currying
def change(b, c, d):
    def a(x):
        return b(c(d(x))) 
    return a

# Example functions for transformation
def b(num):
    return num + 5 

def c(num):
    return num * 2

def d(num):
    return num - 3

# Creating a composed function
fun = change(b, c, d)

print(fun(10))

19

Explanation: change function takes three functions (b, c, d) and applies them in such order that the output of function d is passed to function c and then the output of c is passed to function b and the final output is stored in fun.

Lets discuss some of common use cases of Currying in Python with examples.

Unit Conversion

Let's try to convert kilometers to meters, then to centimeters and finally to feet using function composition, ensuring a structured, readable and reusable approach.

def change(b, c, d):
    def a(x):
        return b(c(d(x)))
    return a


def km_to_m(dist):
    """ Function that converts km to m. """
    return dist * 1000


def m_to_cm(dist):
    """ Function that converts m to cm. """
    return dist * 100


def cm_to_f(dist):
    """ Function that converts cm to ft. """
    return dist / 30.48

transform = change(cm_to_f, m_to_cm, km_to_m)
print(transform(565))

1853674.5406824148

Days To Seconds Conversion

In this example, we’ll convert time from days to hours, then to minutes and finally to seconds using function composition.

def change(b, c, d):
    def a(x):
        return b(c(d(x)))
    return a
    
def d_to_h(time): 
    """ Function that converts days to hours. """
    return time * 24
    
def h_to_m(time): 
    """ Function that converts hours to minutes. """
    return time * 60
    
def m_to_s(time):
    """ Function that converts minutes to seconds. """
    return time * 60
    
transform = change(m_to_s, h_to_m, d_to_h)
print(transform(10))
    

864000

Event Handling in GUI Applications

In GUI programming, event handlers are functions that respond to user actions such as button clicks, mouse movements or key presses. Currying can be useful in these scenarios by allowing us to predefine some arguments for event-handling functions while keeping the remaining arguments flexible. Lets discuss with an example of Button Click Handler in Python:

def button_click(action):
    def execute(event):
        print(f"Button clicked! Performing {action}")
    return execute

click_handler = button_click("Save")
click_handler(None)  

Button clicked! Performing Save

Explanation:

• This function takes an action (e.g., "Save" or "Delete") as input.
• It returns a new function (execute), which prints a message when called.
• The event parameter in execute(event) ensures compatibility with GUI frameworks like Tkinter, which pass event objects when calling event handlers.