A BinaryFunction that accepts a Proto expression and a context, evaluates each child expression with the context, and combines the result using the standard C++ meaning for the operator represented by the current expression node.

Let ``OP`` be the C++ operator corresponding to `Expr::proto_tag`. (For example, if `Tag` is ``proto::tag::plus``, let ``OP`` be `+`.)

The behavior of this class is specified in terms of the C++0x `decltype` keyword. In systems where this keyword is not available, Proto uses the Boost.Typeof library to approximate the behavior.

For exposition only
typename Expr::tag_type
For exposition only
Expr &
For exposition only
Context &
see-below

- If `Tag` corresponds to a unary prefix operator, then the result type is

      decltype(
        OP proto::eval(proto::child(s_expr), s_context)
      )

- If `Tag` corresponds to a unary postfix operator, then the result type is

      decltype(
        proto::eval(proto::child(s_expr), s_context) OP
      )

- If `Tag` corresponds to a binary infix operator, then the result type is

      decltype(
        proto::eval(proto::left(s_expr), s_context) OP
        proto::eval(proto::right(s_expr), s_context)
      )

- If `Tag` is ``proto::tag::subscript`` , then the result type is

      decltype(
        proto::eval(proto::left(s_expr), s_context) [
        proto::eval(proto::right(s_expr), s_context) ]
      )

- If `Tag` is ``proto::tag::if_else_`` , then the result type is

      decltype(
        proto::eval(proto::child_c<0>(s_expr), s_context) ?
        proto::eval(proto::child_c<1>(s_expr), s_context) :
        proto::eval(proto::child_c<2>(s_expr), s_context)
      )

- If `Tag` is ``proto::tag::function`` , then the result type is

      decltype(
        proto::eval(proto::child_c<0>(s_expr), s_context) (
        proto::eval(proto::child_c<1>(s_expr), s_context),
        ...
        proto::eval(proto::child_c<N>(s_expr), s_context) )
      )

result_type `Expr &

The current expression

` `Context &

The evaluation context

`

- If `Tag` corresponds to a unary prefix operator, then return

      OP proto::eval(proto::child(expr), context)

- If `Tag` corresponds to a unary postfix operator, then return

      proto::eval(proto::child(expr), context) OP

- If `Tag` corresponds to a binary infix operator, then return

      proto::eval(proto::left(expr), context) OP
      proto::eval(proto::right(expr), context)

- If `Tag` is ``proto::tag::subscript`` , then return

      proto::eval(proto::left(expr), context) [
      proto::eval(proto::right(expr), context) ]

- If `Tag` is ``proto::tag::if_else_`` , then return

      proto::eval(proto::child_c<0>(expr), context) ?
      proto::eval(proto::child_c<1>(expr), context) :
      proto::eval(proto::child_c<2>(expr), context)

- If `Tag` is ``proto::tag::function`` , then return

      proto::eval(proto::child_c<0>(expr), context) (
      proto::eval(proto::child_c<1>(expr), context),
      ...
      proto::eval(proto::child_c<N>(expr), context) )

An evaluation context that gives the operators their normal C++ semantics.

An evaluation context that gives the operators their normal C++ semantics.

default_context const
proto::context::default_eval
< Expr, ThisContext >