Function object

Last updated

In computer programming, a function object [lower-alpha 1] is a construct allowing an object to be invoked or called as if it were an ordinary function, usually with the same syntax (a function parameter that can also be a function). In some languages, particularly C++, function objects are often called functors (not related to the functional programming concept).

Contents

Description

A typical use of a function object is in writing callback functions. A callback in procedural languages, such as C, may be performed by using function pointers. [2] However it can be difficult or awkward to pass a state into or out of the callback function. This restriction also inhibits more dynamic behavior of the function. A function object solves those problems since the function is really a façade for a full object, carrying its own state.

Many modern (and some older) languages, e.g. C++, Eiffel, Groovy, Lisp, Smalltalk, Perl, PHP, Python, Ruby, Scala, and many others, support first-class function objects and may even make significant use of them. [3] Functional programming languages additionally support closures, i.e. first-class functions that can 'close over' variables in their surrounding environment at creation time. During compilation, a transformation known as lambda lifting converts the closures into function objects.

In C and C++

Consider the example of a sorting routine that uses a callback function to define an ordering relation between a pair of items. The following C/C++ program uses function pointers:

#include<stdlib.h>/* qsort() callback function, returns < 0 if a < b, > 0 if a > b, 0 if a == b */intcompareInts(constvoid*a,constvoid*b){return(*(int*)a-*(int*)b);}...// prototype of qsort is// void qsort(void *base, size_t nel, size_t width, int (*compar)(const void *, const void *));...intmain(void){intitems[]={4,3,1,2};qsort(items,sizeof(items)/sizeof(items[0]),sizeof(items[0]),compareInts);return0;}

In C++, a function object may be used instead of an ordinary function by defining a class that overloads the function call operator by defining an operator() member function. In C++, this may appear as follows:

// comparator predicate: returns true if a < b, false otherwisestructIntComparator{booloperator()(constint&a,constint&b)const{returna<b;}};intmain(){std::vector<int>items{4,3,1,2};std::sort(items.begin(),items.end(),IntComparator());return0;}

Notice that the syntax for providing the callback to the std::sort() function is identical, but an object is passed instead of a function pointer. When invoked, the callback function is executed just as any other member function, and therefore has full access to the other members (data or functions) of the object. Of course, this is just a trivial example. To understand what power a functor provides more than a regular function, consider the common use case of sorting objects by a particular field. In the following example, a functor is used to sort a simple employee database by each employee's ID number.

structCompareBy{conststd::stringSORT_FIELD;CompareBy(conststd::string&sort_field="name"):SORT_FIELD(sort_field){/* validate sort_field */}booloperator()(constEmployee&a,constEmployee&b)const{if(SORT_FIELD=="name")returna.name<b.name;elseif(SORT_FIELD=="age")returna.age<b.age;elseif(SORT_FIELD=="idnum")returna.idnum<b.idnum;else/* throw exception or something */}};intmain(){std::vector<Employee>emps;/* code to populate database */// Sort the database by employee ID numberstd::sort(emps.begin(),emps.end(),CompareBy("idnum"));return0;}

In C++11, the lambda expression provides a more succinct way to do the same thing.

intmain(){std::vector<Employee>emps;/* code to populate database */conststd::stringsort_field="idnum";std::sort(emps.begin(),emps.end(),[&sort_field](constEmployee&a,constEmployee&b)const{/* code to select and compare field */});return0;}


It is possible to use function objects in situations other than as callback functions. In this case, the shortened term functor is normally not used about the function object. Continuing the example,

IntComparatorcpm;boolresult=cpm(a,b);

In addition to class type functors, other kinds of function objects are also possible in C++. They can take advantage of C++'s member-pointer or template facilities. The expressiveness of templates allows some functional programming techniques to be used, such as defining function objects in terms of other function objects (like function composition). Much of the C++ Standard Template Library (STL) makes heavy use of template-based function objects.

Another way to create a function object in C++ is to define a non-explicit conversion function to a function pointer type, a function reference type, or a reference to function pointer type. Assuming the conversion does not discard cv-qualifiers, this allows an object of that type to be used as a function with the same signature as the type it is converted to. Modifying an earlier example to use this we obtain the following class, whose instances can be called like function pointers: [4]

// comparator predicate: returns true if a < b, false otherwisestructIntComparator{staticboolcompare(constint&a,constint&b){returna<b;}usingT=decltype(compare);operatorT*()const{returncompare;}};intmain(){std::vector<int>items{4,3,1,2};std::sort(items.begin(),items.end(),IntComparator());return0;}

Maintaining state

Another advantage of function objects is their ability to maintain a state that affects operator() between calls. For example, the following code defines a generator counting from 10 upwards and is invoked 11 times.

#include<algorithm>#include<iostream>#include<iterator>classCountFrom{public:CountFrom(intcount):count_(count){}intoperator()(){returncount_++;}private:intcount_;};intmain(){constintstate(10);std::generate_n(std::ostream_iterator<int>(std::cout,"\n"),11,CountFrom(state));}

In C++14 or later, the example above could be rewritten as:

#include<algorithm>#include<iostream>#include<iterator>intmain(){std::generate_n(std::ostream_iterator<int>(std::cout,"\n"),11,[count=10]()mutable{returncount++;});}

In C#

In C#, function objects are declared via delegates. A delegate can be declared using a named method or a lambda expression. Here is an example using a named method.

usingSystem;usingSystem.Collections.Generic;publicclassComparisonClass1{publicstaticintCompareFunction(intx,inty){returnx-y;}publicstaticvoidMain(){varitems=newList<int>{4,3,1,2};Comparison<int>del=CompareFunction;items.Sort(del);}}

Here is an example using a lambda expression.

usingSystem;usingSystem.Collections.Generic;publicclassComparisonClass2{publicstaticvoidMain(){varitems=newList<int>{4,3,1,2};items.Sort((x,y)=>x-y);}}

In D

D provides several ways to declare function objects: Lisp/Python-style via closures or C#-style via delegates, respectively:

boolfind(T)(T[]haystack,booldelegate(T)needle_test){foreach(straw;haystack){if(needle_test(straw))returntrue;}returnfalse;}voidmain(){int[]haystack=[345,15,457,9,56,123,456];intneedle=123;boolneedleTest(intn){returnn==needle;}assert(find(haystack,&needleTest));}

The difference between a delegate and a closure in D is automatically and conservatively determined by the compiler. D also supports function literals, that allow a lambda-style definition:

voidmain(){int[]haystack=[345,15,457,9,56,123,456];intneedle=123;assert(find(haystack,(intn){returnn==needle;}));}

To allow the compiler to inline the code (see above), function objects can also be specified C++-style via operator overloading:

boolfind(T,F)(T[]haystack,Fneedle_test){foreach(straw;haystack){if(needle_test(straw))returntrue;}returnfalse;}voidmain(){int[]haystack=[345,15,457,9,56,123,456];intneedle=123;classNeedleTest{intneedle;this(intn){needle=n;}boolopCall(intn){returnn==needle;}}assert(find(haystack,newNeedleTest(needle)));}

In Eiffel

In the Eiffel software development method and language, operations and objects are seen always as separate concepts. However, the agent mechanism facilitates the modeling of operations as runtime objects. Agents satisfy the range of application attributed to function objects, such as being passed as arguments in procedural calls or specified as callback routines. The design of the agent mechanism in Eiffel attempts to reflect the object-oriented nature of the method and language. An agent is an object that generally is a direct instance of one of the two library classes, which model the two types of routines in Eiffel: PROCEDURE and FUNCTION. These two classes descend from the more abstract ROUTINE.

Within software text, the language keyword agent allows agents to be constructed in a compact form. In the following example, the goal is to add the action of stepping the gauge forward to the list of actions to be executed in the event that a button is clicked.

my_button.select_actions.extend(agentmy_gauge.step_forward)

The routine extend referenced in the example above is a feature of a class in a graphical user interface (GUI) library to provide event-driven programming capabilities.

In other library classes, agents are seen to be used for different purposes. In a library supporting data structures, for example, a class modeling linear structures effects universal quantification with a function for_all of type BOOLEAN that accepts an agent, an instance of FUNCTION, as an argument. So, in the following example, my_action is executed only if all members of my_list contain the character '!':

my_list:LINKED_LIST[STRING]...ifmy_list.for_all(agent{STRING}.has('!'))thenmy_actionend...

When agents are created, the arguments to the routines they model and even the target object to which they are applied can be either closed or left open. Closed arguments and targets are given values at agent creation time. The assignment of values for open arguments and targets is deferred until some point after the agent is created. The routine for_all expects as an argument an agent representing a function with one open argument or target that conforms to actual generic parameter for the structure (STRING in this example.)

When the target of an agent is left open, the class name of the expected target, enclosed in braces, is substituted for an object reference as shown in the text agent {STRING}.has ('!') in the example above. When an argument is left open, the question mark character ('?') is coded as a placeholder for the open argument.

The ability to close or leave open targets and arguments is intended to improve the flexibility of the agent mechanism. Consider a class that contains the following procedure to print a string on standard output after a new line:

print_on_new_line(s:STRING)-- Print `s' preceded by a new linedoprint("%N"+s)end

The following snippet, assumed to be in the same class, uses print_on_new_line to demonstrate the mixing of open arguments and open targets in agents used as arguments to the same routine.

my_list:LINKED_LIST[STRING]...my_list.do_all(agentprint_on_new_line(?))my_list.do_all(agent{STRING}.to_lower)my_list.do_all(agentprint_on_new_line(?))...

This example uses the procedure do_all for linear structures, which executes the routine modeled by an agent for each item in the structure.

The sequence of three instructions prints the strings in my_list, converts the strings to lowercase, and then prints them again.

Procedure do_all iterates across the structure executing the routine substituting the current item for either the open argument (in the case of the agents based on print_on_new_line), or the open target (in the case of the agent based on to_lower).

Open and closed arguments and targets also allow the use of routines that call for more arguments than are required by closing all but the necessary number of arguments:

my_list.do_all(agentmy_multi_arg_procedure(closed_arg_1,?,closed_arg_2,closed_arg_3)

The Eiffel agent mechanism is detailed in the Eiffel ISO/ECMA standard document.

In Java

Java has no first-class functions, so function objects are usually expressed by an interface with a single method (most commonly the Callable interface), typically with the implementation being an anonymous inner class, or, starting in Java 8, a lambda.

For an example from Java's standard library, java.util.Collections.sort() takes a List and a functor whose role is to compare objects in the List. Without first-class functions, the function is part of the Comparator interface. This could be used as follows.

List<String>list=Arrays.asList("10","1","20","11","21","12");Comparator<String>numStringComparator=newComparator<String>(){publicintcompare(Stringstr1,Stringstr2){returnInteger.valueOf(str1).compareTo(Integer.valueOf(str2));}};Collections.sort(list,numStringComparator);

In Java 8+, this can be written as:

List<String>list=Arrays.asList("10","1","20","11","21","12");Comparator<String>numStringComparator=(str1,str2)->Integer.valueOf(str1).compareTo(Integer.valueOf(str2));Collections.sort(list,numStringComparator);

In JavaScript

In JavaScript, functions are first class objects. JavaScript also supports closures.

Compare the following with the subsequent Python example.

functionAccumulator(start){varcurrent=start;returnfunction(x){returncurrent+=x;};}

An example of this in use:

vara=Accumulator(4);varx=a(5);// x has value 9x=a(2);// x has value 11varb=Accumulator(42);x=b(7);// x has value 49 (current = 49 in closure b)x=a(7);// x has value 18 (current = 18 in closure a)

In Julia

In Julia, methods are associated with types, so it is possible to make any arbitrary Julia object "callable" by adding methods to its type. (Such "callable" objects are sometimes called "functors.")

An example is this accumulator mutable struct (based on Paul Graham's study on programming language syntax and clarity): [5]

julia>mutablestructAccumulatorn::Intendjulia>function(acc::Accumulator)(n2)acc.n+=n2endjulia>a=Accumulator(4)Accumulator(4)julia>a(5)9julia>a(2)11julia>b=Accumulator(42)Accumulator(42)julia>b(7)49

Such an accumulator can also be implemented using closure:

julia>functionAccumulator(n0)n=n0function(n2)n+=n2endendAccumulator (generic function with 1 method)julia>a=Accumulator(4)(::#1) (generic function with 1 method)julia>a(5)9julia>a(2)11julia>b=Accumulator(42)(::#1) (generic function with 1 method)julia>b(7)49

In Lisp and Scheme

In Lisp family languages such as Common Lisp, Scheme, and others, functions are objects, just like strings, vectors, lists, and numbers. A closure-constructing operator creates a function object from a part of the program: the part of code given as an argument to the operator is part of the function, and so is the lexical environment: the bindings of the lexically visible variables are captured and stored in the function object, which is more commonly called a closure. The captured bindings play the role of member variables, and the code part of the closure plays the role of the anonymous member function, just like operator () in C++.

The closure constructor has the syntax (lambda (parameters ...) code ...). The (parameters ...) part allows an interface to be declared, so that the function takes the declared parameters. The code ... part consists of expressions that are evaluated when the functor is called.

Many uses of functors in languages like C++ are simply emulations of the missing closure constructor. Since the programmer cannot directly construct a closure, they must define a class that has all of the necessary state variables, and also a member function. Then, construct an instance of that class instead, ensuring that all the member variables are initialized through its constructor. The values are derived precisely from those local variables that ought to be captured directly by a closure.

A function-object using the class system in Common Lisp, no use of closures:

(defclasscounter()((value:initarg:value:accessorvalue-of)))(defmethodfunctor-call((ccounter))(incf(value-ofc)))(defunmake-counter(initial-value)(make-instance'counter:valueinitial-value));;; use the counter:(defvar*c*(make-counter10))(functor-call*c*)-->11(functor-call*c*)-->12

Since there is no standard way to make funcallable objects in Common Lisp, we fake it by defining a generic function called FUNCTOR-CALL. This can be specialized for any class whatsoever. The standard FUNCALL function is not generic; it only takes function objects.

It is this FUNCTOR-CALL generic function that gives us function objects, which are a computer programming construct allowing an object to be invoked or called as if it were an ordinary function, usually with the same syntax. We have almost the same syntax: FUNCTOR-CALL instead of FUNCALL. Some Lisps provide funcallable objects as a simple extension. Making objects callable using the same syntax as functions is a fairly trivial business. Making a function call operator work with different kinds of function things, whether they be class objects or closures is no more complicated than making a + operator that works with different kinds of numbers, such as integers, reals or complex numbers.

Now, a counter implemented using a closure. This is much more brief and direct. The INITIAL-VALUE argument of the MAKE-COUNTER factory function is captured and used directly. It does not have to be copied into some auxiliary class object through a constructor. It is the counter. An auxiliary object is created, but that happens behind the scenes.

(defunmake-counter(value)(lambda()(incfvalue)));;; use the counter(defvar*c*(make-counter10))(funcall*c*); --> 11(funcall*c*); --> 12

Scheme makes closures even simpler, and Scheme code tends to use such higher-order programming somewhat more idiomatically.

(define(make-countervalue)(lambda()(set!value(+value1))value));;; use the counter(definec(make-counter10))(c); --> 11(c); --> 12

More than one closure can be created in the same lexical environment. A vector of closures, each implementing a specific kind of operation, can quite faithfully emulate an object that has a set of virtual operations. That type of single dispatch object-oriented programming can be done fully with closures.

Thus there exists a kind of tunnel being dug from both sides of the proverbial mountain. Programmers in OOP languages discover function objects by restricting objects to have one main function to do that object's functional purpose, and even eliminate its name so that it looks like the object is being called! While programmers who use closures are not surprised that an object is called like a function, they discover that multiple closures sharing the same environment can provide a complete set of abstract operations like a virtual table for single dispatch type OOP.

In Objective-C

In Objective-C, a function object can be created from the NSInvocation class. Construction of a function object requires a method signature, the target object, and the target selector. Here is an example for creating an invocation to the current object's myMethod:

// Construct a function objectSELsel=@selector(myMethod);NSInvocation*inv=[NSInvocationinvocationWithMethodSignature:[selfmethodSignatureForSelector:sel]];[invsetTarget:self];[invsetSelector:sel];// Do the actual invocation[invinvoke];

An advantage of NSInvocation is that the target object can be modified after creation. A single NSInvocation can be created and then called for each of any number of targets, for instance from an observable object. An NSInvocation can be created from only a protocol, but it is not straightforward. See here.

In Perl

In Perl, a function object can be created either from a class's constructor returning a function closed over the object's instance data, blessed into the class:

packageAcc1;subnew{my$class=shift;my$arg=shift;my$obj=sub{my$num=shift;$arg+=$num;};bless$obj,$class;}1;

or by overloading the &{} operator so that the object can be used as a function:

packageAcc2;useoverload'&{}'=>sub{my$self=shift;sub{my$num=shift;$self->{arg}+=$num;}};subnew{my$class=shift;my$arg=shift;my$obj={arg=>$arg};bless$obj,$class;}1;

In both cases the function object can be used either using the dereferencing arrow syntax $ref->(@arguments):

useAcc1;my$a=Acc1->new(42);print$a->(10),"\n";# prints 52print$a->(8),"\n";# prints 60

or using the coderef dereferencing syntax &$ref(@arguments):

useAcc2;my$a=Acc2->new(12);print&$a(10),"\n";# prints 22print&$a(8),"\n";# prints 30

In PHP

PHP 5.3+ has first-class functions that can be used e.g. as parameter to the usort() function:

$a=array(3,1,4);usort($a,function($x,$y){return$x-$y;});

PHP 5.3+, supports also lambda functions and closures.

functionAccumulator($start){$current=$start;returnfunction($x)use(&$current){return$current+=$x;};}

An example of this in use:

$a=Accumulator(4);$x=$a(5);echo"x = $x<br/>";// x = 9$x=$a(2);echo"x = $x<br/>";// x = 11

It is also possible in PHP 5.3+ to make objects invokable by adding a magic __invoke() method to their class: [6]

classMinus{publicfunction__invoke($x,$y){return$x-$y;}}$a=array(3,1,4);usort($a,newMinus());

In PowerShell

In the Windows PowerShell language, a script block is a collection of statements or expressions that can be used as a single unit. A script block can accept arguments and return values. A script block is an instance of a Microsoft .NET Framework type System.Management.Automation.ScriptBlock.

FunctionGet-Accumulator($x){{param($y)return$x+=$y}.GetNewClosure()}
PS C:\> $a=Get-Accumulator4PS C:\> &$a59PS C:\> &$a211PS C:\> $b=Get-Accumulator32PS C:\> &$b1042

In Python

In Python, functions are first-class objects, just like strings, numbers, lists etc. This feature eliminates the need to write a function object in many cases. Any object with a __call__() method can be called using function-call syntax.

An example is this accumulator class (based on Paul Graham's study on programming language syntax and clarity): [7]

classAccumulator:def__init__(self,n)->None:self.n=ndef__call__(self,x):self.n+=xreturnself.n

An example of this in use (using the interactive interpreter):

>>> a=Accumulator(4)>>> a(5)9>>> a(2)11>>> b=Accumulator(42)>>> b(7)49

Since functions are objects, they can also be defined locally, given attributes, and returned by other functions, [8] as demonstrated in the following example:

defAccumulator(n):definc(x):nonlocalnn+=xreturnnreturninc

In Ruby

In Ruby, several objects can be considered function objects, in particular Method and Proc objects. Ruby also has two kinds of objects that can be thought of as semi-function objects: UnboundMethod and block. UnboundMethods must first be bound to an object (thus becoming a Method) before they can be used as a function object. Blocks can be called like function objects, but to be used in any other capacity as an object (e.g. passed as an argument) they must first be converted to a Proc. More recently, symbols (accessed via the literal unary indicator :) can also be converted to Procs. Using Ruby's unary & operatorequivalent to calling to_proc on an object, and assuming that method exists the Ruby Extensions Project created a simple hack.

classSymboldefto_procproc{|obj,*args|obj.send(self,*args)}endend

Now, method foo can be a function object, i.e. a Proc, via &:foo and used via takes_a_functor(&:foo). Symbol.to_proc was officially added to Ruby on June 11, 2006 during RubyKaigi2006.

Because of the variety of forms, the term Functor is not generally used in Ruby to mean a Function object. Just a type of dispatch delegation introduced by the Ruby Facets project is named as Functor. The most basic definition of which is:

classFunctordefinitialize(&func)@func=funcenddefmethod_missing(op,*args,&blk)@func.call(op,*args,&blk)endend

This usage is more akin to that used by functional programming languages, like ML, and the original mathematical terminology.

Other meanings

In a more theoretical context a function object may be considered to be any instance of the class of functions, especially in languages such as Common Lisp in which functions are first-class objects.

The ML family of functional programming languages uses the term functor to represent a mapping from modules to modules, or from types to types and is a technique for reusing code. Functors used in this manner are analogous to the original mathematical meaning of functor in category theory, or to the use of generic programming in C++, Java or Ada.

In Haskell, the term functor is also used for a concept related to the meaning of functor in category theory.

In Prolog and related languages, functor is a synonym for function symbol.

See also

Notes

  1. In C++, a functionoid is an object that has one major method, and a functor is a special case of a functionoid. [1] They are similar to a function object, but not the same.

Related Research Articles

Templates are a feature of the C++ programming language that allows functions and classes to operate with generic types. This allows a function or class declaration to reference via a generic variable another different class without creating full declaration for each of these different classes.

In programming languages, a closure, also lexical closure or function closure, is a technique for implementing lexically scoped name binding in a language with first-class functions. Operationally, a closure is a record storing a function together with an environment. The environment is a mapping associating each free variable of the function with the value or reference to which the name was bound when the closure was created. Unlike a plain function, a closure allows the function to access those captured variables through the closure's copies of their values or references, even when the function is invoked outside their scope.

In object-oriented programming, the decorator pattern is a design pattern that allows behavior to be added to an individual object, dynamically, without affecting the behavior of other instances of the same class. The decorator pattern is often useful for adhering to the Single Responsibility Principle, as it allows functionality to be divided between classes with unique areas of concern as well as to the Open-Closed Principle, by allowing the functionality of a class to be extended without being modified. Decorator use can be more efficient than subclassing, because an object's behavior can be augmented without defining an entirely new object.

In object-oriented (OO) and functional programming, an immutable object is an object whose state cannot be modified after it is created. This is in contrast to a mutable object, which can be modified after it is created. In some cases, an object is considered immutable even if some internally used attributes change, but the object's state appears unchanging from an external point of view. For example, an object that uses memoization to cache the results of expensive computations could still be considered an immutable object.

<span class="mw-page-title-main">D (programming language)</span> Multi-paradigm system programming language

D, also known as dlang, is a multi-paradigm system programming language created by Walter Bright at Digital Mars and released in 2001. Andrei Alexandrescu joined the design and development effort in 2007. Though it originated as a re-engineering of C++, D is now a very different language drawing inspiration from other high-level programming languages, notably Java, Python, Ruby, C#, and Eiffel.

In mathematics and computer science, a higher-order function (HOF) is a function that does at least one of the following:

In computer science, a type signature or type annotation defines the inputs and outputs of a function, subroutine or method. A type signature includes the number, types, and order of the function's arguments. One important use of a type signature is for function overload resolution, where one particular definition of a function to be called is selected among many overloaded forms.

A function pointer, also called a subroutine pointer or procedure pointer, is a pointer referencing executable code, rather than data. Dereferencing the function pointer yields the referenced function, which can be invoked and passed arguments just as in a normal function call. Such an invocation is also known as an "indirect" call, because the function is being invoked indirectly through a variable instead of directly through a fixed identifier or address.

In compiler construction, name mangling is a technique used to solve various problems caused by the need to resolve unique names for programming entities in many modern programming languages.

In class-based, object-oriented programming, a constructor is a special type of function called to create an object. It prepares the new object for use, often accepting arguments that the constructor uses to set required member variables.

In mathematics and in computer programming, a variadic function is a function of indefinite arity, i.e., one which accepts a variable number of arguments. Support for variadic functions differs widely among programming languages.

typedef is a reserved keyword in the programming languages C, C++, and Objective-C. It is used to create an additional name (alias) for another data type, but does not create a new type, except in the obscure case of a qualified typedef of an array type where the typedef qualifiers are transferred to the array element type. As such, it is often used to simplify the syntax of declaring complex data structures consisting of struct and union types, although it is also commonly used to provide specific descriptive type names for integer data types of varying sizes.

A class in C++ is a user-defined type or data structure declared with any of the keywords class, struct or union that has data and functions as its members whose access is governed by the three access specifiers private, protected or public. By default access to members of a C++ class declared with the keyword class is private. The private members are not accessible outside the class; they can be accessed only through member functions of the class. The public members form an interface to the class and are accessible outside the class.

C++11 is a version of the ISO/IEC 14882 standard for the C++ programming language. C++11 replaced the prior version of the C++ standard, called C++03, and was later replaced by C++14. The name follows the tradition of naming language versions by the publication year of the specification, though it was formerly named C++0x because it was expected to be published before 2010.

In computer programming, an anonymous function 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. 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.

This article describes the syntax of the C# programming language. The features described are compatible with .NET Framework and Mono.

This article compares a large number of programming languages by tabulating their data types, their expression, statement, and declaration syntax, and some common operating-system interfaces.

In computer programming, variadic templates are templates that take a variable number of arguments.

C++14 is a version of the ISO/IEC 14882 standard for the C++ programming language. It is intended to be a small extension over C++11, featuring mainly bug fixes and small improvements, and was replaced by C++17. Its approval was announced on August 18, 2014. C++14 was published as ISO/IEC 14882:2014 in December 2014.

A callable object, in computer programming, is any object that can be called like a function.

References

  1. What's the difference between a functionoid and a functor?
  2. Silan Liu. "C++ Tutorial Part I - Basic: 5.10 Function pointers are mainly used to achieve call back technique, which will be discussed right after". TRIPOD: Programming Tutorials Copyright © Silan Liu 2002. Retrieved 2012-09-07. Function pointers are mainly used to achieve call back technique, which will be discussed right after.
  3. Paweł Turlejski (2009-10-02). "C++ Tutorial Part I - Basic: 5.10 Function pointers are mainly used to achieve call back technique, which will be discussed right after". Just a Few Lines. Retrieved 2012-09-07. PHP 5.3, along with many other features, introduced closures. So now we can finally do all the cool stuff that Ruby / Groovy / Scala / any_modern_language guys can do, right? Well, we can, but we probably won't… Here's why.
  4. "Overload resolution§Call to a class object". cppreference.com.
  5. Accumulator Generator
  6. PHP Documentation on Magic Methods
  7. Accumulator Generator
  8. Python reference manual - Function definitions

Further reading