Currying a Dyadic Function

Suppose we have some \(f(a, b)\) where a and b are strings, and the function prints a + ": " + b. So, \(f\)("hello", "world"), the console would show "hello: world". Pretty simple. Suppose, for some reason, I want to derive a function \(g(b)\) that does the same thing as \(f\), but always says "hello: ", and then whatever you pass in as b. Basically, I'd like to hold the "a" argument constant for this new function g.

One obvious way to do this is to make a whole new function that repeats code from \(f\), just making the "a" parameter constant. It turns out that some functions take a lot of code, so duplicating the function would get messy. If your programming language supports passing functions around as arguments, you can do what's called "currying" a function, which allows us to pass in arguments we want held constant, and get back a function. Specifically, this is what would be called "currying a dyadic function" because \(f\) takes two arguments.

Here's how currying a dyadic function would look:

function f(a, b) {
    print a + ": " + b
}

function curry_f (a) {
    return function (b) {
        f(a, b);
    }
}

Notice that I didn't call f when I call curry_f. The function curry_f returns another function that holds the argument given to it constant. So, if I called 'curry_f("hello")' then I would get back a function that's like f but always says "hello" first. Cool, right?

Using curry_f to produce g:

f("hello", "world") # would print "hello: world"
g = curry_f("hello") # now g is the function we want
g("goodbye") # would print "hello: goodbye"

Currying Versus Partial Function Application

The differences between currying and partial function application are subtle because they do similar things. From what I understand, currying breaks the original function into all of its pieces by argument, so you'd get a bunch of unary functions, whereas partial function application can leave functions with two or more arguments left. You could partially apply a three argument function to hold one argument constant and end up with a dyadic function, but if you say "I'm going to curry that three argument function" you imply that you're going to split it into 3 unary functions.

Home

Currying a Dyadic Function

what?

Currying Versus Partial Function Application