Function

| Home | Libraries | People | FAQ | More

### Function

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:

- An `operator()` that takes `N` arguments, and implements the function logic. This is also true for ordinary function pointers.
- A nested metafunction `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
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.