Contains definition of transform<> and transform_impl<> helpers.

Inherit from this to make your type a PrimitiveTransform.
This(Expr)
typename PrimitiveTransform::template impl< Expr, unspecified, unspecified >::result_type
This(Expr, State)
typename PrimitiveTransform::template impl< Expr, State, unspecified >::result_type
This(Expr, State, Data)
typename PrimitiveTransform::template impl< Expr, State, Data >::result_type
PrimitiveTransform
typename PrimitiveTransform::template impl<Expr &, unspecified, unspecified>::result_type `Expr &` `typename PrimitiveTransform::template impl<Expr &, unspecified, unspecified>()(expr, unspecified, unspecified)`
typename PrimitiveTransform::template impl<Expr &, State &, unspecified>::result_type `Expr &` `State &` `typename PrimitiveTransform::template impl<Expr &, State &, unspecified>()(expr, state, unspecified)`
typename PrimitiveTransform::template impl<Expr &, State const &, unspecified>::result_type `Expr &` `State const &` `typename PrimitiveTransform::template impl<Expr &, State const &, unspecified>()(expr, state, unspecified)`
typename PrimitiveTransform::template impl<Expr &, State &, Data &>::result_type `Expr &` `State &` `Data &` `typename PrimitiveTransform::template impl<Expr &, State &, Data &>()(expr, state, data)`
typename PrimitiveTransform::template impl<Expr &, State const &, Data &>::result_type `Expr &` `State const &` `Data &` `typename PrimitiveTransform::template impl<Expr &, State const &, Data &>()(expr, state, data)`
typename boost::remove_reference<Expr const>::type
typename boost::add_reference<Expr const>::type
typename boost::remove_reference<State const>::type
typename boost::add_reference<State const>::type
typename boost::remove_reference<Data const>::type
typename boost::add_reference<Data const>::type
To turn an expression into a pseudo-parameter pack containing the expression's children, for the purpose of expanding the pack expression within a CallableTransform or ObjectTransform.

`proto::pack` is useful within CallableTransforms and ObjectTransforms when one wishes to unpack an expression into a function call or an object constructor. `proto::pack` turns a Proto expression into a pseudo-parameter pack, which may appear in an unpacking pattern to be expanded with the "`...`" syntax.

Example:

    // The following demonstrates how to use a pseudo-pack expansion
    // to unpack an expression into a function call.

    struct do_sum : proto::callable
    {
        typedef int result_type;

        int operator()(int i) const { return i; }
        int operator()(int i, int j) const { return i + j; }
        int operator()(int i, int j, int k) const { return i + j + k; }
    };

    // Take any n-ary expression where the children are all int terminals and sum all the ints
    struct sum
      : proto::when<

            // Match any nary expression where the children are all int terminals
            proto::nary_expr<_, proto::vararg<proto::terminal<int> > >

            // Turn the current expression into a pseudo-parameter pack, then expand it,
            // extracting the value from each child in turn.
          , do_sum(proto::_value(proto::pack(_))...)
        >
    {};

    int main()
    {
        proto::terminal<int>::type i = {42};
        int result = sum()( i(3,5) ); // Creates a ternary functional-call expression
        std::cout << "Sum of 42, 3, and 5 : " << result << std::endl;
    }

The above program displays:

`Sum of 42, 3, and 5 : 50`

In the above example, the type ``proto::_value`(proto::pack(`_`))` is a so-called unpacking pattern, described below.

Unpacking Patterns:

Composite transforms (either CallableTransforms or ObjectTransforms) usually have the form `X(A0,…An)`. However, when the argument list in a composite transform is terminated with a C-style vararg ellipsis as in `X(A0,…An ...)`, the final argument `An` is treated as an unpacking pattern.

An unpacking pattern must itself be a composite transform; that is, it must be a function type representing either a CallableTransform or an ObjectTransform. The type `proto::pack(_)` must appear exactly once in the unpacking pattern. This type will receive a substitution when the unpacking pattern is expanded.

A composite transform like `X(A0,…An ...)`, when evaluated against a given expression E, state and data, is evaluated as if it were `X(A0,…An-1,S)` where S is a type sequence computed as follows:

Let `SUB(A,B)` be a type function that replaces every occurence of `proto::pack(_)` within `A` with `B`.

- If the expression E is a terminal (i.e. it has arity 0), S is the one-element sequence containing `SUB(An, `proto::_value`)`.
- If the expression E is a non-terminal, S is the sequence `SUB(An, `proto::_child_c`<0>),… SUB(An, `proto::_child_c`<M-1>)`, where M is the arity of the expression E.