Anonymous function

Uses

Anonymous functions can encapsulate functionality that does not require naming and is intended for short-term or localized use. Some notable examples include closures and currying.

The use of anonymous functions is a matter of style. Using them is never the only way to solve a problem; each anonymous function could instead be defined as a named function and called by name. Anonymous functions often provide a briefer notation than defining named functions. In languages that do not permit the definition of named functions in local scopes, anonymous functions may provide encapsulation via localized scope, however the code in the body of such anonymous function may not be re-usable, or amenable to separate testing. Short/simple anonymous functions used in expressions may be easier to read and understand than separately defined named functions, though lacking a descriptive name may reduce code readability.

In some programming languages, anonymous functions are commonly implemented for very specific purposes such as binding events to callbacks or instantiating the function for particular values, which may be more efficient in a Dynamic programming language, more readable, and less error-prone than calling a named function.

The following examples are written in Python 3.

Sorting

Many languages provide a generic function that sorts a list (or array) of objects into an order determined by a comparison function which compares two objects to determine if they are equal or if one is greater or less than the other. Using an anonymous comparison function expression passed as an argument to a generic sort function is often more concise than creating a named comparison function.

Consider this Python code sorting a list of strings by length of the string:

<span id="mwTg"></span><span class="n" id="mwTw">a</span><span class="p" id="mwUA">:</span> <span class="nb" id="mwUQ">list</span><span class="p" id="mwUg">[</span><span class="nb" id="mwUw">str</span><span class="p" id="mwVA">]</span> <span class="o" id="mwVQ">=</span> <span class="p" id="mwVg">[</span><span class="s2" id="mwVw">"house"</span><span class="p" id="mwWA">,</span> <span class="s2" id="mwWQ">"car"</span><span class="p" id="mwWg">,</span> <span class="s2" id="mwWw">"bike"</span><span class="p" id="mwXA">]</span> <span class="n" id="mwXQ">a</span><span class="o" id="mwXg">.</span><span class="n" id="mwXw">sort</span><span class="p" id="mwYA">(</span><span class="n" id="mwYQ">key</span> <span class="o" id="mwYg">=</span> <span class="k" id="mwYw">lambda</span> <span class="n" id="mwZA">x</span><span class="p" id="mwZQ">:</span> <span class="nb" id="mwZg">len</span><span class="p" id="mwZw">(</span><span class="n" id="mwaA">x</span><span class="p" id="mwaQ">))</span> <span class="nb" id="mwag">print</span><span class="p" id="mwaw">(</span><span class="n" id="mwbA">a</span><span class="p" id="mwbQ">)</span> <span class="c1" id="mwbg"># prints ['car', 'bike', 'house']</span>

The anonymous function in this example is the lambda expression:

<span id="mwcg"></span><span class="k" id="mwcw">lambda</span> <span class="n" id="mwdA">x</span><span class="p" id="mwdQ">:</span> <span class="nb" id="mwdg">len</span><span class="p" id="mwdw">(</span><span class="n" id="mweA">x</span><span class="p" id="mweQ">)</span>

The anonymous function accepts one argument, x, and returns the length of its argument, which is then used by the sort() method as the criteria for sorting.

Basic syntax of a lambda function in Python is

<span id="mwgA"></span><span class="k" id="mwgQ">lambda</span> <span class="n" id="mwgg">arg1</span><span class="p" id="mwgw">,</span> <span class="n" id="mwhA">arg2</span><span class="p" id="mwhQ">,</span> <span class="n" id="mwhg">arg3</span><span class="p" id="mwhw">,</span> <span class="o" id="mwiA">...</span><span class="p" id="mwiQ">:</span> <span class="o" id="mwig"><</span><span class="n" id="mwiw">operation</span> <span class="n" id="mwjA">on</span> <span class="n" id="mwjQ">the</span> <span class="n" id="mwjg">arguments</span> <span class="n" id="mwjw">returning</span> <span class="n" id="mwkA">a</span> <span class="n" id="mwkQ">value</span><span class="o" id="mwkg">></span>

The expression returned by the lambda function can be assigned to a variable and used in the code at multiple places.

<span id="mwlg"></span><span class="kn" id="mwlw">from</span><span class="w" id="mwmA"> </span><span class="nn" id="mwmQ">typing</span><span class="w" id="mwmg"> </span><span class="kn" id="mwmw">import</span> <span class="n" id="mwnA">Callable</span> <span class="n" id="mwnQ">add</span><span class="p" id="mwng">:</span> <span class="n" id="mwnw">Callable</span><span class="p" id="mwoA">[[</span><span class="nb" id="mwoQ">int</span><span class="p" id="mwog">],</span> <span class="nb" id="mwow">int</span><span class="p" id="mwpA">]</span> <span class="o" id="mwpQ">=</span> <span class="k" id="mwpg">lambda</span> <span class="n" id="mwpw">a</span><span class="p" id="mwqA">:</span> <span class="n" id="mwqQ">a</span> <span class="o" id="mwqg">+</span> <span class="n" id="mwqw">a</span> <span class="nb" id="mwrA">print</span><span class="p" id="mwrQ">(</span><span class="n" id="mwrg">add</span><span class="p" id="mwrw">(</span><span class="mi" id="mwsA">20</span><span class="p" id="mwsQ">))</span> <span class="c1" id="mwsg"># prints 40</span>

Another example would be sorting items in a list by the name of their class (in Python, everything has a class):

<span id="mwtg"></span><span class="n" id="mwtw">a</span><span class="p" id="mwuA">:</span> <span class="nb" id="mwuQ">list</span><span class="p" id="mwug">[</span><span class="nb" id="mwuw">int</span> <span class="o" id="mwvA">|</span> <span class="nb" id="mwvQ">str</span><span class="p" id="mwvg">]</span> <span class="o" id="mwvw">=</span> <span class="p" id="mwwA">[</span><span class="mi" id="mwwQ">10</span><span class="p" id="mwwg">,</span> <span class="s2" id="mwww">"number"</span><span class="p" id="mwxA">,</span> <span class="mf" id="mwxQ">11.2</span><span class="p" id="mwxg">]</span> <span class="n" id="mwxw">a</span><span class="o" id="mwyA">.</span><span class="n" id="mwyQ">sort</span><span class="p" id="mwyg">(</span><span class="n" id="mwyw">key</span><span class="o" id="mwzA">=</span><span class="k" id="mwzQ">lambda</span> <span class="n" id="mwzg">x</span><span class="p" id="mwzw">:</span> <span class="n" id="mw0A">x</span><span class="o" id="mw0Q">.</span><span class="vm" id="mw0g">__class__</span><span class="o" id="mw0w">.</span><span class="vm" id="mw1A">__name__</span><span class="p" id="mw1Q">)</span> <span class="nb" id="mw1g">print</span><span class="p" id="mw1w">(</span><span class="n" id="mw2A">a</span><span class="p" id="mw2Q">)</span> <span class="c1" id="mw2g"># prints [11.2, 10, 'number']</span>

Note that 11.2 has class name "float", 10 has class name "int", and 'number' has class name "str". The sorted order is "float", "int", then "str".

Closures

Closures are functions evaluated in an environment containing bound variables. The following example binds the variable "threshold" within an anonymous function that compares input values to this threshold.

<span id="mw7A"></span><span class="k" id="mw7Q">def</span><span class="w" id="mw7g"> </span><span class="nf" id="mw7w">comp</span><span class="p" id="mw8A">(</span><span class="n" id="mw8Q">threshold</span><span class="p" id="mw8g">:</span> <span class="nb" id="mw8w">int</span><span class="p" id="mw9A">)</span> <span class="o" id="mw9Q">-></span> <span class="n" id="mw9g">Callable</span><span class="p" id="mw9w">[[</span><span class="nb" id="mw-A">int</span><span class="p" id="mw-Q">],</span> <span class="nb" id="mw-g">bool</span><span class="p" id="mw-w">]:</span> <span class="k" id="mw_A">return</span> <span class="k" id="mw_Q">lambda</span> <span class="n" id="mw_g">x</span><span class="p" id="mw_w">:</span> <span class="n" id="mwAQA">x</span> <span class="o" id="mwAQE"><</span> <span class="n" id="mwAQI">threshold</span>

This can be used as a sort of generator of comparison functions:

<span id="mwAQY"></span><span class="n" id="mwAQc">func_a</span><span class="p" id="mwAQg">:</span> <span class="n" id="mwAQk">Callable</span><span class="p" id="mwAQo">[[</span><span class="nb" id="mwAQs">int</span><span class="p" id="mwAQw">],</span> <span class="nb" id="mwAQ0">bool</span><span class="p" id="mwAQ4">]</span> <span class="o" id="mwAQ8">=</span> <span class="n" id="mwARA">comp</span><span class="p" id="mwARE">(</span><span class="mi" id="mwARI">10</span><span class="p" id="mwARM">)</span> <span class="n" id="mwARQ">func_b</span><span class="p" id="mwARU">:</span> <span class="n" id="mwARY">Callable</span><span class="p" id="mwARc">[[</span><span class="nb" id="mwARg">int</span><span class="p" id="mwARk">],</span> <span class="nb" id="mwARo">bool</span><span class="p" id="mwARs">]</span> <span class="o" id="mwARw">=</span> <span class="n" id="mwAR0">comp</span><span class="p" id="mwAR4">(</span><span class="mi" id="mwAR8">20</span><span class="p" id="mwASA">)</span> <span class="nb" id="mwASE">print</span><span class="p" id="mwASI">(</span><span class="n" id="mwASM">func_a</span><span class="p" id="mwASQ">(</span><span class="mi" id="mwASU">5</span><span class="p" id="mwASY">),</span> <span class="n" id="mwASc">func_a</span><span class="p" id="mwASg">(</span><span class="mi" id="mwASk">8</span><span class="p" id="mwASo">),</span> <span class="n" id="mwASs">func_a</span><span class="p" id="mwASw">(</span><span class="mi" id="mwAS0">13</span><span class="p" id="mwAS4">),</span> <span class="n" id="mwAS8">func_a</span><span class="p" id="mwATA">(</span><span class="mi" id="mwATE">21</span><span class="p" id="mwATI">))</span> <span class="c1" id="mwATM"># prints True True False False</span> <span class="nb" id="mwATQ">print</span><span class="p" id="mwATU">(</span><span class="n" id="mwATY">func_b</span><span class="p" id="mwATc">(</span><span class="mi" id="mwATg">5</span><span class="p" id="mwATk">),</span> <span class="n" id="mwATo">func_b</span><span class="p" id="mwATs">(</span><span class="mi" id="mwATw">8</span><span class="p" id="mwAT0">),</span> <span class="n" id="mwAT4">func_b</span><span class="p" id="mwAT8">(</span><span class="mi" id="mwAUA">13</span><span class="p" id="mwAUE">),</span> <span class="n" id="mwAUI">func_b</span><span class="p" id="mwAUM">(</span><span class="mi" id="mwAUQ">21</span><span class="p" id="mwAUU">))</span> <span class="c1" id="mwAUY"># prints True True True False</span>

It would be impractical to create a function for every possible comparison function and may be too inconvenient to keep the threshold around for further use. Regardless of the reason why a closure is used, the anonymous function is the entity that contains the functionality that does the comparing.

Currying

Currying transforms a function that takes multiple arguments into a sequence of functions each accepting a single argument. In this example, a function that performs division by any integer is transformed into one that performs division by a set integer.

<span id="mwAU8"></span><span class="k" id="mwAVA">def</span><span class="w" id="mwAVE"> </span><span class="nf" id="mwAVI">divide</span><span class="p" id="mwAVM">(</span><span class="n" id="mwAVQ">x</span><span class="p" id="mwAVU">:</span> <span class="nb" id="mwAVY">int</span><span class="p" id="mwAVc">,</span> <span class="n" id="mwAVg">y</span><span class="p" id="mwAVk">:</span> <span class="nb" id="mwAVo">int</span><span class="p" id="mwAVs">)</span> <span class="o" id="mwAVw">-></span> <span class="nb" id="mwAV0">float</span><span class="p" id="mwAV4">:</span> <span class="k" id="mwAV8">return</span> <span class="n" id="mwAWA">x</span> <span class="o" id="mwAWE">/</span> <span class="n" id="mwAWI">y</span> <span class="k" id="mwAWM">def</span><span class="w" id="mwAWQ"> </span><span class="nf" id="mwAWU">divisor</span><span class="p" id="mwAWY">(</span><span class="n" id="mwAWc">d</span><span class="p" id="mwAWg">:</span> <span class="nb" id="mwAWk">int</span><span class="p" id="mwAWo">)</span> <span class="o" id="mwAWs">-></span> <span class="n" id="mwAWw">Callable</span><span class="p" id="mwAW0">[[</span><span class="nb" id="mwAW4">int</span><span class="p" id="mwAW8">],</span> <span class="nb" id="mwAXA">float</span><span class="p" id="mwAXE">]:</span> <span class="k" id="mwAXI">return</span> <span class="k" id="mwAXM">lambda</span> <span class="n" id="mwAXQ">x</span><span class="p" id="mwAXU">:</span> <span class="n" id="mwAXY">divide</span><span class="p" id="mwAXc">(</span><span class="n" id="mwAXg">x</span><span class="p" id="mwAXk">,</span> <span class="n" id="mwAXo">d</span><span class="p" id="mwAXs">)</span> <span class="n" id="mwAXw">half</span><span class="p" id="mwAX0">:</span> <span class="n" id="mwAX4">Callable</span><span class="p" id="mwAX8">[[</span><span class="nb" id="mwAYA">int</span><span class="p" id="mwAYE">],</span> <span class="nb" id="mwAYI">float</span><span class="p" id="mwAYM">]</span> <span class="o" id="mwAYQ">=</span> <span class="n" id="mwAYU">divisor</span><span class="p" id="mwAYY">(</span><span class="mi" id="mwAYc">2</span><span class="p" id="mwAYg">)</span> <span class="n" id="mwAYk">third</span><span class="p" id="mwAYo">:</span> <span class="n" id="mwAYs">Callable</span><span class="p" id="mwAYw">[[</span><span class="nb" id="mwAY0">int</span><span class="p" id="mwAY4">],</span> <span class="nb" id="mwAY8">float</span><span class="p" id="mwAZA">]</span> <span class="o" id="mwAZE">=</span> <span class="n" id="mwAZI">divisor</span><span class="p" id="mwAZM">(</span><span class="mi" id="mwAZQ">3</span><span class="p" id="mwAZU">)</span> <span class="nb" id="mwAZY">print</span><span class="p" id="mwAZc">(</span><span class="n" id="mwAZg">half</span><span class="p" id="mwAZk">(</span><span class="mi" id="mwAZo">32</span><span class="p" id="mwAZs">),</span> <span class="n" id="mwAZw">third</span><span class="p" id="mwAZ0">(</span><span class="mi" id="mwAZ4">32</span><span class="p" id="mwAZ8">))</span> <span class="c1" id="mwAaA"># prints 16.0 10.666666666666666</span> <span class="nb" id="mwAaE">print</span><span class="p" id="mwAaI">(</span><span class="n" id="mwAaM">half</span><span class="p" id="mwAaQ">(</span><span class="mi" id="mwAaU">40</span><span class="p" id="mwAaY">),</span> <span class="n" id="mwAac">third</span><span class="p" id="mwAag">(</span><span class="mi" id="mwAak">40</span><span class="p" id="mwAao">))</span> <span class="c1" id="mwAas"># prints 20.0 13.333333333333334</span>

While the use of anonymous functions is perhaps not common with currying, it still can be used. In the above example, the function divisor generates functions with a specified divisor. The functions half and third curry the divide function with a fixed divisor.

The divisor function also forms a closure by binding the variable d.

Higher-order functions

A higher-order function is a function that takes a function as an argument or returns one as a result. This technique is frequently employed to tailor the behavior of a generically defined function, such as a loop or recursion pattern. Anonymous functions are a convenient way to specify such function arguments. The following examples are in Python 3.

Map

The map function performs a function call on each element of a list. The following example squares every element in an array with an anonymous function.

<span id="mwAbk"></span><span class="n" id="mwAbo">a</span><span class="p" id="mwAbs">:</span> <span class="nb" id="mwAbw">list</span><span class="p" id="mwAb0">[</span><span class="nb" id="mwAb4">int</span><span class="p" id="mwAb8">]</span> <span class="o" id="mwAcA">=</span> <span class="p" id="mwAcE">[</span><span class="mi" id="mwAcI">1</span><span class="p" id="mwAcM">,</span> <span class="mi" id="mwAcQ">2</span><span class="p" id="mwAcU">,</span> <span class="mi" id="mwAcY">3</span><span class="p" id="mwAcc">,</span> <span class="mi" id="mwAcg">4</span><span class="p" id="mwAck">,</span> <span class="mi" id="mwAco">5</span><span class="p" id="mwAcs">,</span> <span class="mi" id="mwAcw">6</span><span class="p" id="mwAc0">]</span> <span class="nb" id="mwAc4">print</span><span class="p" id="mwAc8">(</span><span class="nb" id="mwAdA">list</span><span class="p" id="mwAdE">(</span><span class="nb" id="mwAdI">map</span><span class="p" id="mwAdM">(</span><span class="k" id="mwAdQ">lambda</span> <span class="n" id="mwAdU">x</span><span class="p" id="mwAdY">:</span> <span class="n" id="mwAdc">x</span> <span class="o" id="mwAdg">*</span> <span class="n" id="mwAdk">x</span><span class="p" id="mwAdo">,</span> <span class="n" id="mwAds">a</span><span class="p" id="mwAdw">)))</span> <span class="c1" id="mwAd0"># prints [1, 4, 9, 16, 25, 36]</span>

The anonymous function takes an argument and returns its square. The above form is discouraged by the creators of the language, who maintain that the form presented below has the same meaning and is more aligned with the philosophy of the language:

<span id="mwAeE"></span><span class="n" id="mwAeI">a</span><span class="p" id="mwAeM">:</span> <span class="nb" id="mwAeQ">list</span><span class="p" id="mwAeU">[</span><span class="nb" id="mwAeY">int</span><span class="p" id="mwAec">]</span> <span class="o" id="mwAeg">=</span> <span class="p" id="mwAek">[</span><span class="mi" id="mwAeo">1</span><span class="p" id="mwAes">,</span> <span class="mi" id="mwAew">2</span><span class="p" id="mwAe0">,</span> <span class="mi" id="mwAe4">3</span><span class="p" id="mwAe8">,</span> <span class="mi" id="mwAfA">4</span><span class="p" id="mwAfE">,</span> <span class="mi" id="mwAfI">5</span><span class="p" id="mwAfM">,</span> <span class="mi" id="mwAfQ">6</span><span class="p" id="mwAfU">]</span> <span class="nb" id="mwAfY">print</span><span class="p" id="mwAfc">([</span><span class="n" id="mwAfg">x</span> <span class="o" id="mwAfk">*</span> <span class="n" id="mwAfo">x</span> <span class="k" id="mwAfs">for</span> <span class="n" id="mwAfw">x</span> <span class="ow" id="mwAf0">in</span> <span class="n" id="mwAf4">a</span><span class="p" id="mwAf8">])</span> <span class="c1" id="mwAgA"># prints [1, 4, 9, 16, 25, 36]</span>

Filter

The filter function returns all elements from a list that evaluate True when passed to a certain function.

<span id="mwAgc"></span><span class="n" id="mwAgg">a</span><span class="p" id="mwAgk">:</span> <span class="nb" id="mwAgo">list</span><span class="p" id="mwAgs">[</span><span class="nb" id="mwAgw">int</span><span class="p" id="mwAg0">]</span> <span class="o" id="mwAg4">=</span> <span class="p" id="mwAg8">[</span><span class="mi" id="mwAhA">1</span><span class="p" id="mwAhE">,</span> <span class="mi" id="mwAhI">2</span><span class="p" id="mwAhM">,</span> <span class="mi" id="mwAhQ">3</span><span class="p" id="mwAhU">,</span> <span class="mi" id="mwAhY">4</span><span class="p" id="mwAhc">,</span> <span class="mi" id="mwAhg">5</span><span class="p" id="mwAhk">,</span> <span class="mi" id="mwAho">6</span><span class="p" id="mwAhs">]</span> <span class="nb" id="mwAhw">print</span><span class="p" id="mwAh0">(</span><span class="nb" id="mwAh4">list</span><span class="p" id="mwAh8">(</span><span class="nb" id="mwAiA">filter</span><span class="p" id="mwAiE">(</span><span class="k" id="mwAiI">lambda</span> <span class="n" id="mwAiM">x</span><span class="p" id="mwAiQ">:</span> <span class="n" id="mwAiU">x</span> <span class="o" id="mwAiY">%</span> <span class="mi" id="mwAic">2</span> <span class="o" id="mwAig">==</span> <span class="mi" id="mwAik">0</span><span class="p" id="mwAio">,</span> <span class="n" id="mwAis">a</span><span class="p" id="mwAiw">)))</span> <span class="c1" id="mwAi0"># prints [2, 4, 6]</span>

The anonymous function checks if the argument passed to it is even. The same as with map, the form below is considered more appropriate:

<span id="mwAjE"></span><span class="n" id="mwAjI">a</span><span class="p" id="mwAjM">:</span> <span class="nb" id="mwAjQ">list</span><span class="p" id="mwAjU">[</span><span class="nb" id="mwAjY">int</span><span class="p" id="mwAjc">]</span> <span class="o" id="mwAjg">=</span> <span class="p" id="mwAjk">[</span><span class="mi" id="mwAjo">1</span><span class="p" id="mwAjs">,</span> <span class="mi" id="mwAjw">2</span><span class="p" id="mwAj0">,</span> <span class="mi" id="mwAj4">3</span><span class="p" id="mwAj8">,</span> <span class="mi" id="mwAkA">4</span><span class="p" id="mwAkE">,</span> <span class="mi" id="mwAkI">5</span><span class="p" id="mwAkM">,</span> <span class="mi" id="mwAkQ">6</span><span class="p" id="mwAkU">]</span> <span class="nb" id="mwAkY">print</span><span class="p" id="mwAkc">([</span><span class="n" id="mwAkg">x</span> <span class="k" id="mwAkk">for</span> <span class="n" id="mwAko">x</span> <span class="ow" id="mwAks">in</span> <span class="n" id="mwAkw">a</span> <span class="k" id="mwAk0">if</span> <span class="n" id="mwAk4">x</span> <span class="o" id="mwAk8">%</span> <span class="mi" id="mwAlA">2</span> <span class="o" id="mwAlE">==</span> <span class="mi" id="mwAlI">0</span><span class="p" id="mwAlM">])</span> <span class="c1" id="mwAlQ"># prints [2, 4, 6]</span>

Fold

A fold function runs over all elements in a structure (for lists usually left-to-right, a "left fold", called reduce in Python), accumulating a value as it goes. This can be used to combine all elements of a structure into one value, for example:

<span id="mwAlw"></span><span class="n" id="mwAl0">a</span><span class="p" id="mwAl4">:</span> <span class="nb" id="mwAl8">list</span><span class="p" id="mwAmA">[</span><span class="nb" id="mwAmE">int</span><span class="p" id="mwAmI">]</span> <span class="o" id="mwAmM">=</span> <span class="p" id="mwAmQ">[</span><span class="mi" id="mwAmU">1</span><span class="p" id="mwAmY">,</span> <span class="mi" id="mwAmc">2</span><span class="p" id="mwAmg">,</span> <span class="mi" id="mwAmk">3</span><span class="p" id="mwAmo">,</span> <span class="mi" id="mwAms">4</span><span class="p" id="mwAmw">,</span> <span class="mi" id="mwAm0">5</span><span class="p" id="mwAm4">]</span> <span class="nb" id="mwAm8">print</span><span class="p" id="mwAnA">(</span><span class="n" id="mwAnE">functools</span><span class="o" id="mwAnI">.</span><span class="n" id="mwAnM">reduce</span><span class="p" id="mwAnQ">(</span><span class="k" id="mwAnU">lambda</span> <span class="n" id="mwAnY">x</span><span class="p" id="mwAnc">,</span> <span class="n" id="mwAng">y</span><span class="p" id="mwAnk">:</span> <span class="n" id="mwAno">x</span> <span class="o" id="mwAns">*</span> <span class="n" id="mwAnw">y</span><span class="p" id="mwAn0">,</span> <span class="n" id="mwAn4">a</span><span class="p" id="mwAn8">))</span> <span class="c1" id="mwAoA"># prints 120</span>

This performs

${\displaystyle \left(\left(\left(1\times 2\right)\times 3\right)\times 4\right)\times 5=120.}$

The anonymous function here is the multiplication of the two arguments.

A fold does not necessarily produce a single scalar value; it can also generate structured results such as lists. Instead, both map and filter can be created using fold. In map, the value that is accumulated is a new list, containing the results of applying a function to each element of the original list. In filter, the value that is accumulated is a new list containing only those elements that match the given condition.

List of languages

The following is a list of programming languages that support unnamed anonymous functions fully, or partly as some variant, or not at all.

The following table illustrates several common patterns. Notably, languages like C, Pascal, and Object Pascal—which traditionally do not support anonymous functions—are all statically typed languages. However, statically typed languages can support anonymous functions. For example, the ML languages are statically typed and fundamentally include anonymous functions, and Delphi, a dialect of Object Pascal, has been extended to support anonymous functions, as has C++ (by the C++11 standard). Second, the languages that treat functions as first-class functions (Dylan, Haskell, JavaScript, Lisp, ML, Perl, Python, Ruby, Scheme) generally have anonymous function support so that functions can be defined and passed around as easily as other data types.

Examples