Citizendia
Your Ad Here

A function object, also called a functor, functional, or functionoid, is a computer programming construct allowing an object to be invoked or called as if it were an ordinary function, usually with the same syntax. In its simplest embodiment an object is an allocated region of storage In Computer science, a subroutine ( function, method, procedure, or subprogram) is a portion of code within a larger The term functor, in this context, is not related to the concept of a functor in the mathematical field of category theory. In Category theory, a branch of Mathematics, a functor is a special type of mapping between categories In Mathematics, category theory deals in an abstract way with mathematical Structures and relationships between them it abstracts from sets

Contents

Description

A typical use of a functor is in writing callback functions. In Computer programming, a callback is Executable code that is passed as an argument to other code A callback in procedural languages, such as C, may be accomplished by using function pointers. Procedural programming can sometimes be used as a synonym for Imperative programming (specifying the steps the program must take to reach the desired state but can also tags please moot on the talk page first! --> In Computing, C is a general-purpose cross-platform block structured A function pointer is a type of Pointer in C, C++, D, and other C-like programming languages 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. The facade pattern or façade pattern is a Software engineering design pattern commonly used with Object-oriented programming.

Most modern object-oriented languages such as C++, Java, Python, Ruby and Lisp support the definition of functors and may even make significant use of them. C++ (" C Plus Plus " ˌsiːˌplʌsˈplʌs is a general-purpose Programming language. Python is a general-purpose High-level programming language. Its design philosophy emphasizes programmer productivity and code readability Ruby is a dynamic, reflective, general purpose Object-oriented programming language that combines syntax inspired by Perl with Smalltalk Lisp (or LISP) is a family of Computer Programming languages with a long history and a distinctive fully parenthesized syntax

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. Smalltalk is an object-oriented, dynamically typed, reflective programming language. 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. In Computer programming, the strategy pattern (also known as the policy pattern) is a particular software design pattern, whereby Algorithms can

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 */
void sort_ints(int* begin_items, int num_items, int (*cmpfunc)(int, int) );
. . . 
int main() {
    int items[] = {4, 3, 1, 2};
    sort_ints(items, sizeof(items)/sizeof(int), 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 Computer programming, operator overloading (less commonly known as operator Ad-hoc polymorphism) is a specific case of polymorphism in This is a list of operators in the C++ and C programming languages. 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 <class ComparisonFunctor> 
void sort_ints(int* begin_items, int num_items, ComparisonFunctor c);
. . . 
int main() {
    int items[] = {4, 3, 1, 2};
    compare_class functor;
    sort_ints(items, sizeof(items)/sizeof(int), 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. Generic programming is a style of Computer programming in which algorithms are written in terms of to-be-specified-later types that are then instantiated The expressiveness of templates allows some functional programming techniques to be used, such as defining functors in terms of other functors (like function composition). In Computer science, functional programming is a Programming paradigm that treats Computation as the evaluation of mathematical functions and In Mathematics, a composite function represents the application of one function to the results of another Much of the C++ Standard Template Library (STL) makes heavy use of template-based function objects. The Standard Template Library ( STL) is a software library partially included in the C++ Standard Library.

Performance

An advantage of function objects in C++ is performance because unlike a function pointer, a function object can be inlined. In Computer science, an inline function is a Programming language construct used to suggest to a Compiler that a particular function be subjected to 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<typename InputIterator, typename Function>
Function for_each(InputIterator first, InputIterator last, Function f) {
  for ( ; first != last; ++first)
    f(*first);
  return f;
}

Suppose we apply std::for_each() like so:

int A[] = {1, 4, 2, 8, 5, 7};
const int N = sizeof(A) / sizeof(a[0]);
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 for_each<int*,IncrementFunctor>(int*, int*, IncrementFunctor)

the second will be to this version:

void(*)(int&) for_each<int*,void(*)(int&)>(int*, int*, void(*)(int&))

Within for_each<int*,IncrementFunctor>(), the compiler will be able to inline the function object because the function is known at compile time whereas within for_each<int*,void(*)(int&)>() 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. In Computer science, a generator is a special routine that can be used to control the Iteration behaviour of a loop. 

#include <iostream>
#include <iterator>
#include <algorithm>
 
class countfrom {
private:
  int count;
public:
  countfrom(int n) : count(n) {}
  int operator()() { return count++; }
};
 
int main() {
  std::generate_n(std::ostream_iterator<int>(std::cout, "\n"), 11, countfrom(10));
  return 0;
}

Functors in D

D provides several ways of declaring functors. The D programming language, also known simply as D, is an object-oriented, imperative, multiparadigm System programming language Lisp/Python-style using closures or C#-style using delegates, respectively:

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)
    );
}

The difference between a delegate and a closure in D is automatically and conservatively determined by the compiler. In Computer science, a closure is a function that is evaluated in an environment containing one or more Bound variables When called the function can access A delegate is a form of type-safe Function pointer used by the. A delegate is a form of type-safe Function pointer used by the. In Computer science, a closure is a function that is evaluated in an environment containing one or more Bound variables When called the function can access D also supports function literals, that allow a lambda-style definition:

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

In order to allow the compiler to inline the code (see above), functors can also be specified C++-style using operator overloading:

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))
    );
}

Functors in Java

Since Java does not have first-class functions, functors are usually expressed by an interface with a single method, typically with the implementation being an anonymous inner class. In Computer programming, operator overloading (less commonly known as operator Ad-hoc polymorphism) is a specific case of polymorphism in In Computer science, a Programming language is said to support first-class functions (or function literal) if it treats functions as In Object-oriented programming, an inner class (aka nested class) is a class declared entirely within the body of another class or interface

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. But because Java does not have first-class functions, the function is part of the Comparator interface. This could be used as follows. 

List<String> list = Arrays. asList(new String[] {
    "10", "1", "20", "11", "21", "12"
});
 
Collections. sort(list, new Comparator<String>() {
    public int compare(String o1, String o2) {
        return Integer. valueOf(o1). compareTo(Integer. valueOf(o2));
    }
});

Functors in Python

In Python, functions are objects, just like strings, numbers, lists, and so on. Python is a general-purpose High-level programming language. Its design philosophy emphasizes programmer productivity and code readability 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. Paul Graham (born 1964 is a Programmer, Venture capitalist and Essayist, known for his work on Lisp. 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

Another way to construct a functor in Python is to use a closure:

def Accumulator(n):
    def inc(x):
        inc. n += x
        return inc. n
    inc. n = n
    return inc

Functors in Lisp

In Common Lisp, Scheme and other languages in that family, functions are objects, just like strings, vectors, lists, numbers and so forth. Common Lisp, commonly abbreviated CL, is a dialect of the Lisp Programming language, published in ANSI standard document Information 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. In Computer science, a closure is a function that is evaluated in an environment containing one or more Bound variables When called the function can access 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, 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-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

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. The factory method pattern is an Object-oriented design pattern. 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
 
(defvar *c* (make-counter 10))
 
(funcall *c*) --> 11
(funcall *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. In Computer science, dynamic dispatch is the process of mapping a message to a specific sequence of code ( method) at Runtime.

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. In Computer science, dynamic dispatch is the process of mapping a message to a specific sequence of code ( method) at Runtime.

Functors in Ruby

Ruby has a number of objects that can be considered functors, in particular Method and Proc. Ruby is a dynamic, reflective, general purpose Object-oriented programming language that combines syntax inspired by Perl with Smalltalk Ruby also has two kinds of objects that can be thought of as semi-functors: UnboundMethod and block. UnboundMethods must first be bound to an object (thus becoming a Method) before they can be used as a functor. Blocks can be called like functors, but in order to be used in any other capacity as an object (eg. 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 & operator—equivalent to calling to_proc on an object, and assuming that method exists—the Ruby Extensions Project created a simple hack.

class Symbol
   def to_proc
      proc { |obj, *args| obj. In Computer programming, duck typing is a style of Dynamic typing in which an object's current set of methods and properties determines the valid send(self, *args) }
   end
end

Now, method foo can be a functor, 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 RubyKaiga2006. Events 1184 BC - Trojan War: Troy is sacked and burned according to the calculations of Eratosthenes. Year 2006 ( MMVI) was a Common year starting on Sunday of the Gregorian calendar. [1]

Because of the variety of forms, the term Functor is not generally used in Ruby to mean a Function object. Rather it has come to represent a type of dispatch delegation introduced by the Ruby Facets project. In Object-oriented programming there are two related notions of delegation. The most basic definition of which is:

class Functor
  def initialize(&func)
    @func = func
  end
  def method_missing(op, *args, &blk)
    @func. call(op, *args, &blk)
  end
end

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

Other meanings of functor

In some functional programming languages, such as ML, a functor represents a mapping from modules to modules, and is a technique for reusing code. In Computer science, functional programming is a Programming paradigm that treats Computation as the evaluation of mathematical functions and ML is a general-purpose Functional programming language developed by Robin Milner and others in the late 1970s at the University of Edinburgh, whose syntax The Mathematical concept of a function expresses dependence between two quantities one of which is given (the independent variable, argument of the function Functors used in this manner are analogous to the original mathematical meaning of functor in category theory, or to the use of templates in C++. In Category theory, a branch of Mathematics, a functor is a special type of mapping between categories In Mathematics, category theory deals in an abstract way with mathematical Structures and relationships between them it abstracts from sets

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. Common Lisp, commonly abbreviated CL, is a dialect of the Lisp Programming language, published in ANSI standard document Information In Computing, a first-class object (also value, entity, and citizen) in the context of a particular Programming language, is an entity In this case the shortened term functor is rarely used.

In Prolog and related languages, functor is a synonym for function symbol. Prolog is a Logic programming language It is a general purpose language often associated with Artificial intelligence and Computational linguistics In Formal logic and related branches of Mathematics, a functional predicate, or function symbol, is a logical symbol that may be applied to an object term

See also

References

External links

Kevlin Henney is an Author who writes on the subject of Computer programming in C and C++ for magazines such as the C/C++ Users Journal Herb Sutter is one of the most prominent C++ experts He is also a book author and a columnist for Dr

Dictionary

function object

-noun

  1. (computing) An object that encapsulates a function pointer (or equivalent).
© 2009 citizendia.org; parts available under the terms of GNU Free Documentation License, from http://en.wikipedia.org
 Dapyx Software network: MP3 Explorer | Ebook Manager | Zenithic