Mills ratio

Not to be confused with partial evaluation.

In computer science, partial application (or partial function application) refers to the process of fixing a number of arguments to a function, producing another function of smaller arity. Given a function $f:(X\times Y\times Z)\to N$, we might fix (or 'bind') the first argument, producing a function of type $\text{partial}(f):(Y\times Z)\to N$. Evaluation of this function might be represented as $f_{partial}(2,3)$. Note that the result of partial function application in this case is a function that takes two arguments.

Motivation

Intuitively, partial function application says "if you fix the first arguments of the function, you get a function of the remaining arguments". For example, if function div stands for the division operation x / y, then div with the parameter x fixed at 1 (i.e. div 1) is another function: the same as the function inv that returns the multiplicative inverse of its argument, defined by inv(y) = 1 / y.

The practical motivation for partial application is that very often the functions obtained by supplying some but not all of the arguments to a function are useful; for example, many languages have a function or operator similar to plus_one. Partial application makes it easy to define these functions, for example by creating a function that represents the addition operator with 1 bound as its first argument.

Implementations

In languages such as ML and Haskell functions are defined in curried form by default. Supplying fewer than the total number of arguments is referred to as partial application.

In languages with first-class functions one can define curry, uncurry and papply to perform currying and partial application explicitly. This might incur a greater run-time overhead due to the creation of additional closures, while Haskell can use more efficient techniques.

Scala implements optional partial application with multiple parameter lists, e.g. def add(x)(y) { x+y}; add(1) returns an incrementing function.

The C++ standard library provides bind(function, args..) to return a functor that is the result of partial application of the given arguments to the given function.

Definitions

In the simply-typed lambda calculus with function and product types (λ^→,×) partial application, currying and uncurrying can be defined as:

• papply  : (((a × b) → c) × a) → (b → c) = λ(f, x). λy. f (x, y)
• curry   : ((a × b) → c) → (a → (b → c)) = λf. λx. λy. f (x, y)
• uncurry : (a → (b → c)) → ((a × b) → c) = λf. λ(x, y). f x y

Note that curry papply = curry.

See also

• Currying
• η-conversion
• POP-2

Further reading

• Simon Marlow and Simon Peyton Jones (2004, 2006). "Making a Fast Curry: Push/Enter vs. Eval/Apply for Higher-order Languages". ICFP '04 Proceedings of the ninth ACM SIGPLAN international conference on Functional programming.
• Benjamin C. Pierce et al. "Partial Application", "Digression: Currying". Software Foundations.

External links

• Partial function application on Rosetta code.
• Partial application at Haskell Wiki

• Constant applicative form at Haskell Wiki
• The dangers of being too partial