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.