Partial application

Implementations

In languages such as ML, Haskell and F#, 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 placeholder, e.g. def add(x: Int, y: Int) = {x+y}; add(1, _: Int) returns an incrementing function. Scala also supports multiple parameter lists as currying, e.g. def add(x: Int)(y: Int) = {x+y}; add(1) _.

Clojure implements partial application using the partial function defined in its core library.

The C++ standard library provides bind(function, args..) to return a function object that is the result of partial application of the given arguments to the given function. Since C++20 the function bind_front(function, args...) is also provided which binds the first sizeof...(args) arguments of the function to the args. In contrast, bind allows binding any of the arguments of the function passed to it, not just the first ones. Alternatively, lambda expressions can be used:

<span id="mwiQ"></span><span class="kt" id="mwig">int</span><span class="w" id="mwiw"> </span><span class="nf" id="mwjA">f</span><span class="p" id="mwjQ">(</span><span class="kt" id="mwjg">int</span><span class="w" id="mwjw"> </span><span class="n" id="mwkA">a</span><span class="p" id="mwkQ">,</span><span class="w" id="mwkg"> </span><span class="kt" id="mwkw">int</span><span class="w" id="mwlA"> </span><span class="n" id="mwlQ">b</span><span class="p" id="mwlg">);</span> <span class="k" id="mwlw">auto</span><span class="w" id="mwmA"> </span><span class="n" id="mwmQ">f_partial</span><span class="w" id="mwmg"> </span><span class="o" id="mwmw">=</span><span class="w" id="mwnA"> </span><span class="p" id="mwnQ">[](</span><span class="kt" id="mwng">int</span><span class="w" id="mwnw"> </span><span class="n" id="mwoA">a</span><span class="p" id="mwoQ">)</span><span class="w" id="mwog"> </span><span class="p" id="mwow">{</span><span class="w" id="mwpA"> </span><span class="k" id="mwpQ">return</span><span class="w" id="mwpg"> </span><span class="n" id="mwpw">f</span><span class="p" id="mwqA">(</span><span class="n" id="mwqQ">a</span><span class="p" id="mwqg">,</span><span class="w" id="mwqw"> </span><span class="mi" id="mwrA">123</span><span class="p" id="mwrQ">);</span><span class="w" id="mwrg"> </span><span class="p" id="mwrw">};</span> <span class="n" id="mwsA">assert</span><span class="p" id="mwsQ">(</span><span class="n" id="mwsg">f_partial</span><span class="p" id="mwsw">(</span><span class="mi" id="mwtA">456</span><span class="p" id="mwtQ">)</span><span class="w" id="mwtg"> </span><span class="o" id="mwtw">==</span><span class="w" id="mwuA"> </span><span class="n" id="mwuQ">f</span><span class="p" id="mwug">(</span><span class="mi" id="mwuw">456</span><span class="p" id="mwvA">,</span><span class="w" id="mwvQ"> </span><span class="mi" id="mwvg">123</span><span class="p" id="mwvw">)</span><span class="w" id="mwwA"> </span><span class="p" id="mwwQ">);</span>

In Java, MethodHandle.bindTo partially applies a function to its first argument. Alternatively, since Java 8, lambdas can be used:

<span id="mwyw"></span><span class="kd" id="mwzA">public</span><span class="w" id="mwzQ"> </span><span class="kd" id="mwzg">static</span><span class="w" id="mwzw"> </span><span class="o" id="mw0A"><</span><span class="n" id="mw0Q">A</span><span class="p" id="mw0g">,</span><span class="w" id="mw0w"> </span><span class="n" id="mw1A">B</span><span class="p" id="mw1Q">,</span><span class="w" id="mw1g"> </span><span class="n" id="mw1w">R</span><span class="o" id="mw2A">></span><span class="w" id="mw2Q"> </span><span class="n" id="mw2g">Function</span><span class="o" id="mw2w"><</span><span class="n" id="mw3A">B</span><span class="p" id="mw3Q">,</span><span class="w" id="mw3g"> </span><span class="n" id="mw3w">R</span><span class="o" id="mw4A">></span><span class="w" id="mw4Q"> </span><span class="nf" id="mw4g">partialApply</span><span class="p" id="mw4w">(</span><span class="n" id="mw5A">BiFunction</span><span class="o" id="mw5Q"><</span><span class="n" id="mw5g">A</span><span class="p" id="mw5w">,</span><span class="w" id="mw6A"> </span><span class="n" id="mw6Q">B</span><span class="p" id="mw6g">,</span><span class="w" id="mw6w"> </span><span class="n" id="mw7A">R</span><span class="o" id="mw7Q">></span><span class="w" id="mw7g"> </span><span class="n" id="mw7w">biFunc</span><span class="p" id="mw8A">,</span><span class="w" id="mw8Q"> </span><span class="n" id="mw8g">A</span><span class="w" id="mw8w"> </span><span class="n" id="mw9A">value</span><span class="p" id="mw9Q">)</span><span class="w" id="mw9g"> </span><span class="p" id="mw9w">{</span> <span class="w" id="mw-A"> </span><span class="k" id="mw-Q">return</span><span class="w" id="mw-g"> </span><span class="n" id="mw-w">b</span><span class="w" id="mw_A"> </span><span class="o" id="mw_Q">-></span><span class="w" id="mw_g"> </span><span class="n" id="mw_w">biFunc</span><span class="p" id="mwAQA">.</span><span class="na" id="mwAQE">apply</span><span class="p" id="mwAQI">(</span><span class="n" id="mwAQM">value</span><span class="p" id="mwAQQ">,</span><span class="w" id="mwAQU"> </span><span class="n" id="mwAQY">b</span><span class="p" id="mwAQc">);</span> <span class="p" id="mwAQg">}</span>

In Raku, the assuming method creates a new function with fewer parameters.

The Python standard library module functools includes the partial function, allowing positional and named argument bindings, returning a new function.

In XQuery, an argument placeholder (?) is used for each non-fixed argument in a partial function application.

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.

Mathematical formulation and examples

Partial application can be a useful way to define several useful notions in mathematics.

Given sets ${\displaystyle X,Y}$ and ${\displaystyle Z}$, and a function ${\displaystyle f:X\times Y\to Z}$, one can define the function

${\displaystyle f(\cdot ,-):X\to (Y\to Z),}$

where ${\displaystyle (Y\to Z)}$ is the set of functions ${\displaystyle Y\to Z}$. The image of ${\displaystyle x\in X}$ under this map is ${\displaystyle f(x,\cdot ):Y\to Z}$. This is the function which sends ${\displaystyle y\in Y}$ to ${\displaystyle f(x,y)}$. There are often structures on ${\displaystyle X,Y,Z}$ which mean that the image of ${\displaystyle f(\cdot ,-)}$ restricts to some subset of functions ${\displaystyle Y\to Z}$, as illustrated in the following examples.

Group actions

A group action can be understood as a function ${\displaystyle \ast :G\times X\to X}$. The partial evaluation ${\displaystyle \rho :G\to \text{Sym}(X)\subset (X\to X)}$ restricts to the group of bijections from ${\displaystyle X}$ to itself. The group action axioms further ensure ${\displaystyle \rho }$ is a group homomorphism.

Inner-products and canonical map to the dual

An inner-product on a vector space ${\displaystyle V}$ over a field ${\displaystyle K}$ is a map ${\displaystyle \varphi :V\times V\to K}$. The partial evaluation provides a canonical map to the dual vector space, ${\displaystyle \varphi (\cdot ,-):V\to V^{\ast }\subset (V\to K)}$. If this is the inner-product of a Hilbert space, the Riesz representation theorem ensures this is an isomorphism.

Cross-products and the adjoint map for Lie algebras

The partial application of the cross product ${\displaystyle \times }$ on ${\displaystyle {\mathbb{R}}^3}$ is ${\displaystyle \times (\cdot ,-):{\mathbb{R}}^3\mapsto \text{End}({\mathbb{R}}^3)}$. The image of the vector ${\displaystyle \mathbf{u}}$ is a linear map ${\displaystyle T_{\mathbf{u}}}$ such that ${\displaystyle T_{\mathbf{u}}(\mathbf{v})=\mathbf{u}\times \mathbf{v}}$. The components of ${\displaystyle T_{\mathbf{u}}}$ can be found to be ${\displaystyle (T_{\mathbf{u}}{)}_{ij}={ϵ}_{ijk}{u}_k}$.

This is closely related to the adjoint map for Lie algebras. Lie algebras are equipped with a bracket ${\displaystyle [\cdot ,\cdot ]:\mathfrak{g}\times \mathfrak{g}\to \mathfrak{g}}$. The partial application gives a map ${\displaystyle \text{ad}:\mathfrak{g}\to \text{End}(\mathfrak{g})}$. The axioms for the bracket ensure this map is a homomorphism of Lie algebras.