If you happen to have at least dabbled with the programming language Haskell, or one similar, you may be familiar with *currying*, aka partially applied functions. Partial function application is an important mechanic in functional programming. Functional programming is a hot topic these days: many of its core features are showing up in other languages, including Python.

A partially applied function is a function that has been given some arguments, but not all. In Haskell you might see a function declaration such as:

`add :: Integer -> Integer -> Integer`

add x y = x + y

Our traditional understanding of functions would lead us to believe that this declares a function `add`

which takes two integer arguments and returns an integer result which is the sum of the arguments. We would be wrong. This, in fact, declares a function that takes an integer and returns another function that takes an integer and returns one. I.e.

`add:: Integer -> (Integer -> Integer)`

When `add`

is called, it returns a function that has been partially applied (to the first argument). The resulting function can then be applied to the second (and final) argument to generate a result.

Normally, we'd call `add`

with both parameters:

`Prelude> add 2 3`

5

but because of being able to partially apply functions, we can call `add`

with one parameter and get a function back. For example:

`Prelude> inc = add 1`

`Prelude> :t inc`

`inc :: Num a => a -> a`

`inc`

is a function that takes an number and returns the number plus one. (`:t`

tells you the type of its argument) That function is essentially:

`inc y = 1 + y`

So now we can use `inc`

:

`Prelude> inc 2`

`3`

This is called currying in honor of Haskell Curry, after whom the Haskell language is also named.

This is just how things work in Haskell, but Python gives us the tools we need to do it there as well.