# Introduction to Programming Languages/Partial Application

### Partial Application[edit]

In many programming languages, most notably in members of the functional paradigm such as ML and Haskell, every function takes only one argument as an input parameter. For instance, a ML function such as `add(x, y)`

does not receive two parameters, *x* and *y*, as one could, at first think. It receives one parameter: the tuple *(x, y)*:

- fun add(x, y) = x + y; val add = fn : int * int -> int - val t = (2, 3); val t = (2,3) : int * int - add t; val it = 5 : int

In order to give developers the illusion that a function takes several parameters, these languages resort to a technique called currying. A curried function such as *f(x)(y)* takes an argument *x*, and returns a new function that takes another argument *y*, and might use the value of *x* inside its body. As an example, the function below is the curried version of the previous implementation of `add`

:

- fun add_curry x y = x + y; val add_curry = fn : int -> int -> int - add_curry 2 3; val it = 5 : int

Usually we do not need to pass all the sequence of arguments expected by a curried function. If we pass only the prefix of this sequence of arguments, then we have a Partial Application. The result of a partial application is normally implemented as a closure. For instance, below we are using our `add_curry`

function as a function factory:

- fun add_curry a b = a + b; val add_curry = fn : int -> int -> int - val inc = add_curry 1; val inc = fn : int -> int - inc 2; val it = 3 : int - val sum2 = add_curry 2; val sum2 = fn : int -> int - sum2 2; val it = 4 : int