Function application

As an operator

Function application can be defined as an operator, called apply or ${\displaystyle \mathrm{\$}}$, by the following definition:

${\displaystyle f\mathrm{\$}x=f(x)}$

The operator may also be denoted by a backtick (`).

If the operator is understood to be of low precedence and right-associative, the application operator can be used to cut down on the number of parentheses needed in an expression. For example;

${\displaystyle f(g(h(j(x))))}$

can be rewritten as:

${\displaystyle f\mathrm{\$}g\mathrm{\$}h\mathrm{\$}j\mathrm{\$}x}$

This can be equivalently expressed using function composition as:

${\displaystyle (f\circ g\circ h\circ j)(x)}$

or even:

${\displaystyle (f\circ g\circ h\circ j\circ x)()}$

if one considers ${\displaystyle x}$ to be a constant function returning ${\displaystyle x}$.

Set theory

In axiomatic set theory, especially Zermelo–Fraenkel set theory, a function ${\displaystyle f:D\mapsto R}$ is often defined as a relation (${\displaystyle f\subseteq D\times R}$) having the property that, for any ${\displaystyle x\in D}$ there is a unique ${\displaystyle y\in R}$ such that ${\displaystyle (x,y)\in f}$.

One is usually not content to write "${\displaystyle (x,y)\in f}$" to specify that ${\displaystyle y}$, and usually wishes for the more common function notation "${\displaystyle f(x)=y}$" . Function application, or more specifically, the notation "${\displaystyle f(x)}$", is not present in the usual signature of set theory, but may be added to the theory as a binary function symbol ${\displaystyle \bullet (\bullet )}$ if desired without any loss of expressiveness by defining:

$${\displaystyle X(Y)=\{\begin{array}{ll}z& \text{if }X\text{ is a function, and }(Y,z)\in X\\ \varnothing & \text{otherwise}\end{array}}$$

Or, more formally:

$${\displaystyle X(Y)=z⟺(\mathrm{\exists }D,R(X\in R^D\wedge ((Y,z)\in X)))\vee (\mathrm{\forall }D,R(X\notin R^D\vee (Y,z)\notin X)\wedge z=\varnothing ),}$$

where ${\displaystyle R^D}$ denotes set exponentiation: the set of all functions from ${\displaystyle D}$ to ${\displaystyle R}$.

In prose: ${\displaystyle X(Y)=z}$ if there exists a domain ${\displaystyle D}$ and range ${\displaystyle R}$ such that ${\displaystyle X}$ is a function from ${\displaystyle D}$ to ${\displaystyle R}$ and ${\displaystyle (Y,z)\in X}$; or (the negation of former) and ${\displaystyle z=\varnothing .}$ The choice of using the empty set ${\displaystyle \varnothing }$ when ${\displaystyle X(Y)}$ is undefined is arbitrary to ensure that the notation defined for the entire domain of discourse.

If ${\displaystyle \mathrm{\Psi }(X,Y,z)}$ denotes the formula on the right side of the biconditional above, for any two sets, ${\displaystyle X,Y}$ the formula ${\displaystyle \mathrm{\Psi }}$ associates a unique object ${\displaystyle z}$: ${\displaystyle \mathrm{\forall }X,Y\mathrm{\exists }!z\mathrm{\Psi }(X,Y,z)}$. Therefore the language of set theory can use an extension by definition to include the function application operation ${\displaystyle \bullet (\bullet )}$ conservatively.

Programming

In computer programming, function application often refers to calling or executing a procedure, rather than a true mathematical function (see functions in computer programing), with similar rules for its behavior.

Function application corresponds to beta reduction in lambda calculus.

Apply function

Related to the apply operator, the function apply applies a function to a variable list of arguments. Eval and apply are the two interdependent components of the eval-apply cycle in Lisp, described in SICP. This is supported in languages with variadic functions, because this is the only way to call a function with an indeterminate (at compile time) number of arguments.

Common Lisp and Scheme

In Common Lisp apply is a function that applies a function to a list of arguments (note here that "+" is a variadic function that takes any number of arguments):

<span id="mwtw"></span><span class="p" id="mwuA">(</span><span class="nb" id="mwuQ">apply</span><span class="w" id="mwug"> </span><span class="nf" id="mwuw">#'</span><span class="nb" id="mwvA">+</span><span class="w" id="mwvQ"> </span><span class="p" id="mwvg">(</span><span class="nb" id="mwvw">list</span><span class="w" id="mwwA"> </span><span class="mi" id="mwwQ">1</span><span class="w" id="mwwg"> </span><span class="mi" id="mwww">2</span><span class="p" id="mwxA">))</span>

Similarly in Scheme:

<span id="mwyA"></span><span class="p" id="mwyQ">(</span><span class="nb" id="mwyg">apply</span><span class="w" id="mwyw"> </span><span class="nb" id="mwzA">+</span><span class="w" id="mwzQ"> </span><span class="p" id="mwzg">(</span><span class="nb" id="mwzw">list</span><span class="w" id="mw0A"> </span><span class="mi" id="mw0Q">1</span><span class="w" id="mw0g"> </span><span class="mi" id="mw0w">2</span><span class="p" id="mw1A">))</span>

C++

In C++, Bind is used either via the std namespace or via the boost namespace.

C# and Java

In C# and Java, variadic arguments are simply collected in an array. Caller can explicitly pass in an array in place of the variadic arguments. This can only be done for a variadic parameter. It is not possible to apply an array of arguments to non-variadic parameter without using reflection. An ambiguous case arises should the caller want to pass an array itself as one of the arguments rather than using the array as a list of arguments. In this case, the caller should cast the array to Object to prevent the compiler from using the apply interpretation.

<span id="mw5g"></span><span class="n" id="mw5w">variadicFunc</span><span class="p" id="mw6A">(</span><span class="n" id="mw6Q">arrayOfArgs</span><span class="p" id="mw6g">);</span>

With version 8 lambda expressions were introduced. Functions are implemented as objects with a functional interface, an interface with only one non-static method. The standard interface

<span id="mw7g"></span><span class="n" id="mw7w">Function</span><span class="o" id="mw8A"><</span><span class="n" id="mw8Q">T</span><span class="p" id="mw8g">,</span><span class="n" id="mw8w">R</span><span class="o" id="mw9A">></span>

consist of the method (plus some static utility functions):

<span id="mw-A"></span><span class="n" id="mw-Q">R</span><span class="w" id="mw-g"> </span><span class="nf" id="mw-w">apply</span><span class="p" id="mw_A">(</span><span class="n" id="mw_Q">T</span><span class="w" id="mw_g"> </span><span class="n" id="mw_w">para</span><span class="p" id="mwAQA">)</span>

Go

In Go, typed variadic arguments are simply collected in a slice. The caller can explicitly pass in a slice in place of the variadic arguments, by appending a ... to the slice argument. This can only be done for a variadic parameter. The caller can not apply an array of arguments to non-variadic parameters, without using reflection..

<span id="mwAQc"></span><span class="nx" id="mwAQg">s</span><span class="w" id="mwAQk"> </span><span class="o" id="mwAQo">:=</span><span class="w" id="mwAQs"> </span><span class="p" id="mwAQw">[]</span><span class="kt" id="mwAQ0">string</span><span class="p" id="mwAQ4">{</span><span class="s" id="mwAQ8">"foo"</span><span class="p" id="mwARA">,</span><span class="w" id="mwARE"> </span><span class="s" id="mwARI">"bar"</span><span class="p" id="mwARM">}</span> <span class="nx" id="mwARQ">variadicFunc</span><span class="p" id="mwARU">(</span><span class="nx" id="mwARY">s</span><span class="p" id="mwARc">...)</span>

JavaScript

In JavaScript, function objects have an apply method, the first argument is the value of the this keyword inside the function; the second is the list of arguments:

<span id="mwAR8"></span><span class="nx" id="mwASA">func</span><span class="p" id="mwASE">.</span><span class="nx" id="mwASI">apply</span><span class="p" id="mwASM">(</span><span class="kc" id="mwASQ">null</span><span class="p" id="mwASU">,</span><span class="w" id="mwASY"> </span><span class="nx" id="mwASc">args</span><span class="p" id="mwASg">);</span>

ES6 adds the spread operator func(...args) which may be used instead of apply.

Lua

In Lua, apply can be written this way:

<span id="mwATY"></span><span class="kr" id="mwATc">function</span><span class="w" id="mwATg"> </span><span class="nf" id="mwATk">apply</span><span class="p" id="mwATo">(</span><span class="nv" id="mwATs">f</span><span class="p" id="mwATw">,...)</span> <span class="w" id="mwAT0"> </span><span class="kr" id="mwAT4">return</span><span class="w" id="mwAT8"> </span><span class="nf" id="mwAUA">f</span><span class="p" id="mwAUE">(...)</span> <span class="kr" id="mwAUI">end</span>

Perl

In Perl, arrays, hashes and expressions are automatically "flattened" into a single list when evaluated in a list context, such as in the argument list of a function

<span id="mwAUg"></span><span class="c1" id="mwAUk"># Equivalent subroutine calls:</span> <span class="nv" id="mwAUo">@args</span><span class="w" id="mwAUs"> </span><span class="o" id="mwAUw">=</span><span class="w" id="mwAU0"> </span><span class="p" id="mwAU4">(</span><span class="nv" id="mwAU8">@some_args</span><span class="p" id="mwAVA">,</span><span class="w" id="mwAVE"> </span><span class="nv" id="mwAVI">@more_args</span><span class="p" id="mwAVM">);</span> <span class="n" id="mwAVQ">func</span><span class="p" id="mwAVU">(</span><span class="nv" id="mwAVY">@args</span><span class="p" id="mwAVc">);</span> <span class="n" id="mwAVg">func</span><span class="p" id="mwAVk">(</span><span class="nv" id="mwAVo">@some_args</span><span class="p" id="mwAVs">,</span><span class="w" id="mwAVw"> </span><span class="nv" id="mwAV0">@more_args</span><span class="p" id="mwAV4">);</span>

PHP

In PHP, apply is called call_user_func_array:

<span id="mwAWY"></span><span class="nb" id="mwAWc">call_user_func_array</span><span class="p" id="mwAWg">(</span><span class="s1" id="mwAWk">'func_name'</span><span class="p" id="mwAWo">,</span> <span class="nv" id="mwAWs">$args</span><span class="p" id="mwAWw">);</span>

Python and Ruby

In Python and Ruby, the same asterisk notation used in defining variadic functions is used for calling a function on a sequence and array respectively:

<span id="mwAXQ"></span><span class="n" id="mwAXU">func</span><span class="p" id="mwAXY">(</span><span class="o" id="mwAXc">*</span><span class="n" id="mwAXg">args</span><span class="p" id="mwAXk">)</span>

Python originally had an apply function, but this was deprecated in favour of the asterisk in 2.3 and removed in 3.0.

R

In R, do.call constructs and executes a function call from a name or a function and a list of arguments to be passed to it:

<span id="mwAYY"></span><span class="nf" id="mwAYc">f</span><span class="p" id="mwAYg">(</span><span class="n" id="mwAYk">x1</span><span class="p" id="mwAYo">,</span><span class="w" id="mwAYs"> </span><span class="n" id="mwAYw">x2</span><span class="p" id="mwAY0">)</span> <span class="c1" id="mwAY4"># can also be performed via</span> <span class="nf" id="mwAY8">do.call</span><span class="p" id="mwAZA">(</span><span class="n" id="mwAZE">what</span><span class="w" id="mwAZI"> </span><span class="o" id="mwAZM">=</span><span class="w" id="mwAZQ"> </span><span class="n" id="mwAZU">f</span><span class="p" id="mwAZY">,</span><span class="w" id="mwAZc"> </span><span class="n" id="mwAZg">args</span><span class="w" id="mwAZk"> </span><span class="o" id="mwAZo">=</span><span class="w" id="mwAZs"> </span><span class="nf" id="mwAZw">list</span><span class="p" id="mwAZ0">(</span><span class="n" id="mwAZ4">x1</span><span class="p" id="mwAZ8">,</span><span class="w" id="mwAaA"> </span><span class="n" id="mwAaE">x2</span><span class="p" id="mwAaI">))</span>

Smalltalk

In Smalltalk, block (function) objects have a valueWithArguments: method which takes an array of arguments:

<span id="mwAak"></span><span class="nv" id="mwAao">aBlock</span> <span class="nf" id="mwAas">valueWithArguments:</span> <span class="nv" id="mwAaw">args</span>

Tcl

Since Tcl 8.5, a function can be applied to arguments with the apply command

<span id="mwAbc"></span><span class="k" id="mwAbg">apply</span><span class="w" id="mwAbk"> </span>func<span class="w" id="mwAbo"> </span><span class="o" id="mwAbs">?</span>arg1<span class="w" id="mwAbw"> </span>arg2<span class="w" id="mwAb0"> </span>...<span class="o" id="mwAb4">?</span>

where the function is a two element list {args body} or a three element list {args body namespace}.

Universal property

Consider a function ${\displaystyle g:(X\times Y)\to Z}$, that is, ${\displaystyle g\in [(X\times Y)\to Z]}$ where the bracket notation ${\displaystyle [A\to B]}$ denotes the space of functions from A to B. By means of currying, there is a unique function ${\displaystyle \text{curry}(g):X\to [Y\to Z]}$. Then Apply provides the universal morphism

${\displaystyle \text{Apply}:([Y\to Z]\times Y)\to Z}$,

so that

${\displaystyle \text{Apply}(f,y)=f(y)}$

or, equivalently one has the commuting diagram

${\displaystyle \text{Apply}\circ \left(\text{curry}(g)\times {\text{id}}_Y\right)=g}$

More precisely, curry and apply are adjoint functors.

The notation ${\displaystyle [A\to B]}$ for the space of functions from A to B occurs more commonly in computer science. In category theory, however, ${\displaystyle [A\to B]}$ is known as the exponential object, and is written as ${\displaystyle B^A}$. There are other common notational differences as well; for example Apply is often called Eval, even though in computer science, these are not the same thing, with eval distinguished from Apply, as being the evaluation of the quoted string form of a function with its arguments, rather than the application of a function to some arguments.

Also, in category theory, curry is commonly denoted by ${\displaystyle \lambda }$, so that ${\displaystyle \lambda g}$ is written for curry(g). This notation is in conflict with the use of ${\displaystyle \lambda }$ in lambda calculus, where lambda is used to denote bound variables. With all of these notational changes accounted for, the adjointness of Apply and curry is then expressed in the commuting diagram

The articles on exponential object and Cartesian closed category provide a more precise discussion of the category-theoretic formulation of this idea. Thus the use of lambda here is not accidental; the internal language of Cartesian closed categories is simply typed lambda calculus. The most general possible setting for Apply are the closed monoidal categories, of which the cartesian closed categories are an example. In homological algebra, the adjointness of curry and apply is known as tensor-hom adjunction.

Topological properties

In order theory, in the category of complete partial orders endowed with the Scott topology, both curry and apply are continuous functions (that is, they are Scott continuous). This property helps establish the foundational validity of the study of the denotational semantics of computer programs.

In algebraic geometry and homotopy theory, curry and apply are both continuous functions when the space ${\displaystyle Y^X}$ of continuous functions from ${\displaystyle X}$ to ${\displaystyle Y}$ is given the compact open topology, and ${\displaystyle X}$ is locally compact Hausdorff. This result is very important, in that it underpins homotopy theory, allowing homotopic deformations to be understood as continuous paths in the space of functions.

Other instances

The Curry–Howard correspondence relates function application to the logical rule of modus ponens.