Anonymous function

From Wikipedia, the free encyclopedia

It has been suggested that this article or section be merged into First-class function. (Discuss)

This article is in need of attention from an expert on the subject. WikiProject Computing or the Computing Portal may be able to help recruit one. (August 2009)

In computing, an anonymous function is a function (or a subroutine) defined, and possibly called, without being bound to an identifier.

Anonymous functions originate in the work of Alonzo Church in his invention of the lambda calculus in 1936 (prior to electronic computers), in which all functions are anonymous. The Y combinator can be utilised in these circumstances to provide anonymous recursion, which Church used to show that some mathematical questions are unsolvable by computation. (Note: this result was disputed at the time, and one year later his student Alan Turing provided a proof that was more generally accepted.)

Anonymous functions have been a feature of programming languages since Lisp in 1958. An increasing number of modern programming languages support anonymous functions, and some notable mainstream languages have recently added support for them, the most widespread being JavaScript, and another being C++0x the proposed new standard for C++.

Some object-oriented programming languages have anonymous classes, which are a similar concept, but do not support anonymous functions. Java is such a language.

[edit] Uses

Anonymous functions can be used to contain functionality that need not be named and possibly for short-term use. Some notable examples include closures and currying.

All of the code in the following sections is written in Python.

[edit] Sorting

When attempting to sort in a non-standard way it may be easier to contain the comparison logic as an anonymous function instead of creating a named function. Most languages provide a generic sort function that implements a sort algorithm that will sort arbitrary objects. This function usually accepts an arbitrary comparison function that is supplied two items and the function indicates if they are equal or if one is "greater" or "less" than the other (typically indicated by returning a negative number, zero, or a positive number).

Consider sorting items in a list by the name of their class (everything in python has a class):

a = [10, '10', 10.0]
a.sort(lambda x,y: cmp(x.__class__.__name__, y.__class__.__name__))
print a
[10.0, 10, '10']

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

The anonymous function in this example is the lambda expression:

lambda x,y: cmp(...)

The anonymous function accepts two arguments, x and y, and returns the comparison between them using the built-in function cmp(). Another example would be sorting a list of strings by length of the string:

a = ['three', 'two', 'four']
a.sort(lambda x,y: cmp(len(x), len(y)))
print a
['two', 'four', 'three']

which clearly has been sorted by length of the strings.

[edit] Closures

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

def comp(threshold):
  return lambda x: x < threshold

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

a = comp(10)
b = comp(20)
 
print a(9), a(10), a(20), a(21)
True False False False
 
print b(9), b(10), b(20), b(21)
True True False False

It would be very 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.

[edit] Currying

Currying is transforming a function from multiple inputs to fewer inputs (in this case integer division).

def divide(x,y):
  return x/y
 
def divisor(d):
  return lambda x: divide(x,d)
 
half = divisor(2)
third = divisor(3)
 
print half(32), third(32)
16 10
 
print half(40), third(40)
20 13

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.

(It just so happens that the divisor function forms a closure as well as curries by binding the "d" variable.)

[edit] Higher-order functions

[edit] Map

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

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

The anonymous function accepts an argument and multiplies it by itself (squares it).

[edit] Filter

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

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

The anonymous function checks if the argument passed to it is even.

[edit] Fold

The fold/reduce function reduces a list of elements repeatedly from left-to-right until only one element remains.

a = [1, 2, 3, 4, 5]
print reduce(lambda x,y: x*y, a)
120

This performs:

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

[edit] List of languages

The following is a list of programming languages that fully support unnamed anonymous functions; support some variant of anonymous functions; and have no support for anonymous functions.

This table shows some general trends. First, the languages that do not support anonymous functions — C, Pascal, Object Pascal, Java — are all conventional statically-typed languages. This does not, however, mean that statically-typed languages are incapable of 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. Second, the languages that treat functions as first-class functions — Dylan, JavaScript, Lisp, Scheme, ML, Haskell, Python, Ruby, Perl — generally have anonymous function support so that functions can be defined and passed around as easily as other data types. However, the coming C++0x standard adds them to C++, even though this is conventional, statically-typed language.

This list is incomplete; you can help by expanding it.

Language	Support	Notes
ActionScript	Y
C	N
C#	Y
C++	Y	In the C++0x standard. For now, some compilers and a number of third-party libraries such as the Boost C++ Libraries implement support for anonymous functions.[1]
Curl	Y
D	Y
Dylan	Y
Erlang	Y
Frink	Y
Haskell	Y
Java	N
JavaScript	Y
Lisp	Y
Logtalk	Y
Lua	Y
ML languages (OCaml, Standard ML, etc.)	Y
Object Pascal	Y	Delphi, a dialect of Object Pascal, implements support for anonymous functions (formally, anonymous methods) natively. The Oxygene ObjectPascal dialect also supports them.
Objective-C (Mac OS X 10.6+)	Y	called blocks
Pascal	N
Perl	Y
PHP	Y	As of PHP 5.3.0, true anonymous functions are supported, previously only partical anonymous functions were supported, which worked much like C#'s implementation.
Python	Y
R	Y
Ruby	Y	Ruby's anonymous functions, inherited from Smalltalk, are called blocks.
Scala	Y
Scheme	Y
Smalltalk	Y	Smalltalk's anonymous functions are called blocks.
Visual Basic .NET v9	Y
Visual Prolog v 7.2	Y
Vala	Y

[edit] Examples

Numerous languages support anonymous functions, or something similar.

[edit] C#

Support for anonymous functions in C# has deepened through the various versions of the language compiler. The C# Language v3.0, released in November 2007 with the .NET Framework v3.5, has full support of anonymous functions. C# refers to them as "lambda expressions", following the original version of anonymous functions, the Lambda Calculus. See the C# 3.0 Language Specification, section 5.3.3.29, for more information.

//the first int is the x' type
//the second int is the return type
//<see cref="http://msdn.microsoft.com/en-us/library/bb549151.aspx" />
Func<int,int> foo = x => x*x;
Console.WriteLine(foo(7));

While the function is anonymous, the type is explicit. C# 3.0 does include implicitly typed variables, but because the lambda syntax may be used to denote an anonymous function or an expression tree, the type cannot automatically be inferred by the compiler, and therefore lambda expressions cannot be assigned to implicitly typed variables. Eg,this does not work:

// will NOT compile!
var foo = x => x*x;
Console.WriteLine(foo(7));

As a further example, combining anonymous functions with the Map capability available with System.Collections.Generic.List (in the ConvertAll() method) looks like this:

// Initialize the list:
var values = new List<int>() { 7, 13, 4, 9, 3 };
// Map the anonymous function over all elements in the list, return the new list
var foo = values.ConvertAll(d => d*d) ; 
// the result of the foo variable is of type System.Collections.Generic.List<Int32>

Prior versions of C# had more limited support for anonymous functions. C# v1.0, introduced in February 2002 with the .NET Framework v1.0, provided partial anonymous function support through the use of delegates. This construct is somewhat similar to PHP delegates. In C# 1.0, Delegates are like function pointers that refer to an explicitly named method within a class. (but unlike PHP the name is not required at the time the delegate is used.) C# v2.0, released in November 2005 with the .NET Framework v2.0, introduced the concept of anonymous methods as a way to write unnamed inline statement blocks that can be executed in a delegate invocation. C# 3.0 continues to support these constructs, but also supports the lambda expression construct.

This example will compile in C# 3.0, and exhibits the three forms:

  public class TestDriver
  {
    delegate int SquareDelegate(int d);
    static int Square(int d)
    {
      return d*d;
    }
 
    static void Main(string[] args)
    {
      // C# 1.0: Original delegate syntax required 
      // initialization with a named method.
      SquareDelegate A = new SquareDelegate(Square);
      System.Console.WriteLine(A(3));
 
      // C# 2.0: A delegate can be initialized with
      // inline code, called an "anonymous method." This
      // method takes an int as an input parameter.
      SquareDelegate B = delegate(int d) { return d*d; };
      System.Console.WriteLine(B(5));
 
      // C# 3.0. A delegate can be initialized with
      // a lambda expression. The lambda takes an int, and returns an int. 
      // The type of x is inferred by the compiler.
      SquareDelegate C = x => x*x;
      System.Console.WriteLine(C(7));
 
      // C# 3.0. A delegate that accepts a single input and
      // returns a single output can also be implicitly declared with the Func<> type.
      System.Func<int,int> D = x => x*x;
      System.Console.WriteLine(D(9));
 
    } 
  }

In the case of the C# 2.0 version, the C# compiler takes the code block of the anonymous function and creates a static private function. Internally, the function gets a generated name, of course; this generated name is based on the name of the method in which the Delegate is declared. But the name is never exposed to application code.

In the case of the C# 3.0 version, the same mechanism applies.

[edit] Delphi

program demo;
 
type
  TSimpleProcedure = reference to procedure;
  TSimpleFunction = reference to function(x: string): Integer;
 
var
  x1: TSimpleProcedure;
  y1: TSimpleFunction;
 
begin
  x1 := procedure
    begin
      Writeln('Hello World');
    end;
  x1;   //invoke anonymous method just defined
 
  y1 := function(x: string): Integer
    begin
      Result := Length(x);
    end;
  Writeln(y1('bar')); 
end.

[edit] Erlang

Erlang uses a syntax for anonymous functions similar to that of named functions.

% Anonymous function bound to the Square variable
Square = fun(X) -> X * X end.
 
% Named function with the same functionality
square(X) -> X * X.

[edit] Haskell

Haskell uses a concise syntax for anonymous functions (lambda expressions).

\arg -> arg * arg

Lambda expressions are fully integrated with the type inference engine, and support all the syntax and features of "ordinary" functions (except for the use of multiple definitions for pattern-matching, since the argument list is only specified once).

map (\arg -> arg * arg) [1..5] -- returns [1, 4, 9, 16, 25]

[edit] JavaScript

JavaScript supports anonymous functions.

var foo = function(x) {return x*x;};
alert(foo(10));

Unlike Python, anonymous functions in JavaScript are just like named functions and are declared just like named functions - in fact, all functions are implemented in the same way as anonymous functions, only sometimes with slightly different syntax (e.g. function foo(x) { return x*x } is the same as foo given above).

[edit] Lisp

Lisp and Scheme support anonymous functions using the "lambda" construct, which is a reference to lambda calculus.

(lambda (arg) (* arg arg))

Interestingly, Scheme's "named functions" is simply syntactic sugar for anonymous functions bound to names:

(define (somename arg)
  (do-something arg))

expands (and is equivalent) to

(define somename
  (lambda (arg)
    (do-something arg)))

[edit] Logtalk

Logtalk uses the following syntax for anonymous predicates (lambda expressions):

{FreeVar1, FreeVar2, ...}/[LambdaParameter1, LambdaParameter2, ...]>>Goal 

A simple example with no free variables and using a list mapping predicate is:

| ?- meta::map([X,Y]>>(Y is 2*X), [1,2,3], Ys).
Ys = [2,4,6]
yes

Currying is also supported. The above example can be written as:

| ?- meta::map([X]>>([Y]>>(Y is 2*X)), [1,2,3], Ys).
Ys = [2,4,6]
yes

[edit] Lua

In Lua (much as in Scheme) all functions are anonymous. A "named function" in Lua is simply a variable holding a reference to a function object ^[2].

Thus, in Lua

function foo(x) return 2*x end

is just syntactical sugar for

foo = function(x) return 2*x end

An example of using anonymous functions for reverse-order sorting:

table.sort(network, function(a,b)
  return a.name > b.name
end)

[edit] ML

The various dialects of ML support anonymous functions.

OCaml:

fun arg -> arg * arg

Standard ML:

fn arg => arg * arg

[edit] Perl

Perl supports anonymous functions, as follows:

(sub { print "I got called\n" })->();         # 1. fully anonymous, called as created
 
my $squarer = sub { my $x = shift; $x * $x }; # 2. assigned to a variable
 
sub curry {
    my ($sub, @args) = @_;
    return sub { $sub->(@args, @_) };         # 3. as a return value of another function
}
 
# example of currying in Perl
sub sum { my $tot = 0; $tot += $_ for @_; $tot } # returns the sum of its arguments
my $curried = curry \&sum, 5, 7, 9;
print $curried->(1,2,3), "\n";    # prints 27 ( = 5 + 7 + 9 + 1 + 2 + 3 )

Other constructs take "bare blocks" as arguments, which serve a function similar to lambda functions of a single parameter, but don't have the same parameter-passing convention as functions -- @_ is not set.

my @squares = map { $_ * $_ } 1..10;   # map and grep don't use the 'sub' keyword
my @square2 = map $_ * $_, 1..10;      # parentheses not required for a single expression
 
my @bad_example = map { print for @_ } 1..10; # values not passed like normal Perl function

[edit] PHP

PHP prior to 4.0.1 ^[3] PHP had no anonymous function support.

[edit] 4.0.1 to 5.3

PHP 4.0.1 introduced the create_function which was the initial anonymous function support. This function call creates a new randomly named function and returns its name (as a string)

$foo = create_function('$x', 'return $x*$x;');
$bar = create_function("\$x", "return \$x*\$x;");
echo $foo(10);

It is important to note that the argument list and function body must be in single quotes or the dollar signs must be escaped. Otherwise PHP will assume "$x" means the variable $x and will substitute it into the string (despite possibly not existing) instead of leaving "$x" in the string. For functions with quotes or functions with lots of variables, it can get quite tedious to ensure the intended function body is what PHP interprets.

[edit] 5.3

PHP 5.3 added a new class called Closure and magic method __invoke() that makes a class instance invocable. ^[4] Lambda functions are a compiler "trick" ^[5] that instantiates a new Closure instance that can be invoked as if the function were invokable.

$x = 3;
$func = function($z) { return $z *= 2; };
echo $func($x); // prints 6

In this example, $func is an instance of Closure and echo $func() is equivalent to $func->__invoke($z). PHP 5.3 mimics anonymous functions but it does not support true anonymous functions because PHP functions are still not first-class functions.

PHP 5.3 does support closures but the variables must be explicitly indicated as such:

$x = 3;
$func = function() use(&$x) { $x *= 2; };
$func();
echo $x; // prints 6

The variable $x is bound by reference so the invocation of $func modifies it and the changes are visible outside of the function.

[edit] Python

Python supports simple anonymous functions through the lambda form. The executable body of the lambda must be an expression and can't be a statement, which is a restriction that limits its utility. The value returned by the lambda is the value of the contained expression. Lambda forms can be used anywhere ordinary functions can, however these restrictions make it a very limited version of a normal function. Here is an example:

foo = lambda x: x*x
print foo(10)

This example will print: 100.

In general, Python convention encourages the use of named functions defined in the same scope as one might typically use an anonymous functions in other languages. This is acceptable as locally defined functions are almost as efficient as the use of a lambda in Python.

[edit] Ruby

Ruby supports anonymous functions by using a syntactical structure called block, which are essentially an object of class Proc.

#Example 1:
#Purely anonymous functions using blocks.
ex = [16.2, 24.1, 48.3, 32.4, 8.5]
ex.sort() {|x,y| (x % x.to_i) <=> (y % y.to_i)} #sort by fractional part, ignoring integer part.
# [24.1, 16.2, 48.3, 32.4, 8.5]
 
#Example 2:
#First-class functions as an explicit object of Proc -
ex = Proc.new { puts("Hello, world!") }
ex.call() # Hello, world!

[edit] Smalltalk

In Smalltalk anonymous functions are called blocks

[edit] Visual Basic

VB v9, introduced in November 2007, supports anonymous functions through the lambda form. Combined with implicit typing, VB provides an economical syntax for anonymous functions. As with Python, in VB v9, anonymous functions must be defined on a single line; they cannot be compound statements. Further, an anonymous function in VB must truly be a VB "Function" - it must return a value.

Dim foo = Function(x) x * x
Console.WriteLine(foo(10))

[edit] Visual Prolog

Anonymous functions (in general anonymous predicates) were introduced in Visual Prolog in version 7.2^[6]. Anonymous predicates can capture values from the context. If created in an object member it can also access the object state (by capturing This).

mkAdder returns an anonymous function, which has captured the argument X in the closure. The returned function is a function that adds X to its argument:

clauses
    mkAdder(X) = { (Y) = X+Y }.

[edit] See also

• First-class function

[edit] References

[edit] External links

• Anonymous Methods - When Should They Be Used?