Jump to content

Function object: Difference between revisions

From Wikipedia, the free encyclopedia
Browse history interactively
← Previous editNext edit →
Content deleted Content added
VisualWikitext
←Replaced content with 'l[llkpkpk'
Tag: blanking
Line 1: Line 1:
l[llkpkpk
{{About|the computer programming concept|functors in category theory|Functor}}
{{Refimprove|date=February 2009}}
A '''function object'''{{efn|1=In C++, a '''functionoid''' is an object that has one major method, and a '''functor''' is a special case of a functionoid.<ref>[http://www.parashift.com/c++-faq-lite/pointers-to-members.html#faq-33.15 33.15: What's the difference between a functionoid and a functor?]</ref> They are similar to a function object, ''but not the same''.}} is a [[computer programming]] construct allowing an [[object (computer science)|object]] to be invoked or called as if it were an ordinary [[subroutine|function]], usually with the same syntax (a function parameter that can also be a function).

==Description==
A typical use of a function object is in writing [[callback (computer science)|callback]] functions. A callback in [[procedural programming|procedural languages]], such as [[C (programming language)|C]], may be performed by using [[function pointer]]s.<ref>{{cite web
| url = http://progtutorials.tripod.com/cpp1.htm#_Toc50820124
| title = C++ Tutorial Part I - Basic: 5.10 Function pointers are mainly used to achieve call back technique, which will be discussed right after.
| author = Silan Liu
| authorlink =
| date =
| publisher = TRIPOD: Programming Tutorials Copy Right © Silan Liu 2002
| quote = Function pointers are mainly used to achieve call back technique, which will be discussed right after.
| accessdate = 2012-09-07
}}</ref> 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 [[facade pattern|façade]] for a full object, carrying its own state.

Many modern (and some older) languages, e.g. [[C++]], [[Groovy (programming language)|Groovy]], [[Lisp (programming language)|Lisp]], [[Smalltalk]], [[Perl]], [[PHP]], [[Python (programming language)|Python]], [[Ruby (programming language)|Ruby]], [[Scala (programming language)|Scala]], and many others, support [[first-class function]] objects and may even make significant use of them.<ref>{{cite web
| url = http://progtutorials.tripod.com/cpp1.htm#_Toc50820124
| title = C++ Tutorial Part I - Basic: 5.10 Function pointers are mainly used to achieve call back technique, which will be discussed right after.
| author = Paweł Turlejski
| authorlink = | date = 2009-10-02
| publisher = Just a Few Lines
| quote = 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.
| accessdate = 2012-09-07
}}</ref> [[Functional programming]] languages additionally support [[closure (computer science)|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. A C program using function pointers may appear as:

<source lang=C>
#include <stdlib.h>

/* Callback function, returns < 0 if a < b, > 0 if a > b, 0 if a == b */
int compareInts(const void* a, const void* b)
{
return *(const int *)a - *(const int *)b;
}
...
// prototype of qsort is
// void qsort(void *base, size_t nel, size_t width, int (*compar)(const void *, const void *));
...
int main(void)
{
int items[] = { 4, 3, 1, 2 };
qsort(items, sizeof(items) / sizeof(items[0]), sizeof(items[0]), compareInts);
return 0;
}
</source>

In C++, a function object may be used instead of an ordinary function by defining a class that [[operator overloading|overloads]] the [[function call operator]] by defining an <code>operator()</code> member function. In C++, this is called a ''class type functor'', and may appear as follows:

<source lang=Cpp>
// comparator predicate: returns true if a < b, false otherwise
struct IntComparator
{
bool operator()(const int &a, const int &b) const
{
return a < b;
}
};
...
// An overload of std::sort is:
template <class RandomIt, class Compare>
void sort(RandomIt first, RandomIt last, Compare comp);
...
int main()
{
std::vector<int> items { 4, 3, 1, 2 };
std::sort(items.begin(), items.end(), IntComparator());
return 0;
}
</source>

Notice that the syntax for providing the callback to the <code>sortInts()</code> 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.

It is possible to use function objects in situations other than as callback functions (although the shortened term ''functor'' is normally not used). Continuing the example,

<source lang=Cpp>
IntComparator cpm;
bool result = cpm(a, b);
</source>

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 [[generic programming|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 (computer science)|function composition]]). Much of the C++ [[Standard Template Library]] (STL) makes heavy use of template-based function objects.

[[C++11]] allows one to define [[anonymous function]] objects. The line from the prior example could be written as follows:

<source lang=Cpp>
sortInts(items.begin(), items.end(), [](int a, int b) { return a < b; });
</source>

=== Maintaining state ===
Another advantage of function objects is their ability to maintain a state that affects <code lang=C>operator()</code> between calls. For example, the following code defines a [[generator (computer science)|generator]] counting from 10 upwards and is invoked 11 times.

<source lang=Cpp>
#include <iostream>
#include <iterator>
#include <algorithm>

class CountFrom {
private:
int &count;
public:
CountFrom(int &n) : count(n) {}
int operator()() { return count++; }
};

int main()
{
int state(10);
std::generate_n(std::ostream_iterator<int>(std::cout, "\n"), 11, CountFrom(state));
return 0;
}
</source>

== In C# ==
In [[C Sharp (programming language)|C#]], function objects are declared via [[delegate (CLI)|delegate]]s. A delegate can be declared using a named method or a [[Lambda (programming)|lambda expression]]. Here is an example using a named method.

<source lang=CSharp>
using System;
using System.Collections.Generic;

public class ComparisonClass1 {
public static int CompareFunction(int x, int y) {
return x - y;
}

public static void Main() {
List<int> items = new List<int> { 4, 3, 1, 2 };

Comparison<int> del = CompareFunction;

items.Sort(del);
}
}
</source>

Here is an example using a lambda expression.

<source lang=CSharp>
using System;
using System.Collections.Generic;

public class ComparisonClass2 {
public static void Main() {
List<int> items = new List<int> { 4, 3, 1, 2 };
items.Sort((x, y) => x - y);
}
}
</source>

== In D ==
[[D (programming language)|D]] provides several ways to declare function objects: Lisp/Python-style via [[closure (computer science)|closures]] or C#-style via [[delegate (CLI)|delegate]]s, respectively:

<source lang=D>
bool find(T)(T[] haystack, bool delegate(T) needle_test) {
foreach (straw; haystack) {
if (needle_test(straw))
return true;
}
return false;
}

void main() {
int[] haystack = [345, 15, 457, 9, 56, 123, 456];
int needle = 123;
bool needleTest(int n) {
return n == needle;
}
assert(
find(haystack, &needleTest)
);
}
</source>

The difference between a [[delegate (CLI)|delegate]] and a [[closure (computer science)|closure]] in D is automatically and conservatively determined by the compiler. D also supports function literals, that allow a lambda-style definition:

<source lang=D>
void main() {
int[] haystack = [345, 15, 457, 9, 56, 123, 456];
int needle = 123;
assert(
find(haystack, (int n) { return n == needle; })
);
}
</source>

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

<source lang=D>
bool find(T, F)(T[] haystack, F needle_test) {
foreach (straw; haystack) {
if (needle_test(straw))
return true;
}
return false;
}

void main() {
int[] haystack = [345, 15, 457, 9, 56, 123, 456];
int needle = 123;
class NeedleTest {
int needle;
this(int n) { needle = n; }
bool opCall(int n) {
return n == needle;
}
}
assert(
find(haystack, new NeedleTest(needle))
);
}
</source>

==In Eiffel==

In the [[Eiffel (programming language)|Eiffel]] software development method and language, operations and objects are seen always as separate concepts. However, the [[Eiffel (programming language)#Agents|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: <code lang=Eiffel>PROCEDURE</code> and <code lang=Eiffel>FUNCTION</code>. These two classes descend from the more abstract <code lang=Eiffel>ROUTINE</code>.

Within software text, the language keyword <code lang=Eiffel>agent</code> 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.

<source lang=Eiffel>
my_button.select_actions.extend (agent my_gauge.step_forward)
</source>

The routine <code lang=Eiffel>extend</code> 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 <code lang=Eiffel>for_all</code> of type <code lang=Eiffel>BOOLEAN</code> that accepts an agent, an instance of <code lang=Eiffel>FUNCTION</code>, as an argument. So, in the following example, <code lang=Eiffel>my_action</code> is executed only if all members of <code lang=Eiffel>my_list</code> contain the character '!':

<source lang=Eiffel>
my_list: LINKED_LIST [STRING]
...
if my_list.for_all (agent {STRING}.has ('!')) then
my_action
end
...
</source>

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 <code lang=Eiffel>for_all</code> expects as an argument an agent representing a function with one open argument or target that conforms to actual generic parameter for the structure (<code lang=Eiffel>STRING</code> 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 <code lang=Eiffel>agent {STRING}.has ('!')</code> 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:

<source lang=Eiffel>
print_on_new_line (s: STRING)
-- Print `s' preceded by a new line
do
print ("%N" + s)
end
</source>

The following snippet, assumed to be in the same class, uses <code lang=Eiffel>print_on_new_line</code> to demonstrate the mixing of open arguments and open targets in agents used as arguments to the same routine.

<source lang=Eiffel>
my_list: LINKED_LIST [STRING]
...
my_list.do_all (agent print_on_new_line (?))
my_list.do_all (agent {STRING}.to_lower)
my_list.do_all (agent print_on_new_line (?))
...
</source>

This example uses the procedure <code lang=Eiffel>do_all</code> 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 <code lang=Eiffel>my_list</code>, converts the strings to lowercase, and then prints them again.

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

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:

<source lang=Eiffel>
my_list.do_all (agent my_multi_arg_procedure (closed_arg_1, ?, closed_arg_2, closed_arg_3)
</source>

The Eiffel agent mechanism is detailed in the [http://www.ecma-international.org/publications/standards/Ecma-367.htm Eiffel ISO/ECMA standard document].

== In Java ==
[[Java (programming language)|Java]] has no [[first-class function]]s, so function objects are usually expressed by an interface with a single method (most commonly the <code lang=Java>Callable</code> interface), typically with the implementation being an anonymous [[inner class]], or, starting in Java 8, a [[anonymous function|lambda]].

For an example from Java's standard library, <code lang=Java>java.util.Collections.sort()</code> takes a <code lang=Java>List</code> 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.

<source lang=Java>
List<String> list = Arrays.asList("10", "1", "20", "11", "21", "12");
Comparator<String> numStringComparator = new Comparator<String>() {
public int compare(String str1, String str2) {
return Integer.valueOf(str1).compareTo(Integer.valueOf(str2));
}
};

Collections.sort(list, numStringComparator);
</source>

In Java 8+, this can be written as:
<source lang=Java>
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);
</source>

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

Compare the following with the subsequent Python example.

<source lang=JavaScript>
function Accumulator(start) {
var current = start;
return function (x) {
return current += x;
};
}
</source>

An example of this in use:

<source lang=JavaScript>
var a = Accumulator(4);
var x = a(5); // x has value 9
x = a(2); // x has value 11
var b = Accumulator(42);
x = b(7); // x has value 49 (current = 42 in closure b)
x = a(7); // x has value 18 (current = 11 in closure a)
</source>

== In Lisp and Scheme ==
In Lisp family languages such as [[Common Lisp]], [[Scheme (programming language)|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 (computer science)|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 <code>(lambda (parameters ...) code ...)</code>. The <code>(parameters ...)</code> part allows an interface to be declared, so that the function takes the declared parameters. The <code>code ...</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, no use of closures:

<source lang=Lisp>
(defclass counter ()
((value :initarg :value :accessor value-of)))

(defmethod functor-call ((c counter))
(incf (value-of c)))

(defun make-counter (initial-value)
(make-instance 'counter :value initial-value))

;;; use the counter:
(defvar *c* (make-counter 10))
(functor-call *c*) --> 11
(functor-call *c*) --> 12
</source>

Since there is no standard way to make funcallable objects in 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''.

<source lang=Lisp>
(defun make-counter (value)
(lambda () (incf value)))

;;; use the counter
(defvar *c* (make-counter 10))
(funcall *c*) ; --> 11
(funcall *c*) ; --> 12
</source>

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

<source lang=scheme>
(define (make-counter value)
(lambda () (set! value (+ value 1)) value))
;;; use the counter
(define c (make-counter 10))
(c) ; --> 11
(c) ; --> 12
</source>

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 <code>NSInvocation</code> 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 <code>myMethod</code>:

<source lang=ObjC>
// Construct a function object
SEL sel = @selector(myMethod);
NSInvocation* inv = [NSInvocation invocationWithMethodSignature:
[[self methodSignatureForSelector:sel]];
[inv setTarget:self];
[inv setSelector:sel];

// Do the actual invocation
[inv invoke];
</source>

An advantage of <code>NSInvocation</code> is that the target object can be modified after creation. A single <code>NSInvocation</code> can be created and then called for each of any number of targets, for instance from an observable object. An <code>NSInvocation</code> can be created from only a protocol, but it is not straightforward. See [http://www.a-coding.com/2010/10/making-nsinvocations.html 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:

<source lang=Perl>
package Acc1;
sub new {
my $class = shift;
my $arg = shift;
my $obj = sub {
my $num = shift;
$arg += $num;
};
bless $obj, $class;
}
1;
</source>

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

<source lang=Perl>
package Acc2;
use overload
'&{}' =>
sub {
my $self = shift;
sub {
$num = shift;
$self->{arg} += $num;
}
};
sub new {
my $class = shift;
my $arg = shift;
my $obj = { arg => $arg };
bless $obj, $class;
}
1;
</source>

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

<source lang=Perl>
use Acc1;
my $a = Acc1->new(42);
# prints '52'
print $a->(10), "\n";
# prints '60'
print $a->(8), "\n";
</source>
or using the coderef dereferencing syntax ''&$ref(@arguments)'':
<source lang=Perl>
use Acc2;
my $a = Acc2->new(12);
# prints '22'
print &$a(10), "\n";
# prints '30'
print &$a(8), "\n";
</source>

== In PHP ==

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

<source lang=PHP>
$a = array(3, 1, 4);
usort($a, function ($x, $y) { return $x - $y; });
</source>

It is also possible in PHP 5.3+ to make objects invokable by adding a magic __invoke() method to their class:<ref name="phpinvoke">[http://php.net/manual/en/language.oop5.magic.php#object.invoke PHP Documentation on Magic Methods]</ref>

<source lang=PHP>
class Minus {
public function __invoke($x, $y) {
return $x - $y;
}
}

$a = array(3, 1, 4);
usort($a, new Minus());
</source>

== 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.

<source lang=PowerShell>
Function Get-Accumulator($x) {
{
param($y)
return $script:x += $y
}.GetNewClosure()
}
</source>
<source lang=PowerShell>
PS C:\> $a = Get-Accumulator 4

PS C:\> & $a 5

9

PS C:\> & $a 2

11

PS C:\> $b = Get-Accumulator 32

PS C:\> & $b 10

42
</source>

== In Python ==
In [[Python (programming language)|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 <code>__call__()</code> method can be called using function-call syntax.

An example is this accumulator class (based on [[Paul Graham (computer programmer)|Paul Graham's]] study on programming language syntax and clarity):<ref>[http://www.paulgraham.com/accgen.html Accumulator Generator]</ref>

<source lang=Python>
class Accumulator(object):
def __init__(self, n):
self.n = n
def __call__(self, x):
self.n += x
return self.n
</source>

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

<source lang=Python>
>>> a = Accumulator(4)
>>> a(5)
9
>>> a(2)
11
>>> b = Accumulator(42)
>>> b(7)
49
</source>

Since functions are objects, they can also be defined locally, given attributes, and returned by other functions
,<ref>[https://docs.python.org/3/reference/compound_stmts.html#function-definitions Python reference manual - Function definitions]</ref> as demonstrated in the following two examples:

<source lang=Python>
def Accumulator(n):
def inc(x):
inc.n += x
return inc.n
inc.n = n
return inc
</source>

Function object creation using a [[Closure (computer science)|closure]] referencing a [[non-local variable]] in Python 3:

<source lang=Python>
def Accumulator(n):
def inc(x):
nonlocal n
n += x
return n
return inc
</source>

== In Ruby ==
In [[Ruby (programming language)|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 <code>:</code>) can also be converted to <code>Proc</code>s. Using Ruby's unary <code>&</code> operator&mdash;equivalent to calling <code>to_proc</code> on an object, and [[duck typing|assuming that method exists]]&mdash;the [[Ruby Extensions Project]] [http://blogs.pragprog.com/cgi-bin/pragdave.cgi/Tech/Ruby/ToProc.rdoc created a simple hack.]

<source lang=Ruby>
class Symbol
def to_proc
proc { |obj, *args| obj.send(self, *args) }
end
end
</source>

Now, method <code>foo</code> can be a function object, i.e. a <code>Proc</em>, via <code>&:foo</code> and used via <code>takes_a_functor(&:foo)</code>. <code>Symbol.to_proc</code> was officially added to Ruby on June 11, 2006 during RubyKaiga2006. [http://redhanded.hobix.com/cult/symbolTo_procExonerated.html]

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 (programming)|delegation]] introduced by the [http://facets.rubyforge.org Ruby Facets] project is named as Functor. The most basic definition of which is:

<source lang=Ruby>
class Functor
def initialize(&func)
@func = func
end
def method_missing(op, *args, &blk)
@func.call(op, *args, &blk)
end
end
</source>

This usage is more akin to that used by functional programming languages, like [[ML (programming language)|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 object]]s.

The [[functional programming]] languages [[ML (programming language)|ML]] and [[Haskell (programming language)|Haskell]] use the term ''functor'' to represent a [[function (mathematics)|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 (programming language)|Ada]].

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

== See also ==
* [[Callback (computer science)]]
* [[Closure (computer science)]]
* [[Function pointer]]
* [[Higher-order function]]
* [[Command pattern]]
* [[Currying]]

==Notes==
{{notelist}}

== References ==
{{Reflist}}

==Further reading ==
* David Vandevoorde & Nicolai M Josuttis (2006). ''C++ Templates: The Complete Guide'', ISBN 0-201-73484-2: Specifically, chapter 22 is devoted to function objects.

== External links ==
* [http://c2.com/cgi/wiki?FunctorObject Description from the Portland Pattern Repository]
* [http://www.two-sdg.demon.co.uk/curbralan/papers/AsynchronousC++.pdf C++ Advanced Design Issues - Asynchronous C++] by [[Kevlin Henney]]
* [http://www.newty.de/fpt/index.html The Function Pointer Tutorials] by Lars Haendel (2000/2001)
* Article "[http://cuj.com/documents/s=8464/cujcexp0308sutter/ Generalized Function Pointers]" by [[Herb Sutter]]
* [http://jga.sourceforge.net/ Generic Algorithms for Java]
* [http://www.amcgowan.ca/blog/computer-science/php-functors-function-objects-in-php/ PHP Functors - Function Objects in PHP]
* [http://parashift.com/c%2B%2B-faq-lite/pointers-to-members.html#faq-33.10 What the heck is a functionoid, and why would I use one?] (C++ FAQ)

{{DEFAULTSORT:Function Object}}
[[Category:Object (computer science)]]
[[Category:Subroutines]]
[[Category:Articles with example C code]]
[[Category:Articles with example C++ code]]
[[Category:Articles with example Java code]]
[[Category:Articles with example Perl code]]
[[Category:Articles with example Python code]]
[[Category:Articles with example Ruby code]]

Revision as of 13:34, 4 November 2014

l[llkpkpk

Retrieved from "https://en.wikipedia.org/enwiki/w/index.php?title=Function_object&oldid=632416050"