Function Object Article Index for
Function 		Website Links For
Function 		 

Information About

Function Object
  CATEGORIES ABOUT FUNCTION OBJECT
   
programming constructs
   
APPAREL
BABY
BEAUTY
BOOKS
CAR TOYS
CELL PHONES
DVD'S
ELECTRONICS
GOURMET FOOD
GROCERIES
HEALTH & PERSONAL
HOME & GARDEN
JEWELRY
MUSIC
MUSIC INSTRUMENTS
OFFICE PRODUCTS
SOFTWARE
SPORTING GOODS
TOOLS & HARDWARE
TOYS
VIDEO GAMES
SHOPPING HOME
MORE SHOPPING...




DESCRIPTION

A typical use of a functor is in writing more intelligent Callback Functions . A callback in Procedural Languages , such as C , may be accomplished by using Function Pointers . However it can be difficult or awkward to pass state into or out of the callback function. This restriction also inhibits more dynamic behavior of the function. A functor solves those problems since the function is really a Façade for a full object, thus it carries its own state.

Most modern object-oriented languages such as C++ , Java , Python , and Ruby support the definition of functors and may even make significant use of them.


ORIGINS

Smalltalk was one of the first languages to support functors through the use of block constructs that are an integral part of the language syntax. For example, one can supply functors as
arguments to collection objects to provide filtering & sorting. It is a perfect realization of the Strategy Pattern that promotes the use of pluggable behaviour.


FUNCTORS IN C AND C++

Consider the example of a sorting routine which uses a callback function to define an ordering relation between a pair of items. A C program using function pointers may appear as:

  • Callback function ---/

    • int compare_function(int A, int B) {

return (A < B);
}
...
  • Declaration of C sorting function ---/

  • begin_items, int num_items, int (---cmpfunc)(int, int) );

    • ...

int main() {
int items {Link without Title} = {4, 3, 1, 2};
sort_ints(items, 4, compare_function);
}

In C++ a functor may be used instead of an ordinary function by defining a class which Overloads the Function Call Operator by defining an operator() member function. In C++ this is called a '''class type functor''', and may appear as follows:

class compare_class {
public:
bool operator()(int A, int B) {
return (A < B);
}
};
...
// Declaration of C++ sorting function.
template
  • begin_items, int num_items, ComparisonFunctor c);

    • ...

int main() {
int items {Link without Title} = {4, 3, 1, 2};
compare_class functor;
sort_ints(items, 4, functor);
}

Notice that the syntax for providing the callback to the sort_ints() 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,

functor_class Y;
int result = Y( 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 functors in terms of other functors (like Function Composition ). Much of the C++ Standard Template Library (STL) makes heavy use of template-based function objects.


Performance


An advantage of function objects in C++ is performance because unlike a function pointer, a function object can be inlined. For example, consider a simple function which increments its argument implemented as a function object:
struct IncrementFunctor {
void operator()(int&i) { ++i; }
};
and as a free function:
void increment_function(int&i) { ++i; }
Recall the standard library function std::for_each():
template
Function for_each(InputIterator first, InputIterator last, Function f) {
for ( ; first != last; ++first)
  • first);

    • return f;

}
Suppose we apply std::for_each() like so:
int A {Link without Title} = {1, 4, 2, 8, 5, 7};
const int N = sizeof(A) / sizeof(int);
for_each(A, A + N, IncrementFunctor());
for_each(A, A + N, increment_function);
Both calls to for_each() will work as expected. The first call will be to this version:
  • ,IncrementFunctor>(int---, int---, IncrementFunctor)

    • the second will be to this version:

  • )(int&) for_each(int---, int---, void(---)(int&))

  • ,IncrementFunctor>(), the compiler will be able to inline the function object because the function is known at compile time whereas within for_each() the function cannot be known at compile time and so cannot be inlined.


Actually, a function can easily be known at compile time and the compiler will happily inline it, if it is instructed to. The only requirement is that the compiler has seen the function definition, and that applies equally to functions inside a class or outside. In case we are not inlining however, the linker is instructed to "silently" drop multiple definitions of the same function from different compilation units, without producing an error, but only if said function is a class function. The linker will not dismiss multiple definition of the same function if it is not a class function.


Maintain State

One advantage of functors is that they can maintain state (as fields of the object) between calls. For example, the following code defines a Generator (a function that takes no arguments) that counts from 10 up, and we invoke the generator 11 times and print the results.


#include 

#include 

#include 



class countfrom {

private:

  int count;

public:

  countfrom(int n) : count(n) {}

  int operator()() { return count++; }

};



int main() {

  std::generate_n(std::ostream_iterator(std::cout, "

"), 11, countfrom(10));

  return 0;

}



FUNCTORS IN JAVA

Functors in Java are typically expressed by defining a Method Signature in a Base Class (or an Interface ). Then different functors are created by deriving from the interface. This could be called an inheritance model of functors.

Take Apache's and Transformation functors. EqualPredicate, for instance, could be used as follows.


public class Functors {

  public static void main(String  {Link without Title} args) {

    Predicate p = new EqualPredicate ("wikipedia");

    if (p.evaluate (args {Link without Title} ))

         System.err.println ("true; " +args {Link without Title} + " is 'wikipedia'.");

    else

         System.err.println ("false;" +args {Link without Title} + " is not.");

  }

}


Notice that p is an object having evaluate method, so it can be treated like every other object.


FUNCTORS IN PYTHON

In Python, functions are objects, just like strings, numbers, lists, and so on. This feature eliminates the need to create a functor object in many cases. However, any object with a __call__() method may be called using function-call syntax.

An example is this Accumulator class (based on Paul Graham 's study on programming language syntax and clarity here ):


class Accumulator(object):
def __init__(self, n):
self.n = n
def __call__(self, x):
self.n += x
return self.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


Due to the dynamic nature of the language an ordinary object can be converted into a functor at run-time, but this is rare in practice.


FUNCTORS IN LISP

In Common Lisp, and languages in that family, functions are objects, just like strings, vectors, lists, numbers and so forth. A closure-constructing operator creates a function-object from a piece of the program itself: the piece 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 functor, 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 such and such 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, he or she must define a class which 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:


(defclass counter ()

  ((value :initarg :value :accessor value)))



(defgeneric functor-call (function-object))



(defmethod functor-call ((c counter))

  (return (incf (value c))))



(defun make-counter (initial-value)

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



;;; use the counter:




    

  • c--- (make-counter 10))

    • 






    

  • c---) --> 11

    • 

  • c---) --> 12 

    •

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 which gives us functors, 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".



(defun make-counter (initial-value)

  (lambda () (incf initial-value)))



;;; use the counter




    

  • c--- (make-counter 10))

    • 






    

  • 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 entirely with closures.

So there exists a kind of tunnel being dug from both sides of the proverbial mountain. Programmers in OOP languages discover functors 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.


FUNCTORS IN RUBY


—the Ruby Extensions Project created a simple hack.

class Symbol
def to_proc