|  | Home | Libraries | People | FAQ | More | 
        The function class template
        provides a mechanism for implementing lazily evaluated functions. Syntactically,
        a lazy function looks like an ordinary C/C++ function. The function call
        looks familiar and feels the same as ordinary C++ functions. However, unlike
        ordinary functions, the actual function execution is deferred.
      
#include <boost/phoenix/function.hpp>
Unlike ordinary function pointers or functor objects that need to be explicitly bound through the bind function (see Bind), the argument types of these functions are automatically lazily bound.
        In order to create a lazy function, we need to implement a model of the
        Polymorphic
        Function Object concept. For a function that takes N arguments, a model of Polymorphic
        Function Object must provide:
      
operator()
            that takes N arguments,
            and implements the function logic. This is also true for ordinary function
            pointers.
          result<Signature> or nested typedef result_type,
            following the Boost.Result
            Of Protocol
          For example, the following type implements the FunctionEval concept, in order to provide a lazy factorial function:
struct factorial_impl { template <typename Sig> struct result; template <typename This, typename Arg> struct result<This(Arg const &)> { typedef Arg type; }; template <typename Arg> Arg operator()(Arg const & n) const { return (n <= 0) ? 1 : n * (*this)(n-1); } };
(See factorial.cpp)
        Having implemented the factorial_impl
        type, we can declare and instantiate a lazy factorial
        function this way:
      
function<factorial_impl> factorial;
        Invoking a lazy function such as factorial
        does not immediately execute the function object factorial_impl.
        Instead, an actor object is created
        and returned to the caller. Example:
      
factorial(arg1)
does nothing more than return an actor. A second function call will invoke the actual factorial function. Example:
std::cout << factorial(arg1)(4);
will print out "24".
Take note that in certain cases (e.g. for function objects with state), an instance of the model of Polymorphic Function Object may be passed on to the constructor. Example:
function<factorial_impl> factorial(ftor);
        where ftor is an instance of factorial_impl (this is not necessary in this
        case as factorial_impl does
        not require any state).
      
| ![[Important]](../../../../../../doc/src/images/important.png) | Important | 
|---|---|
| Take care though when using function objects with state because they are often copied repeatedly, and state may change in one of the copies, rather than the original. |