Anonymous function

In computer programming, an anonymous function (function literal, lambda function, or block) is a function definition that is not bound to an identifier. Anonymous functions are often arguments being passed to higher-order functions or used for constructing the result of a higher-order function that needs to return a function.^[1] If the function is only used once, or a limited number of times, an anonymous function may be syntactically lighter than using a named function. Anonymous functions are ubiquitous in functional programming languages and other languages with first-class functions, where they fulfil the same role for the function type as literals do for other data types.

Anonymous functions originate in the work of Alonzo Church in his invention of the lambda calculus, in which all functions are anonymous, in 1936, before electronic computers.^[2] In several programming languages, anonymous functions are introduced using the keyword lambda, and anonymous functions are often referred to as lambdas or lambda abstractions. Anonymous functions have been a feature of programming languages since Lisp in 1958, and a growing number of modern programming languages support anonymous functions.

Names

The names "lambda abstraction", "lambda function", and "lambda expression" refer to the notation of function abstraction in lambda calculus, where the usual function ${\displaystyle f(x)=M}$ would be written ${\displaystyle (\lambda x.M)}$, and where ${\displaystyle M}$ is an expression that uses ${\displaystyle x}$. Compare to the Python syntax of lambda x: M.

The name "arrow function" refers to the mathematical "maps to" symbol, ${\displaystyle x\mapsto M}$. Compare to the JavaScript syntax of x => M.^[3]

Uses

This section does not cite any sources. Please help improve this section by adding citations to reliable sources. Unsourced material may be challenged and removed. (February 2018) (Learn how and when to remove this message)

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.

a: list[str] = ["house", "car", "bike"]
a.sort(key = lambda x: len(x))
print(a)
# prints ['car', 'bike', 'house']

lambda x: len(x)

lambda arg1, arg2, arg3, ...: <operation on the arguments returning a value>

from typing import Callable

add: Callable[[int], int] = lambda a: a + a
print(add(20))
# prints 40

a: list[int | str] = [10, "number", 11.2]
a.sort(key=lambda x: x.__class__.__name__)
print(a)
# prints [11.2, 10, 'number']

def comp(threshold: int) -> Callable[[int], bool]:
    return lambda x: x < threshold

func_a: Callable[[int], bool] = comp(10)
func_b: Callable[[int], bool] = comp(20)

print(func_a(5), func_a(8), func_a(13), func_a(21))
# prints True True False False

print(func_b(5), func_b(8), func_b(13), func_b(21))
# prints True True True False

def divide(x: int, y: int) -> float:
    return x / y

def divisor(d: int) -> Callable[[int], float]:
    return lambda x: divide(x, d)

half: Callable[[int], float] = divisor(2)
third: Callable[[int], float] = divisor(3)

print(half(32), third(32))
# prints 16.0 10.666666666666666

print(half(40), third(40))
# prints 20.0 13.333333333333334

a: list[int] = [1, 2, 3, 4, 5, 6]
print(list(map(lambda x: x * x, a)))
# prints [1, 4, 9, 16, 25, 36]

a: list[int] = [1, 2, 3, 4, 5, 6]
print([x * x for x in a])
# prints [1, 4, 9, 16, 25, 36]

a: list[int] = [1, 2, 3, 4, 5, 6]
print(list(filter(lambda x: x % 2 == 0, a)))
# prints [2, 4, 6]

a: list[int] = [1, 2, 3, 4, 5, 6]
print([x for x in a if x % 2 == 0])
# prints [2, 4, 6]

a: list[int] = [1, 2, 3, 4, 5]
print(functools.reduce(lambda x, y: x * y, a))
# prints 120

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.

This list is incomplete; you can help by adding missing items. (August 2008)

List of languages

Language	Support	Notes
ActionScript	Y
Ada	Y	Expression functions are a part of Ada2012, access-to-subprogram[4]
ALGOL 68	Y
APL	Y	Dyalog, ngn and dzaima APL fully support both dfns and tacit functions. GNU APL has rather limited support for dfns.
Assembly languages	N
AHK	Y	Since AutoHotkey V2, anonymous functions are supported with a syntax similar to JavaScript.
Bash	Y	A library has been made to support anonymous functions in Bash.[5]
C	N	Support is provided in Clang and along with the LLVM compiler-rt lib. GCC support is given for a macro implementation which enables the possibility of use. See below for more details.
C#	Y	[6]
C++	Y	As of the C++11 standard
CFML	Y	As of Railo 4,[7] ColdFusion 10[8]
Clojure	Y	[9]
COBOL	N	Micro Focus's non-standard Managed COBOL dialect supports lambdas, which are called anonymous delegates/methods.[10]
Curl	Y
D	Y	[11]
Dart	Y	[12]
Delphi	Y	[13]
Dylan	Y	[14]
Eiffel	Y
Elm	Y	[15]
Elixir	Y	[16]
Erlang	Y	[17]
F#	Y	[18]
Excel	Y	Excel worksheet function, 2021 beta release[19]
Factor	Y	"Quotations" support this[20]
Fortran	N
Frink	Y	[21]
Go	Y	[22]
Gosu	Y	[23]
Groovy	Y	[24]
Haskell	Y	[25]
Haxe	Y	[26]
Java	Y	Supported since Java 8.
JavaScript	Y	[27]
Julia	Y	[28]
Kotlin	Y	[29]
Lisp	Y
Logtalk	Y
Lua	Y	[30]
MUMPS	N
Maple	Y	[31]
MATLAB	Y	[32]
Maxima	Y	[33]
Nim	Y	[34]
OCaml	Y	[35]
Octave	Y	[36]
Object Pascal	Y	Delphi, a dialect of Object Pascal, supports anonymous functions (formally, anonymous methods) natively since Delphi 2009. The Oxygene Object Pascal dialect also supports them.
Objective-C (Mac OS X 10.6+)	Y	Called blocks; in addition to Objective-C, blocks can also be used on C and C++ when programming on Apple's platform.
OpenSCAD	Y	Function Literal support was introduced with version 2021.01.[37]
Pascal	N
Perl	Y	[38]
PHP	Y	As of PHP 5.3.0, true anonymous functions are supported.[39] Formerly, only partial anonymous functions were supported, which worked much like C#'s implementation.
PL/I	N
Python	Y	Python supports anonymous functions through the lambda syntax, which supports only expressions, not statements.[40]
R	Y
Racket	Y	[41]
Raku	Y	[42]
Rexx	N
RPG	N
Ruby	Y	Ruby's anonymous functions, inherited from Smalltalk, are called blocks.[43]
Rust	Y	[44]
Scala	Y	[45]
Scheme	Y
Smalltalk	Y	Smalltalk's anonymous functions are called blocks.
Standard ML	Y	[46]
Swift	Y	Swift's anonymous functions are called Closures.[47]
TypeScript	Y	[48]
Typst	Y	[49]
Tcl	Y	[50]
Vala	Y	[50]
Visual Basic .NET v9	Y	[51]
Visual Prolog v 7.2	Y	[52]
Wolfram Language	Y	[53]
Zig	N	[54]

Examples

See also

• First-class function
• Lambda calculus definition

References

External links

• Anonymous Methods - When Should They Be Used? (blog about anonymous function in Delphi)
• Compiling Lambda Expressions: Scala vs. Java 8
• php anonymous functions php anonymous functions
• Lambda functions in various programming languages
• Functions in Go