Apply

In computer programming, apply applies a function to a list of arguments. Eval and apply are the two interdependent components of the eval-apply cycle, which is the essence of evaluating Lisp, described in SICP.[1] 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 param1 param2 ...

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,[6] 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

Universal property of the exponential object

The articles on exponential object and Cartesian closed category provide a more precise discussion of the category-theoretic formulation of this idea. Thus 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).[7] 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.