Contains definitions for various expression traits and utilities like ``proto::tag_of`<>` and ``proto::arity_of`<>`; the functions `proto::value()`, `proto::left()` and `proto::right()`; `proto::child()`, `proto::child_c()`, `proto::as_expr()`, `proto::as_child()`, and assorted helpers.

Boolean metafunction which tells whether a type is a callable PolymorphicFunctionObject or not.

`proto::is_callable<>` is used by the ``proto::when<>`` transform to determine whether a function type `R(A1,...An)` is a CallableTransform or an ObjectTransform. The former are evaluated using ``proto::call<>`` and the later with ``proto::make<>``. If `proto::is_callable<R>::value` is `true`, the function type is a CallableTransform; otherwise, it is an ObjectTransform.

Unless specialized for a type `T`, `proto::is_callable<T>::value` is computed as follows:

- If `T` is a template type `X<Y0,...Yn>`, where all `Yx` are types for `x` in `[0,n]`, `proto::is_callable<T>::value` is `boost::is_same<Yn, `proto::callable`>::value`.

- If `T` is derived from ``proto::callable``, `proto::is_callable<T>::value` is `true`.

- Otherwise, `proto::is_callable<T>::value` is `false`.

mpl::bool_<true-or-false>
Boolean metafunction which tells whether a type is a PrimitiveTransform or not.

`proto::is_transform<>` is used by the ``proto::make<>`` transform to determine whether a type `R` represents a PrimitiveTransform to apply, or whether it merely represents itself.

It is also used by the ``proto::call<>`` transform to determine whether the function types `R()`, `R(A1)`, and `R(A1, A2)` should be passed the expression, state and data parameters (as needed).

Unless specialized for a type `T`, `proto::is_transform<T>::value` is computed as follows:

- If `T` is a class type that inherits directly or indirectly from an instantiation of ``proto::transform<>``, `proto::is_transform<T>::value` is `true`.

- Otherwise, `proto::is_transform<T>::value` is `false`.

mpl::bool_<true-or-false>
A Boolean metafunction that indicates whether a type requires aggregate initialization.

`proto::is_aggregate<>` is used by the ``proto::make<>`` transform to determine how to construct an object of some type `T`, given some initialization arguments `a0,...an`. If `proto::is_aggregate<T>::value` is `true`, then an object of type `T` will be initialized as `T t = {a0,...an};`. Otherwise, it will be initialized as `T t(a0,...an)`.

Note: ``proto::expr<>`` and ``proto::basic_expr<>``are aggregates.

mpl::bool_<true-or-false>
proto::default_domain
A callable PolymorphicFunctionObject that is equivalent to the `proto::as_expr()` function.
`proto::callable`
This(T)
`proto::result_of::as_expr`< typename remove_reference< T >::type, Domain >
typename `proto::result_of::as_expr`< T, Domain >::type `T &

The object to wrap.

`

Wrap an object in a Proto terminal if it isn't a Proto expression already.

`proto::as_expr<Domain>(t)`

typename `proto::result_of::as_expr`< T const, Domain >::type `T const &`

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

proto::default_domain
A callable PolymorphicFunctionObject that is equivalent to the `proto::as_child()` function.
`proto::callable`
This(T)
`proto::result_of::as_child`< typename remove_reference< T >::type, Domain >
typename `proto::result_of::as_child`< T, Domain >::type `T &

The object to wrap.

`

Wrap an object in a Proto terminal if it isn't a Proto expression already.

`proto::as_child<Domain>(t)`

typename `proto::result_of::as_child`< T const, Domain >::type `T const &`

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

long
A callable PolymorphicFunctionObject that is equivalent to the `proto::child_c()` function.
`proto::callable`
This(Expr)
`proto::result_of::child_c`< Expr, N >
typename `proto::result_of::child_c`< Expr &, N >::type `Expr &

The expression node.

`

Return the Nth child of the given expression.

``proto::is_expr`<Expr>::value` is `true`

`N < Expr::proto_arity::value`

`proto::child_c<N>(expr)`

Will not throw.

typename `proto::result_of::child_c`< Expr const &, N >::type `Expr const &`

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

mpl::long_<0>
A callable PolymorphicFunctionObject that is equivalent to the `proto::child()` function.

A callable PolymorphicFunctionObject that is equivalent to the `proto::child()` function. `N` is required to be an MPL Integral Constant.

`proto::callable`
This(Expr)
`proto::result_of::child`< Expr, N >
typename `proto::result_of::child`< Expr &, N >::type `Expr &

The expression node.

`

Return the Nth child of the given expression.

``proto::is_expr`<Expr>::value` is `true`

`N::value < Expr::proto_arity::value`

`proto::child<N>(expr)`

Will not throw.

typename `proto::result_of::child`< Expr const &, N >::type `Expr const &`

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

A callable PolymorphicFunctionObject that is equivalent to the `proto::value()` function.
`proto::callable`
This(Expr)
`proto::result_of::value`< Expr >
typename `proto::result_of::value`< Expr & >::type `Expr &

The terminal expression node.

`

Return the value of the given terminal expression.

``proto::is_expr`<Expr>::value` is `true`

`0 == Expr::proto_arity::value`

`proto::value(expr)`

Will not throw.

typename `proto::result_of::value`< Expr const & >::type `Expr const &`

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

A callable PolymorphicFunctionObject that is equivalent to the `proto::left()` function.
This(Expr)
`proto::result_of::left`< Expr >
`proto::callable`
typename `proto::result_of::left`< Expr & >::type `Expr &

The expression node.

`

Return the left child of the given binary expression.

``proto::is_expr`<Expr>::value` is `true`

`2 == Expr::proto_arity::value`

`proto::left(expr)`

Will not throw.

typename `proto::result_of::left`< Expr const & >::type `Expr const &`

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

A callable PolymorphicFunctionObject that is equivalent to the `proto::right()` function.
This(Expr)
`proto::result_of::right`< Expr >
`proto::callable`
typename `proto::result_of::right`< Expr & >::type `Expr &

The expression node.

`

Return the right child of the given binary expression.

``proto::is_expr`<Expr>::value` is `true`

`2 == Expr::proto_arity::value`

`proto::right(expr)`

Will not throw.

typename `proto::result_of::right`< Expr const & >::type `Expr const &`
proto::transform
< terminal<T> >
A metafunction for generating terminal expression types, a grammar element for matching terminal expressions, and a PrimitiveTransform that returns the current expression unchanged.
proto::transform_impl
< Expr, State, Data >
Expr
Expr `typename impl::expr_param

The current expression

` `typename impl::state_param` `typename impl::data_param`

``proto::matches`<Expr, proto::terminal<T> >::value` is `true`.

`expr`

Will not throw.

`proto::expr`< `proto::tag::terminal`, `proto::term`< T > >
`proto::basic_expr`< `proto::tag::terminal`, `proto::term`< T > >
proto::transform
< if_else_<T, U, V> >
A metafunction for generating ternary conditional expression types, a grammar element for matching ternary conditional expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<if_else_>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::if_else_`, `proto::list3`< T, U, V > >
`proto::basic_expr`< `proto::tag::if_else_`, `proto::list3`< T, U, V > >
proto::transform
< unary_plus<T> >
A metafunction for generating unary plus expression types, a grammar element for matching unary plus expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<unary_plus>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::unary_plus`, `proto::list1`< T > >
`proto::basic_expr`< `proto::tag::unary_plus`, `proto::list1`< T > >
proto::transform
< negate<T> >
A metafunction for generating unary minus expression types, a grammar element for matching unary minus expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<negate>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::negate`, `proto::list1`< T > >
`proto::basic_expr`< `proto::tag::negate`, `proto::list1`< T > >
proto::transform
< dereference<T> >
A metafunction for generating defereference expression types, a grammar element for matching dereference expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<dereference>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::dereference`, `proto::list1`< T > >
`proto::basic_expr`< `proto::tag::dereference`, `proto::list1`< T > >
proto::transform
< complement<T> >
A metafunction for generating complement expression types, a grammar element for matching complement expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<complement>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::complement`, `proto::list1`< T > >
`proto::basic_expr`< `proto::tag::complement`, `proto::list1`< T > >
proto::transform
< address_of<T> >
A metafunction for generating address_of expression types, a grammar element for matching address_of expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<address_of>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::address_of`, `proto::list1`< T > >
`proto::basic_expr`< `proto::tag::address_of`, `proto::list1`< T > >
proto::transform
< logical_not<T> >
A metafunction for generating logical_not expression types, a grammar element for matching logical_not expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<logical_not>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::logical_not`, `proto::list1`< T > >
`proto::basic_expr`< `proto::tag::logical_not`, `proto::list1`< T > >
proto::transform
< pre_inc<T> >
A metafunction for generating pre-increment expression types, a grammar element for matching pre-increment expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<pre_inc>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::pre_inc`, `proto::list1`< T > >
`proto::basic_expr`< `proto::tag::pre_inc`, `proto::list1`< T > >
proto::transform
< pre_dec<T> >
A metafunction for generating pre-decrement expression types, a grammar element for matching pre-decrement expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<pre_dec>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::pre_dec`, `proto::list1`< T > >
`proto::basic_expr`< `proto::tag::pre_dec`, `proto::list1`< T > >
proto::transform
< post_inc<T> >
A metafunction for generating post-increment expression types, a grammar element for matching post-increment expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<post_inc>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::post_inc`, `proto::list1`< T > >
`proto::basic_expr`< `proto::tag::post_inc`, `proto::list1`< T > >
proto::transform
< post_dec<T> >
A metafunction for generating post-decrement expression types, a grammar element for matching post-decrement expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<post_dec>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::post_dec`, `proto::list1`< T > >
`proto::basic_expr`< `proto::tag::post_dec`, `proto::list1`< T > >
proto::transform
< shift_left<T, U> >
A metafunction for generating left-shift expression types, a grammar element for matching left-shift expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<shift_left>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::shift_left`, `proto::list2`< T, U > >
`proto::basic_expr`< `proto::tag::shift_left`, `proto::list2`< T, U > >
proto::transform
< shift_right<T, U> >
A metafunction for generating right-shift expression types, a grammar element for matching right-shift expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<shift_right>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::shift_right`, `proto::list2`< T, U > >
`proto::basic_expr`< `proto::tag::shift_right`, `proto::list2`< T, U > >
proto::transform
< multiplies<T, U> >
A metafunction for generating multiplies expression types, a grammar element for matching multiplies expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<multiplies>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::multiplies`, `proto::list2`< T, U > >
`proto::basic_expr`< `proto::tag::multiplies`, `proto::list2`< T, U > >
proto::transform
< divides<T, U> >
A metafunction for generating divides expression types, a grammar element for matching divides expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<divides>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::divides`, `proto::list2`< T, U > >
`proto::basic_expr`< `proto::tag::divides`, `proto::list2`< T, U > >
proto::transform
< modulus<T, U> >
A metafunction for generating modulus expression types, a grammar element for matching modulus expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<modulus>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::modulus`, `proto::list2`< T, U > >
`proto::basic_expr`< `proto::tag::modulus`, `proto::list2`< T, U > >
proto::transform
< plus<T, U> >
A metafunction for generating binary plus expression types, a grammar element for matching binary plus expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<plus>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::plus`, `proto::list2`< T, U > >
`proto::basic_expr`< `proto::tag::plus`, `proto::list2`< T, U > >
proto::transform
< minus<T, U> >
A metafunction for generating binary minus expression types, a grammar element for matching binary minus expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<minus>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::minus`, `proto::list2`< T, U > >
`proto::basic_expr`< `proto::tag::minus`, `proto::list2`< T, U > >
proto::transform
< less<T, U> >
A metafunction for generating less expression types, a grammar element for matching less expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<less>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::less`, `proto::list2`< T, U > >
`proto::basic_expr`< `proto::tag::less`, `proto::list2`< T, U > >
proto::transform
< greater<T, U> >
A metafunction for generating greater expression types, a grammar element for matching greater expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<greater>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::greater`, `proto::list2`< T, U > >
`proto::basic_expr`< `proto::tag::greater`, `proto::list2`< T, U > >
proto::transform
< less_equal<T, U> >
A metafunction for generating less-or-equal expression types, a grammar element for matching less-or-equal expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<less_equal>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::less_equal`, `proto::list2`< T, U > >
`proto::basic_expr`< `proto::tag::less_equal`, `proto::list2`< T, U > >
proto::transform
< greater_equal<T, U> >
A metafunction for generating greater-or-equal expression types, a grammar element for matching greater-or-equal expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<greater_equal>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::greater_equal`, `proto::list2`< T, U > >
`proto::basic_expr`< `proto::tag::greater_equal`, `proto::list2`< T, U > >
proto::transform
< equal_to<T, U> >
A metafunction for generating equal-to expression types, a grammar element for matching equal-to expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<equal_to>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::equal_to`, `proto::list2`< T, U > >
`proto::basic_expr`< `proto::tag::equal_to`, `proto::list2`< T, U > >
proto::transform
< not_equal_to<T, U> >
A metafunction for generating not-equal-to expression types, a grammar element for matching not-equal-to expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<mot_equal_to>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::not_equal_to`, `proto::list2`< T, U > >
`proto::basic_expr`< `proto::tag::not_equal_to`, `proto::list2`< T, U > >
proto::transform
< logical_or<T, U> >
A metafunction for generating logical-or expression types, a grammar element for matching logical-or expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<logical_or>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::logical_or`, `proto::list2`< T, U > >
`proto::basic_expr`< `proto::tag::logical_or`, `proto::list2`< T, U > >
proto::transform
< logical_and<T, U> >
A metafunction for generating logical-and expression types, a grammar element for matching logical-and expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<logical_and>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::logical_and`, `proto::list2`< T, U > >
`proto::basic_expr`< `proto::tag::logical_and`, `proto::list2`< T, U > >
proto::transform
< bitwise_and<T, U> >
A metafunction for generating bitwise-and expression types, a grammar element for matching bitwise-and expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<bitwise_and>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::bitwise_and`, `proto::list2`< T, U > >
`proto::basic_expr`< `proto::tag::bitwise_and`, `proto::list2`< T, U > >
proto::transform
< bitwise_or<T, U> >
A metafunction for generating bitwise-or expression types, a grammar element for matching bitwise-or expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<bitwise_or>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::bitwise_or`, `proto::list2`< T, U > >
`proto::basic_expr`< `proto::tag::bitwise_or`, `proto::list2`< T, U > >
proto::transform
< bitwise_xor<T, U> >
A metafunction for generating bitwise-xor expression types, a grammar element for matching bitwise-xor expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<bitwise_xor>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::bitwise_xor`, `proto::list2`< T, U > >
`proto::basic_expr`< `proto::tag::bitwise_xor`, `proto::list2`< T, U > >
proto::transform
< comma<T, U> >
A metafunction for generating comma expression types, a grammar element for matching comma expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<comma>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::comma`, `proto::list2`< T, U > >
`proto::basic_expr`< `proto::tag::comma`, `proto::list2`< T, U > >
proto::transform
< mem_ptr<T, U> >
`proto::pass_through`<mem_ptr>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::mem_ptr`, `proto::list2`< T, U > >
`proto::basic_expr`< `proto::tag::mem_ptr`, `proto::list2`< T, U > >
proto::transform
< assign<T, U> >
A metafunction for generating assignment expression types, a grammar element for matching assignment expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<assign>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::assign`, `proto::list2`< T, U > >
`proto::basic_expr`< `proto::tag::assign`, `proto::list2`< T, U > >
proto::transform
< shift_left_assign<T, U> >
A metafunction for generating left-shift-assign expression types, a grammar element for matching left-shift-assign expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<shift_left_assign>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::shift_left_assign`, `proto::list2`< T, U > >
`proto::basic_expr`< `proto::tag::shift_left_assign`, `proto::list2`< T, U > >
proto::transform
< shift_right_assign<T, U> >
A metafunction for generating right-shift-assign expression types, a grammar element for matching right-shift-assign expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<shift_right_assign>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::shift_right_assign`, `proto::list2`< T, U > >
`proto::basic_expr`< `proto::tag::shift_right_assign`, `proto::list2`< T, U > >
proto::transform
< multiplies_assign<T, U> >
A metafunction for generating multiplies-assign expression types, a grammar element for matching multiplies-assign expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<multiplies_assign>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::multiplies_assign`, `proto::list2`< T, U > >
`proto::basic_expr`< `proto::tag::multiplies_assign`, `proto::list2`< T, U > >
proto::transform
< divides_assign<T, U> >
A metafunction for generating divides-assign expression types, a grammar element for matching divides-assign expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<divides_assign>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::divides_assign`, `proto::list2`< T, U > >
`proto::basic_expr`< `proto::tag::divides_assign`, `proto::list2`< T, U > >
proto::transform
< modulus_assign<T, U> >
A metafunction for generating modulus-assign expression types, a grammar element for matching modulus-assign expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<modulus_assign>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::modulus_assign`, `proto::list2`< T, U > >
`proto::basic_expr`< `proto::tag::modulus_assign`, `proto::list2`< T, U > >
proto::transform
< plus_assign<T, U> >
A metafunction for generating plus-assign expression types, a grammar element for matching plus-assign expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<plus_assign>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::plus_assign`, `proto::list2`< T, U > >
`proto::basic_expr`< `proto::tag::plus_assign`, `proto::list2`< T, U > >
proto::transform
< minus_assign<T, U> >
A metafunction for generating minus-assign expression types, a grammar element for matching minus-assign expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<minus_assign>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::minus_assign`, `proto::list2`< T, U > >
`proto::basic_expr`< `proto::tag::minus_assign`, `proto::list2`< T, U > >
proto::transform
< bitwise_and_assign<T, U> >
A metafunction for generating bitwise-and-assign expression types, a grammar element for matching bitwise-and-assign expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<bitwise_and_assign>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::bitwise_and_assign`, `proto::list2`< T, U > >
`proto::basic_expr`< `proto::tag::bitwise_and_assign`, `proto::list2`< T, U > >
proto::transform
< bitwise_or_assign<T, U> >
A metafunction for generating bitwise-or-assign expression types, a grammar element for matching bitwise-or-assign expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<bitwise_or_assign>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::bitwise_or_assign`, `proto::list2`< T, U > >
`proto::basic_expr`< `proto::tag::bitwise_or_assign`, `proto::list2`< T, U > >
proto::transform
< bitwise_xor_assign<T, U> >
A metafunction for generating bitwise-xor-assign expression types, a grammar element for matching bitwise-xor-assign expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<bitwise_xor_assign>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::bitwise_xor_assign`, `proto::list2`< T, U > >
`proto::basic_expr`< `proto::tag::bitwise_xor_assign`, `proto::list2`< T, U > >
proto::transform
< subscript<T, U> >
A metafunction for generating subscript expression types, a grammar element for matching subscript expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<subscript>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::subscript`, `proto::list2`< T, U > >
`proto::basic_expr`< `proto::tag::subscript`, `proto::list2`< T, U > >
proto::transform
< function<A...> >
A metafunction for generating function-call expression types, a grammar element for matching function-call expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.
`proto::pass_through`<function>::template impl<Expr, State, Data>
`proto::expr`< `proto::tag::function`, `proto::listN`< A... > >
`proto::basic_expr`< `proto::tag::function`, `proto::listN`< A... > >
proto::transform
< nullary_expr<Tag, T> >
A metafunction for generating nullary expression types, a grammar element for matching nullary expressions, and a PrimitiveTransform that returns the current expression unchanged.

Use `proto::nullary_expr<`proto::_`, `proto::_`>` as a grammar element to match any nullary expression.

proto::transform_impl
< Expr, State, Data >
Expr
Expr `typename impl::expr_param

The current expression

` `typename impl::state_param` `typename impl::data_param`

``proto::matches`<Expr, proto::nullary_expr<Tag, T> >::value` is `true`.

`expr`

Will not throw.

`proto::expr`< Tag, `proto::term`< T > >
`proto::basic_expr`< Tag, `proto::term`< T > >
proto::transform
< unary_expr<Tag, T> >
A metafunction for generating unary expression types with a specified tag type, a grammar element for matching unary expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.

Use `proto::unary_expr<`proto::_`, `proto::_`>` as a grammar element to match any unary expression.

`proto::pass_through`<unary_expr>::template impl<Expr, State, Data>
`proto::expr`< Tag, `proto::list1`< T > >
`proto::basic_expr`< Tag, `proto::list1`< T > >
proto::transform
< binary_expr<Tag, T, U> >
A metafunction for generating binary expression types with a specified tag type, a grammar element for matching binary expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.

Use `proto::binary_expr<`proto::_`, `proto::_`, `proto::_`>` as a grammar element to match any binary expression.

`proto::pass_through`<binary_expr>::template impl<Expr, State, Data>
`proto::expr`< Tag, `proto::list2`< T, U > >
`proto::basic_expr`< Tag, `proto::list2`< T, U > >
proto::transform
< nary_expr<Tag, A...> >
A metafunction for generating n-ary expression types with a specified tag type, a grammar element for matching n-ary expressions, and a PrimitiveTransform that dispatches to the ``proto::pass_through<>`` transform.

Use `proto::nary_expr<`proto::_`, `proto::vararg`<`proto::_`> >` as a grammar element to match any n-ary expression; that is, any non-terminal.

`proto::pass_through`<nary_expr>::template impl<Expr, State, Data>
`proto::expr`< Tag, `proto::listN`< A... > >
`proto::basic_expr`< Tag, `proto::listN`< A... > >
mpl::bool_<true-or-false>
A Boolean metafunction that indicates whether a given type `T` is a Proto expression type.

If `T` is an instantiation of ``proto::expr<>`` or ``proto::basic_expr<>`` or is an extension (via `proto::extends<>` or BOOST_PROTO_EXTENDS()) of such an instantiation, ``proto::is_expr`<T>::value` is `true`. Otherwise, ``proto::is_expr`<T>::value` is `false`.

A metafunction that returns the tag type of a Proto expression.
typename Expr::proto_tag
A metafunction that returns the arity of a Proto expression.
Expr::proto_arity
proto::default_domain
A metafunction that computes the return type of the `proto::as_expr()` function.

The `proto::result_of::as_expr<>` metafunction turns types into Proto expression types, if they are not already, in a domain-specific way. It is intended for use to compute the type of a local variable that can hold the result of the `proto::as_expr()` function.

See ``proto::domain::as_expr`<>` for a complete description of the default behavior.

typename Domain::template as_expr< T >::result_type
proto::default_domain
A metafunction that computes the return type of the `proto::as_child()` function.

The `proto::result_of::as_child<>` metafunction turns types into Proto expression types, if they are not already, in a domain-specific way. It is used by Proto to compute the type of an object to store as a child in another expression node.

See ``proto::domain::as_child`<>` for a complete description of the default behavior.

typename Domain::template as_child< T >::result_type
mpl::long_<0>
`proto::result_of::child_c`<Expr, N::value>
A metafunction that returns the type of the Nth child of a Proto expression, where N is an MPL Integral Constant.

`proto::result_of::child<Expr, N>` is equivalent to ``proto::result_of::child_c`<Expr, N::value>`.

A metafunction that returns the type of the value of a terminal Proto expression.

The raw type of the value as it is stored within `Expr`. This may be a value or a reference.

typename Expr::proto_child0

If `Expr` is not a reference type, `type` is computed as follows:

- `T const(&)[N]` becomes `T[N]`

- `T[N]` becomes `T[N]`

- `T(&)[N]` becomes `T[N]`

- `R(&)(A...)` becomes `R(&)(A...)`

- `T const &` becomes `T`

- `T &` becomes `T`

- `T` becomes `T`

If `Expr` is a non-const reference type, `type` is computed as follows:

- `T const(&)[N]` becomes `T const(&)[N]`

- `T[N]` becomes `T(&)[N]`

- `T(&)[N]` becomes `T(&)[N]`

- `R(&)(A...)` becomes `R(&)(A...)`

- `T const &` becomes `T const &`

- `T &` becomes `T &`

- `T` becomes `T &`

If `Expr` is a const reference type, `type` is computed as follows:

- `T const(&)[N]` becomes `T const(&)[N]`

- `T[N]` becomes `T const(&)[N]`

- `T(&)[N]` becomes `T(&)[N]`

- `R(&)(A...)` becomes `R(&)(A...)`

- `T const &` becomes `T const &`

- `T &` becomes `T &`

- `T` becomes `T const &`

see-below
proto::result_of::child_c< Expr, 0 >
A metafunction that returns the type of the left child of a binary Proto expression.

`proto::result_of::left<Expr>` is equivalent to ``proto::result_of::child_c`<Expr, 0>`.

proto::result_of::child_c< Expr, 1 >
A metafunction that returns the type of the right child of a binary Proto expression.

`proto::result_of::right<Expr>` is equivalent to ``proto::result_of::child_c`<Expr, 1>`.

long
A metafunction that returns the type of the Nth child of a Proto expression.

A metafunction that returns the type of the Nth child of a Proto expression. `N` must be 0 or less than `Expr::proto_arity::value`.

The raw type of the Nth child as it is stored within `Expr`. This may be a value or a reference.

typename Expr::proto_child0

If `Expr` is not a reference type, `type` is computed as follows:

- `T const &` becomes `T`

- `T &` becomes `T`

- `T` becomes `T`

If `Expr` is a non-const reference type, `type` is computed as follows:

- `T const &` becomes `T const &`

- `T &` becomes `T &`

- `T` becomes `T &`

If `Expr` is a const reference type, `type` is computed as follows:

- `T const &` becomes `T const &`

- `T &` becomes `T &`

- `T` becomes `T const &`

see-below
typename `proto::result_of::as_expr`< T >::type `T &`
typename `proto::result_of::as_expr`< T const >::type `T const &`
typename `proto::result_of::as_expr`< T, Domain >::type `T &`
typename `proto::result_of::as_expr`< T const, Domain >::type `T const &`
A function that wraps non-Proto expression types in Proto terminals and leaves Proto expression types alone.

The `proto::as_expr()` function returns Proto expression objects that are suitable for storage in a local variable. It turns non-Proto objects into Proto terminals. Its behavior is domain-specific. By default, non-Proto types are wrapped by value (if possible) in a new Proto terminal expression, and objects that are already Proto expressions are returned by value.

If `Domain` is not explicitly specified, it is assumed to be ``proto::default_domain``.

See ``proto::domain::as_expr`<>` for a complete description of this function's default behavior.

typename Domain::template as_expr< T >()(t)
typename `proto::result_of::as_child`< T >::type `T &`
typename `proto::result_of::as_child`< T const >::type `T const &`
typename `proto::result_of::as_child`< T, Domain >::type `T &`
typename `proto::result_of::as_child`< T const, Domain >::type `T const &`
A function that wraps non-Proto objects in Proto terminals (by reference) and leaves Proto expression types alone.

The `proto::as_child()` function returns Proto expression objects that are suitable for storage as child nodes in an expression tree. It turns non-Proto objects into Proto terminals. Its behavior is domain-specific. By default, non-Proto types are held wrapped by reference in a new Proto terminal expression, and objects that are already Proto expressions are simply returned by reference.

If `Domain` is not explicitly specified, it is assumed to be ``proto::default_domain``.

See ``proto::domain::as_child`<>` for a complete description of this function's default behavior.

typename Domain::template as_child< T >()(t)
typename `proto::result_of::child`< Expr &, N >::type `Expr &

The Proto expression.

`
typename `proto::result_of::child`< Expr const &, N >::type `Expr const &`
typename `proto::result_of::child`< Expr & >::type `Expr &`
typename `proto::result_of::child`< Expr const & >::type `Expr const &`
Return the Nth child of the specified Proto expression.

Return the Nth child of the specified Proto expression. If `N` is not specified, as in `proto::child(expr)`, then `N` is assumed to be `mpl::long_<0>`. The child is returned by reference.

``proto::is_expr`<Expr>::value` is `true`.

`N` is an MPL Integral Constant.

`N::value < Expr::proto_arity::value`

A reference to the Nth child of `expr`.

Will not throw.

typename `proto::result_of::child_c`< Expr &, N >::type long `Expr &`
typename `proto::result_of::child_c`< Expr const &, N >::type long `Expr const &`
Return the Nth child of the specified Proto expression.

Return the Nth child of the specified Proto expression. The child is returned by reference.

``proto::is_expr`<Expr>::value` is `true`.

`N < Expr::proto_arity::value`

A reference to the Nth child of `expr`.

Will not throw.

typename `proto::result_of::value`< Expr & >::type `Expr &`
typename `proto::result_of::value`< Expr const & >::type `Expr const &`
Return the value stored within the specified Proto terminal expression.

Return the the value stored within the specified Proto terminal expression. The value is returned by reference.

`0 == Expr::proto_arity::value`

A reference to the terminal's value

Will not throw.

typename `proto::result_of::left`< Expr & >::type `Expr &`
typename `proto::result_of::left`< Expr const & >::type `Expr const &`
Return the left child of the specified binary Proto expression.

Return the left child of the specified binary Proto expression. The child is returned by reference.

``proto::is_expr`<Expr>::value` is `true`.

`2 == Expr::proto_arity::value`

A reference to the left child of `expr`.

Will not throw.

typename `proto::result_of::right`< Expr & >::type `Expr &

The Proto expression.

`
typename `proto::result_of::right`< Expr const & >::type `Expr const &`
Return the right child of the specified binary Proto expression.

Return the right child of the specified binary Proto expression. The child is returned by reference.

``proto::is_expr`<Expr>::value` is `true`.

`2 == Expr::proto_arity::value`

A reference to the right child of `expr`.

Will not throw.