Contains definition of the childN transforms and friends.

proto::transform
< _expr >
A PrimitiveTransform that returns the current expression unmodified.

Example:

    proto::terminal<int>::type i = {42};
    proto::terminal<int>::type & j = proto::_expr()(i);
    assert( boost::addressof(i) == boost::addressof(j) );

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

The current expression.

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

Returns the current expression.

`expr`

Will not throw.

proto::transform
< _state >
A PrimitiveTransform that returns the current state unmodified.

Example:

    proto::terminal<int>::type i = {42};
    char ch = proto::_state()(i, 'a');
    assert( ch == 'a' );

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

The current state.

` `typename impl::data_param`

Returns the current state.

`state`

Will not throw.

proto::transform
< _data >
A PrimitiveTransform that returns the current data unmodified. If the data (third) parameter is a transform environment, it returns the value associated with the ``proto::data_type`` key. Otherwise, it returns the data parameter unmodified.

If the data (third) parameter is a transform environment, it returns the value associated with the ``proto::data_type`` key. Otherwise, it returns the data parameter unmodified.

Example:

    proto::terminal<int>::type i = {42};
    std::string str("hello");
    std::string & d1 = proto::_data()(i, 'a', str);
    assert( &str == &d1 );

    std::string & d2 = proto::_data()(i, 'a', (proto::data = boost::ref(str)));
    assert( &str == &d2 );

mpl::if_c< `proto::is_env`<Data>::value, `proto::_env_var`<`proto::data_type`>, `proto::_env` >::type::template impl<Expr, State, Data>
int
proto::transform
< _child_c<N> >
A PrimitiveTransform that returns N-th child of the current expression.

Example:

    proto::terminal<int>::type i = {42};
    proto::terminal<int>::type & j = proto::_child_c<0>()(-i);
    assert( boost::addressof(i) == boost::addressof(j) );

proto::transform_impl
< Expr, State, Data >
typename `proto::result_of::child_c`< Expr, N >::type
typename `proto::result_of::child_c`< Expr, N >::type `typename impl::expr_param

The current expression.

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

Returns the N-th child of `expr`

`Expr::proto_arity::value > N`

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

Will not throw.

proto::transform
< _value >
A PrimitiveTransform that returns the value of the current terminal expression.

Example:

    proto::terminal<int>::type i = {42};
    int j = proto::_value()(i);
    assert( 42 == j );

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

The current expression.

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

Returns the value of the specified terminal expression.

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

`proto::value(expr)`

Will not throw.

proto::transform
< _void >
A PrimitiveTransform that does nothing and returns void.
proto::transform_impl
< Expr, State, Data >
void
void `typename impl::expr_param` `typename impl::state_param` `typename impl::data_param`

Does nothing.

Will not throw.

proto::callable
A unary callable PolymorphicFunctionObject that wraps its argument in a `boost::reference_wrapper<>`.

Example:

    proto::terminal<int>::type i = {42};
    boost::reference_wrapper<proto::terminal<int>::type> j
      = proto::when<proto::_, proto::_byref(_)>()(i);
    assert( boost::addressof(i) == boost::addressof(j.get()) );

This(T &)
boost::reference_wrapper< T > const
This(T)
boost::reference_wrapper< T const > const
boost::reference_wrapper< T > const `T &

The object to wrap

`

Wrap the parameter `t` in a `boost::reference_wrapper<>`

`boost::ref(t)`

Will not throw.

boost::reference_wrapper< T const > const `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::callable
A unary callable PolymorphicFunctionObject that strips references and `boost::reference_wrapper<>` from its argument.

Example:

    proto::terminal<int>::type i = {42};
    int j = 67;
    int k = proto::when<proto::_, proto::_byval(proto::_state)>()(i, boost::ref(j));
    assert( 67 == k );

This(boost::reference_wrapper< T >)
result<This(T)>
This(T &)
result<This(T)>
This(T)
T
T `T const &

The object to unref

`

`t`

Will not throw.

T `boost::reference_wrapper< T > const &`

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