Explore Black History

This article needs more citations. Please help improve this article by adding citations to reliable sources. Unsourced material may be challenged and removed. Find sources: "Function application" – news · newspapers · books · scholar · JSTOR (February 2024) (Learn how and when to remove this message)

In mathematics, function application (or evaluation) is the act of taking a function and an input from its domain to obtain the corresponding value from its range. In this sense, function application can be thought of as the opposite of function abstraction.^[1]

It is central to programming languages derived from lambda calculus, such as LISP and Scheme, and also in functional languages. It has a role in the study of the denotational semantics of computer programs, because it is a continuous function on complete partial orders. Function application is also a continuous function in homotopy theory, and, indeed underpins the entire theory: it allows a homotopy deformation to be viewed as a continuous path in the space of functions. Likewise, valid mutations (refactorings) of computer programs can be seen as those that are "continuous" in the Scott topology.

Function application is usually depicted by juxtaposing the variable representing the function with its argument encompassed in parentheses. For example, the following expression represents the application of the function ƒ to its argument x.

${\displaystyle f(x)}$

In some instances, a different notation is used where the parentheses aren't required, and function application can be expressed just by juxtaposition. For example, the following expression can be considered the same as the previous one:

${\displaystyle f\;x}$

The latter notation is especially useful in combination with the currying isomorphism. Given a function ${\displaystyle f:(X\times Y)\to Z}$, its application is represented as ${\displaystyle f(x,y)}$ by the former notation and ${\displaystyle f\;(x,y)}$ (or ${\displaystyle f\;\langle x,y\rangle }$ with the argument ${\displaystyle \langle x,y\rangle \in X\times Y}$ written with the less common angle brackets) by the latter. However, functions in curried form ${\displaystyle f:X\to (Y\to Z)}$ can be represented by juxtaposing their arguments: ${\displaystyle f\;x\;y}$, rather than ${\displaystyle f(x)(y)}$. This relies on function application being left-associative.

When mathematical notation is represented in a digital document, the invisible zero-width Unicode characters U+2061 FUNCTION APPLICATION and U+2062 INVISIBLE TIMES can be used to distinguish concatenation meaning function application from concatenation meaning multiplication.

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

${\displaystyle f\mathop {\,\$\,} 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\mathop {\,\$\,} g\mathop {\,\$\,} h\mathop {\,\$\,} j\mathop {\,\$\,} 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}$.

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:^[2]

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

Or, more formally:^[3][4]

$${\displaystyle X(Y)=z\iff (\exists D,R(X\in R^{D}\land ((Y,z)\in X)))\lor (\forall D,R(X\notin R^{D}\lor (Y,z)\notin X)\land 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.^[5]

If ${\displaystyle \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 \Psi }$ associates a unique object ${\displaystyle z}$: ${\displaystyle \forall X,Y\,\exists !z\,\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.

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 #'+ (list 1 2))

(apply + (list 1 2))

variadicFunc(arrayOfArgs);

Function<T,R>

R apply(T para)

s := []string{"foo", "bar"}
variadicFunc(s...)

func.apply(null, args);

function apply(f,...)
  return f(...)
end

# Equivalent subroutine calls:
@args = (@some_args, @more_args);
func(@args);

func(@some_args, @more_args);

call_user_func_array('func_name', $args);

func(*args)

f(x1, x2)
# can also be performed via
do.call(what = f, args = list(x1, x2))

aBlock valueWithArguments: args

apply func ?arg1 arg2 ...?

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 {\mbox{curry}}(g):X\to [Y\to Z]}$. Then Apply provides the universal morphism

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

so that

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

or, equivalently one has the commuting diagram

${\displaystyle {\mbox{Apply}}\circ \left({\mbox{curry}}(g)\times {\mbox{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,^[11] 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.

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).^[12] 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.

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

Look up apply in Wiktionary, the free dictionary.

• Evaluation strategy
• Execution (computing)
• Function composition
• Polish notation