f@@expr or Apply[f,expr]

replaces the head of expr by f.

f@@@expr or Apply[f,expr,{1}]

replaces heads at level 1 of expr by f.


replaces heads in parts of expr specified by levelspec.


represents an operator form of Apply that can be applied to an expression.

Details and Options

  • Apply uses standard level specifications:
  • nlevels 1 through n
    Infinitylevels 1 through Infinity
    {n}level n only
    {n1,n2}levels n1 through n2
  • The default value for levelspec in Apply is {0}.
  • f@@@expr is equivalent to Apply[f,expr,{1}].
  • A positive level n consists of all parts of expr specified by n indices.
  • A negative level -n consists of all parts of expr with depth n.
  • Level -1 consists of numbers, symbols, and other objects that do not have subparts.
  • Level 0 corresponds to the whole expression.
  • Apply always effectively constructs a complete new expression and then evaluates it.
  • Apply operates on SparseArray objects just as it would on the corresponding ordinary lists.
  • Apply operates on values only in Association objects.
  • Apply[f][expr] is equivalent to Apply[f,expr].


open allclose all

Basic Examples  (7)

Apply gets rid of a level of lists:

Use the operator form of Apply:

Applying f to an Association keeps only values:

Applying a List to an Association is equivalent to Values:

Apply f at the second level:

Apply f at several levels:

Scope  (10)

Level Specifications  (10)

Apply at level 0 (default):

Apply at level 1:

The short form @@@ is equivalent to applying at level 1:

Apply at levels 0 and 1:

Apply down to level 2 (excluding level 0):

Apply at levels 0 through 2:

Apply at all levels, starting at level 1:

Apply also at level 0:

Negative levels:

Positive and negative levels can be mixed:

Different heads at each level:

Apply also inside heads at the levels specified:

Generalizations & Extensions  (2)

Apply works with any head, not just List:

Apply works on sparse arrays:

Options  (1)

Heads  (1)

Apply inside heads as well as arguments:

Applications  (4)

Display the factorization of an integer using superscripts:

Create a table from a list of range specifications:

Turn a function that takes several arguments into one that takes a list of arguments:

Find random co-prime integers:

Properties & Relations  (5)

Leaves are visited before roots:

Total does effectively the same thing as applying Plus to a list:

Using ## in a pure function has the same effect as using Apply:

Three ways to apply a function at level 1:

Ordinary function application takes the list as a single argument:

Apply takes the elements of the list as separate arguments:

Possible Issues  (1)

Applying to atomic objects that do not have subparts effectively does nothing:

Wolfram Research (1988), Apply, Wolfram Language function, (updated 2014).


Wolfram Research (1988), Apply, Wolfram Language function, (updated 2014).


Wolfram Language. 1988. "Apply." Wolfram Language & System Documentation Center. Wolfram Research. Last Modified 2014.


Wolfram Language. (1988). Apply. Wolfram Language & System Documentation Center. Retrieved from


@misc{reference.wolfram_2021_apply, author="Wolfram Research", title="{Apply}", year="2014", howpublished="\url{}", note=[Accessed: 24-May-2022 ]}


@online{reference.wolfram_2021_apply, organization={Wolfram Research}, title={Apply}, year={2014}, url={}, note=[Accessed: 24-May-2022 ]}