Boost C++ Libraries of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

This is the documentation for an old version of Boost. Click here to view this page for the latest version.


Adapting Functions

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:

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:


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