Boost-Commit :

Date view	Thread view	Subject view	Author view

From: eric_at_[hidden]
Date: 2008-04-13 18:29:40

Next message: grafikrobot_at_[hidden]: "[Boost-commit] svn:boost r44379 - trunk/libs/crc/test"
Previous message: grafikrobot_at_[hidden]: "[Boost-commit] svn:boost r44377 - in trunk: libs/crc libs/crc/test status"

Author: eric_niebler
Date: 2008-04-13 18:29:39 EDT (Sun, 13 Apr 2008)
New Revision: 44378
URL: http://svn.boost.org/trac/boost/changeset/44378

Log:
latest doc tweaks
Text files modified:
   branches/proto/v4/libs/proto/doc/Jamfile.v2 | 5
   branches/proto/v4/libs/proto/doc/calculator.qbk | 2
   branches/proto/v4/libs/proto/doc/construction.qbk | 66
   branches/proto/v4/libs/proto/doc/installation.qbk | 12
   branches/proto/v4/libs/proto/doc/proto.qbk | 9
   branches/proto/v4/libs/proto/doc/protodoc.xml | 2331 +++++++++++++++++++--------------------
   6 files changed, 1194 insertions(+), 1231 deletions(-)

Modified: branches/proto/v4/libs/proto/doc/Jamfile.v2
==============================================================================
--- branches/proto/v4/libs/proto/doc/Jamfile.v2 (original)
+++ branches/proto/v4/libs/proto/doc/Jamfile.v2 2008-04-13 18:29:39 EDT (Sun, 13 Apr 2008)
@@ -13,6 +13,7 @@
     :
         ../../../boost/proto/args.hpp
         ../../../boost/proto/context.hpp
+ ../../../boost/proto/core.hpp
         ../../../boost/proto/debug.hpp
         ../../../boost/proto/deep_copy.hpp
         ../../../boost/proto/domain.hpp
@@ -28,7 +29,6 @@
         ../../../boost/proto/proto.hpp
         ../../../boost/proto/proto_fwd.hpp
# ../../../boost/proto/proto_typeof.hpp
- ../../../boost/proto/ref.hpp
         ../../../boost/proto/tags.hpp
         ../../../boost/proto/traits.hpp
         ../../../boost/proto/transform.hpp
@@ -37,6 +37,7 @@
         ../../../boost/proto/context/null.hpp
         ../../../boost/proto/transform/arg.hpp
         ../../../boost/proto/transform/call.hpp
+ ../../../boost/proto/transform/default.hpp
         ../../../boost/proto/transform/fold.hpp
         ../../../boost/proto/transform/fold_tree.hpp
         ../../../boost/proto/transform/lazy.hpp
@@ -105,5 +106,5 @@
         # better use SVG's instead:
         # <format>pdf:<xsl:param>admon.graphics.extension=".svg"

-# <dependency>protodoc
+ <dependency>protodoc
     ;

Modified: branches/proto/v4/libs/proto/doc/calculator.qbk
==============================================================================
--- branches/proto/v4/libs/proto/doc/calculator.qbk (original)
+++ branches/proto/v4/libs/proto/doc/calculator.qbk 2008-04-13 18:29:39 EDT (Sun, 13 Apr 2008)
@@ -16,7 +16,7 @@
expression, such as `(_2 - _1) / _2 * 100`, where `_1` and `_2` are
placeholders for values to be passed in when the expression is evaluated.

-[heading Defining Terminals]
+[heading Defining A Terminal]

The first order of business is to define the placeholders `_1` and `_2`. For
that, we'll use the _terminal_ metafunction.

Modified: branches/proto/v4/libs/proto/doc/construction.qbk
==============================================================================
--- branches/proto/v4/libs/proto/doc/construction.qbk (original)
+++ branches/proto/v4/libs/proto/doc/construction.qbk 2008-04-13 18:29:39 EDT (Sun, 13 Apr 2008)
@@ -41,7 +41,7 @@

The _expr_ struct is defined as follows:

- template< typename Tag, typename Args, long Arity = Args::size >
+ template< typename Tag, typename Args, long Arity = Args::arity >
     struct expr;

     template< typename Tag, typename Args >
@@ -93,21 +93,33 @@
The `_1` node is an _expr_ type, and new nodes created with this type are
also _expr_ types. They look like this:

- // typeof( -_1 )
- expr<
- tag::negate
- , list1<
- ref_< expr< tag::terminal, term< placeholder1 >, 0 > >
+ // decltype( -_1 )
+ proto::expr<
+ proto::tag::negate
+ , proto::list1<
+ proto::expr<
+ proto::tag::terminal
+ , proto::term< placeholder1 >
+ , 0
+ > const &
>
       , 1
>

- // typeof( _1 + 42 )
- expr<
- tag::plus
- , list2<
- ref_< expr< tag::terminal, term< placeholder1 >, 0 > >
- , expr< tag::terminal, term< int const & >, 0 >
+ // decltype( _1 + 42 )
+ proto::expr<
+ proto::tag::plus
+ , proto::list2<
+ proto::expr<
+ proto::tag::terminal
+ , proto::term< placeholder1 >
+ , 0
+ > const &
+ , proto::expr<
+ proto::tag::terminal
+ , proto::term< int const & >
+ , 0
+ >
>
       , 2
>
@@ -117,14 +129,13 @@
# Terminals have arity 0, unary expressions have arity 1 and binary expressions
   have arity 2.
# When one Proto expression is made a child node of another Proto expression,
- it is wrapped in _ref_, which is a simple reference wrapper. That is, Proto
- expressions hold their children by reference ['even if they are temporary
- objects]. This last point becomes important later.
+ it is held by reference, ['even if they are temporary objects]. This last
+ point becomes important later.
# Non-Proto expressions, such as the integer literal, are turned into Proto
   expressions by making them Proto terminals. These terminal expressions
- are /not/ wrapped in _ref_, but the object itself /is/ held by reference.
- Notice that the type of the Proto-ified `42` literal is `int const &` -- held
- by reference.
+ are thenselves held by reference, but the object itself /is/. Notice that
+ the type of the Proto-ified `42` literal is `int const &` -- held by
+ reference.

The types make it clear: everything in a Proto expression tree is held by
reference. That means that building an expression tree is exceptionally cheap.
@@ -170,7 +181,7 @@

Each node in an expression tree corresponds to an operator in an expression,
and the children correspond to the operands, or arguments of the operator.
-To access them, you can use the _arg_c_ function template, as demonstrated
+To access them, you can use the _child_c_ function template, as demonstrated
below:

     proto::terminal<int>::type i = {0};
@@ -214,19 +225,22 @@
references and cv-qualifiers, you can use
`fusion::result_of::value_at<Expr, N>::type`. This way, you can tell whether
a child is stored by value or by reference. And if you would like to know
-the exact type that _arg_c_ returns, you can use
+the exact type that _child_c_ returns, you can use
`fusion::result_of::at_c<Expr, N>::type`. It will always be a reference type,
and its cv-qualification depends on the cv-qualification of `Expr` and
whether the child is stored by reference or not.

-[heading [^child()], [^left()], and [^right()]]
+[heading [^value()], [^child()], [^left()], and [^right()]]

Most operators in C++ are unary or binary. For that reason, accessing the
only operand, or the left and right operands, are very common operations. For
-this reason, Proto provides the _arg_, _left_, and _right_ functions. _arg_
+this reason, Proto provides the _child_, _left_, and _right_ functions. _child_
and _left_ are synonomous with `child_c<0>()`, and _right_ is synonomous with
`child_c<1>()`.

+Another very common operation is accessing the value stored within a Proto
+terminal. You can use the _value_ function for that.
+
There are also `result_of::child<>`, `result_of::left<>`, and `result_of::right<>`
metafunctions that merely forward to their `result_of::child_c<>` counterparts.

@@ -250,7 +264,7 @@
     };

     struct fun_t {};
- terminal<fun_t>::type const fun = {{}};
+ proto::terminal<fun_t>::type const fun = {{}};

     // ...
     fusion::for_each(
@@ -258,7 +272,7 @@
             // pop_front() removes the "fun" child
             fusion::pop_front(fun(1,2,3,4))
             // Extract the ints from the terminal nodes
- , functional::child<>()
+ , proto::functional::value()
         )
       , display()
     );
@@ -278,13 +292,13 @@
over the arguments of a lazy function invocation, we would like to iterate
over the terminals in an addition expression:

- terminal<int>::type const _1 = {1};
+ proto::terminal<int>::type const _1 = {1};

     // ERROR: this doesn't work! Why?
     fusion::for_each(
         fusion::transform(
             _1 + 2 + 3 + 4
- , functional::child<>()
+ , proto::functional::value()
         )
       , display()
     );

Modified: branches/proto/v4/libs/proto/doc/installation.qbk
==============================================================================
--- branches/proto/v4/libs/proto/doc/installation.qbk (original)
+++ branches/proto/v4/libs/proto/doc/installation.qbk 2008-04-13 18:29:39 EDT (Sun, 13 Apr 2008)
@@ -19,16 +19,14 @@

Proto is a header-only template library, which means you don't need to alter
your build scripts or link to any separate lib file to use it. All you need
-to do is `#include <boost/proto/proto.hpp>`. This will include the
-core of Proto. If you want to use any transforms, you must include the
-appropriate header from the [^boost\/proto\/transform\/] directory.
-Likewise for any evaluation contexts, which live in the
-[^boost\/proto\/context\/] directory.
+to do is `#include <boost/proto/proto.hpp>`. Or, you might decide to just
+include the core of Proto (`#include <boost/proto/proto.hpp>`) and whichever
+contexts and transforms you happen to use.

[heading Requirements]

-Proto depends on Boost. You must use either Boost version 1.34.1 or the
-version in SVN trunk.
+Proto depends on Boost. You must use either Boost version 1.34.1 or higher,
+or the version in SVN trunk.

[heading Supported Compilers]

Modified: branches/proto/v4/libs/proto/doc/proto.qbk
==============================================================================
--- branches/proto/v4/libs/proto/doc/proto.qbk (original)
+++ branches/proto/v4/libs/proto/doc/proto.qbk 2008-04-13 18:29:39 EDT (Sun, 13 Apr 2008)
@@ -40,12 +40,10 @@
[def _spirit_ [@http://spirit.sourceforge.net Spirit]]
[def _xpressive_ [@../../../libs/doc/index.html Boost.Xpressive]]
[def _expr_ [classref boost::proto::expr<Tag,Args,1> `expr<>`]]
-[def _ref_ [classref boost::proto::ref_ `ref_<>`]]
-[def _unref_ [funcref boost::proto::unref `unref()`]]
[def _deep_copy_ [funcref boost::proto::deep_copy `deep_copy()`]]
[def _extends_ [classref boost::proto::extends `extends<>`]]
[def _as_expr_ [funcref boost::proto::as_expr `as_expr()`]]
-[def _as_arg_ [funcref boost::proto::as_child `as_child()`]]
+[def _as_child_ [funcref boost::proto::as_child `as_child()`]]
[def _make_expr_ [funcref boost::proto::make_expr `make_expr()`]]
[def _unpack_expr_ [funcref boost::proto::unpack_expr `unpack_expr()`]]
[def _matches_ [classref boost::proto::result_of::matches `matches<>`]]
@@ -57,11 +55,12 @@
[def _convertible_to_ [classref boost::proto::control::convertible_to `convertible_to<>`]]
[def _is_expr_ [classref boost::proto::result_of::is_expr `is_expr<>`]]
[def _tag_of_ [classref boost::proto::result_of::tag_of `tag_of<>`]]
-[def _arg_ [funcref boost::proto::child `child()`]]
-[def _arg_c_ [funcref boost::proto::child_c `child_c()`]]
+[def _child_ [funcref boost::proto::child `child()`]]
+[def _child_c_ [funcref boost::proto::child_c `child_c()`]]
[def _eval_ [funcref boost::proto::eval `eval()`]]
[def _left_ [funcref boost::proto::left `left()`]]
[def _right_ [funcref boost::proto::right `right()`]]
+[def _value_ [funcref boost::proto::value `value()`]]
[def _terminal_ [classref boost::proto::op::terminal `terminal<>`]]
[def _unary_expr_ [classref boost::proto::op::unary_expr `unary_expr<>`]]
[def _binary_expr_ [classref boost::proto::op::binary_expr `binary_expr<>`]]

Modified: branches/proto/v4/libs/proto/doc/protodoc.xml
==============================================================================
--- branches/proto/v4/libs/proto/doc/protodoc.xml (original)
+++ branches/proto/v4/libs/proto/doc/protodoc.xml 2008-04-13 18:29:39 EDT (Sun, 13 Apr 2008)
@@ -1,27 +1,29 @@
<?xml version="1.0" standalone="yes"?>
-<library-reference><header name="boost/proto/args.hpp"><para>Contains definition of args<> class template. </para><namespace name="boost"><namespace name="proto"><struct name="term"><template>
+<library-reference><header name="boost/proto/args.hpp"><para>Contains definition of args<> class template. </para><namespace name="boost"><namespace name="proto"><struct-specialization name="term_ref"><template>
+ <template-type-parameter name="T"/>
+ </template><specialization><template-arg>T const &</template-arg></specialization><typedef name="type"><type>T</type></typedef></struct-specialization><struct name="term"><template>
       <template-type-parameter name="Arg0"/>
- </template><purpose>A type sequence, for use as the 2nd parameter to the <computeroutput>expr<></computeroutput> class template. </purpose><description><para>A type sequence, for use as the 2nd parameter to the <computeroutput>expr<></computeroutput> class template. The types in the sequence correspond to the children of a node in an expression tree. </para></description><data-member name="arity" specifiers="static"><type>const long</type></data-member><typedef name="child0"><type>Arg0</type></typedef><typedef name="child1"><type>mpl::void_</type></typedef><typedef name="child2"><type>mpl::void_</type></typedef><typedef name="child3"><type>mpl::void_</type></typedef><typedef name="child4"><type>mpl::void_</type></typedef></struct><struct name="list1"><template>
+ </template><purpose>A type sequence, for use as the 2nd parameter to the <computeroutput>expr<></computeroutput> class template. </purpose><description><para>A type sequence, for use as the 2nd parameter to the <computeroutput>expr<></computeroutput> class template. The types in the sequence correspond to the children of a node in an expression tree. </para></description><data-member name="arity" specifiers="static"><type>const long</type></data-member><typedef name="child0"><type>Arg0</type></typedef><typedef name="child_ref0"><type><classname>term_ref</classname>< Arg0 ></type></typedef></struct><struct name="list1"><template>
       <template-type-parameter name="Arg0"/>
- </template><purpose>A type sequence, for use as the 2nd parameter to the <computeroutput>expr<></computeroutput> class template. </purpose><description><para>A type sequence, for use as the 2nd parameter to the <computeroutput>expr<></computeroutput> class template. The types in the sequence correspond to the children of a node in an expression tree. </para></description><data-member name="arity" specifiers="static"><type>const long</type></data-member><typedef name="child0"><type>Arg0</type></typedef><typedef name="child1"><type>mpl::void_</type></typedef><typedef name="child2"><type>mpl::void_</type></typedef><typedef name="child3"><type>mpl::void_</type></typedef><typedef name="child4"><type>mpl::void_</type></typedef></struct><struct name="list2"><template>
+ </template><purpose>A type sequence, for use as the 2nd parameter to the <computeroutput>expr<></computeroutput> class template. </purpose><description><para>A type sequence, for use as the 2nd parameter to the <computeroutput>expr<></computeroutput> class template. The types in the sequence correspond to the children of a node in an expression tree. </para></description><data-member name="arity" specifiers="static"><type>const long</type></data-member><typedef name="child0"><type>Arg0</type></typedef><typedef name="child_ref0"><type><classname>expr_ref</classname>< Arg0 ></type></typedef></struct><struct name="list2"><template>
       <template-type-parameter name="Arg0"/>
       <template-type-parameter name="Arg1"/>
- </template><purpose>A type sequence, for use as the 2nd parameter to the <computeroutput>expr<></computeroutput> class template. </purpose><description><para>A type sequence, for use as the 2nd parameter to the <computeroutput>expr<></computeroutput> class template. The types in the sequence correspond to the children of a node in an expression tree. </para></description><data-member name="arity" specifiers="static"><type>const long</type></data-member><typedef name="child0"><type>Arg0</type></typedef><typedef name="child1"><type>Arg1</type></typedef><typedef name="child2"><type>mpl::void_</type></typedef><typedef name="child3"><type>mpl::void_</type></typedef><typedef name="child4"><type>mpl::void_</type></typedef></struct><struct name="list3"><template>
+ </template><purpose>A type sequence, for use as the 2nd parameter to the <computeroutput>expr<></computeroutput> class template. </purpose><description><para>A type sequence, for use as the 2nd parameter to the <computeroutput>expr<></computeroutput> class template. The types in the sequence correspond to the children of a node in an expression tree. </para></description><data-member name="arity" specifiers="static"><type>const long</type></data-member><typedef name="child0"><type>Arg0</type></typedef><typedef name="child_ref0"><type><classname>expr_ref</classname>< Arg0 ></type></typedef><typedef name="child1"><type>Arg1</type></typedef><typedef name="child_ref1"><type><classname>expr_ref</classname>< Arg1 ></type></typedef></struct><struct name="list3"><template>
       <template-type-parameter name="Arg0"/>
       <template-type-parameter name="Arg1"/>
       <template-type-parameter name="Arg2"/>
- </template><purpose>A type sequence, for use as the 2nd parameter to the <computeroutput>expr<></computeroutput> class template. </purpose><description><para>A type sequence, for use as the 2nd parameter to the <computeroutput>expr<></computeroutput> class template. The types in the sequence correspond to the children of a node in an expression tree. </para></description><data-member name="arity" specifiers="static"><type>const long</type></data-member><typedef name="child0"><type>Arg0</type></typedef><typedef name="child1"><type>Arg1</type></typedef><typedef name="child2"><type>Arg2</type></typedef><typedef name="child3"><type>mpl::void_</type></typedef><typedef name="child4"><type>mpl::void_</type></typedef></struct><struct name="list4"><template>
+ </template><purpose>A type sequence, for use as the 2nd parameter to the <computeroutput>expr<></computeroutput> class template. </purpose><description><para>A type sequence, for use as the 2nd parameter to the <computeroutput>expr<></computeroutput> class template. The types in the sequence correspond to the children of a node in an expression tree. </para></description><data-member name="arity" specifiers="static"><type>const long</type></data-member><typedef name="child0"><type>Arg0</type></typedef><typedef name="child_ref0"><type><classname>expr_ref</classname>< Arg0 ></type></typedef><typedef name="child1"><type>Arg1</type></typedef><typedef name="child_ref1"><type><classname>expr_ref</classname>< Arg1 ></type></typedef><typedef name="child2"><type>Arg2</type></typedef><typedef name="child_ref2"><type><classname>expr_ref</classname>< Arg2 ></type></typedef></struct><struct name="list4"><template>
       <template-type-parameter name="Arg0"/>
       <template-type-parameter name="Arg1"/>
       <template-type-parameter name="Arg2"/>
       <template-type-parameter name="Arg3"/>
- </template><purpose>A type sequence, for use as the 2nd parameter to the <computeroutput>expr<></computeroutput> class template. </purpose><description><para>A type sequence, for use as the 2nd parameter to the <computeroutput>expr<></computeroutput> class template. The types in the sequence correspond to the children of a node in an expression tree. </para></description><data-member name="arity" specifiers="static"><type>const long</type></data-member><typedef name="child0"><type>Arg0</type></typedef><typedef name="child1"><type>Arg1</type></typedef><typedef name="child2"><type>Arg2</type></typedef><typedef name="child3"><type>Arg3</type></typedef><typedef name="child4"><type>mpl::void_</type></typedef></struct><struct name="list5"><template>
+ </template><purpose>A type sequence, for use as the 2nd parameter to the <computeroutput>expr<></computeroutput> class template. </purpose><description><para>A type sequence, for use as the 2nd parameter to the <computeroutput>expr<></computeroutput> class template. The types in the sequence correspond to the children of a node in an expression tree. </para></description><data-member name="arity" specifiers="static"><type>const long</type></data-member><typedef name="child0"><type>Arg0</type></typedef><typedef name="child_ref0"><type><classname>expr_ref</classname>< Arg0 ></type></typedef><typedef name="child1"><type>Arg1</type></typedef><typedef name="child_ref1"><type><classname>expr_ref</classname>< Arg1 ></type></typedef><typedef name="child2"><type>Arg2</type></typedef><typedef name="child_ref2"><type><classname>expr_ref</classname>< Arg2 ></type></typedef><typedef name="child3"><type>Arg3</type></typedef><typedef name="child_ref3"><type><classname>expr_ref</classname>
< Arg3 ></type></typedef></struct><struct name="list5"><template>
       <template-type-parameter name="Arg0"/>
       <template-type-parameter name="Arg1"/>
       <template-type-parameter name="Arg2"/>
       <template-type-parameter name="Arg3"/>
       <template-type-parameter name="Arg4"/>
- </template><purpose>A type sequence, for use as the 2nd parameter to the <computeroutput>expr<></computeroutput> class template. </purpose><description><para>A type sequence, for use as the 2nd parameter to the <computeroutput>expr<></computeroutput> class template. The types in the sequence correspond to the children of a node in an expression tree. </para></description><data-member name="arity" specifiers="static"><type>const long</type></data-member><typedef name="child0"><type>Arg0</type></typedef><typedef name="child1"><type>Arg1</type></typedef><typedef name="child2"><type>Arg2</type></typedef><typedef name="child3"><type>Arg3</type></typedef><typedef name="child4"><type>Arg4</type></typedef></struct></namespace></namespace></header><header name="boost/proto/context.hpp"><para>Includes all the context classes in the context/ sub-directory. </para></header><header name="boost/proto/context/callable.hpp"><para>Definintion of callable_context<>, an evaluation context for proto::eval
() that explodes each node and calls the derived context type with the expressions constituents. If the derived context doesn't have an overload that handles this node, fall back to some other context. </para><namespace name="boost"><namespace name="proto"><namespace name="context"><struct name="callable_eval"><template>
+ </template><purpose>A type sequence, for use as the 2nd parameter to the <computeroutput>expr<></computeroutput> class template. </purpose><description><para>A type sequence, for use as the 2nd parameter to the <computeroutput>expr<></computeroutput> class template. The types in the sequence correspond to the children of a node in an expression tree. </para></description><data-member name="arity" specifiers="static"><type>const long</type></data-member><typedef name="child0"><type>Arg0</type></typedef><typedef name="child_ref0"><type><classname>expr_ref</classname>< Arg0 ></type></typedef><typedef name="child1"><type>Arg1</type></typedef><typedef name="child_ref1"><type><classname>expr_ref</classname>< Arg1 ></type></typedef><typedef name="child2"><type>Arg2</type></typedef><typedef name="child_ref2"><type><classname>expr_ref</classname>< Arg2 ></type></typedef><typedef name="child3"><type>Arg3</type></typedef><typedef name="child_ref3"><type><classname>expr_ref</classname>
< Arg3 ></type></typedef><typedef name="child4"><type>Arg4</type></typedef><typedef name="child_ref4"><type><classname>expr_ref</classname>< Arg4 ></type></typedef></struct></namespace></namespace></header><header name="boost/proto/context.hpp"><para>Includes all the context classes in the context/ sub-directory. </para></header><header name="boost/proto/context/callable.hpp"><para>Definintion of callable_context<>, an evaluation context for proto::eval() that explodes each node and calls the derived context type with the expressions constituents. If the derived context doesn't have an overload that handles this node, fall back to some other context. </para><namespace name="boost"><namespace name="proto"><namespace name="context"><struct name="callable_eval"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="Context"/>
       <template-nontype-parameter name="Arity"><type>long</type><default>Expr::proto_arity::value</default></template-nontype-parameter>
@@ -68,39 +70,239 @@
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="Context"/>
     </template><specialization><template-arg>Expr</template-arg><template-arg>Context</template-arg><template-arg>0</template-arg></specialization><purpose>A BinaryFunction that accepts a Proto expression and a callable context and calls the context with the expression tag and children as arguments, effectively fanning the expression out. </purpose><description><para><computeroutput>callable_eval<></computeroutput> requires that <computeroutput>Context</computeroutput> is a PolymorphicFunctionObject that can be invoked with <computeroutput>Expr's</computeroutput> tag and children as expressions, as follows:</para><para><programlisting> context(Expr::proto_tag(), child_c\<0\>(expr), child_c\<1\>(expr), ...)
-</programlisting> </para></description><typedef name="child0"><type>proto::result_of::child_c< Expr, 0 >::const_reference</type></typedef><typedef name="result_type"><type>boost::result_of< Context(typename Expr::proto_tag, child0)>::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>Expr &</paramtype><description><para>The current expression </para></description></parameter><parameter name="context"><paramtype>Context &</paramtype><description><para>The callable evaluation context </para></description></parameter><description><para>
+</programlisting> </para></description><typedef name="child0"><type>proto::result_of::child_c< Expr const &, 0 >::type</type></typedef><typedef name="result_type"><type>boost::result_of< Context(typename Expr::proto_tag, child0)>::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>Expr &</paramtype><description><para>The current expression </para></description></parameter><parameter name="context"><paramtype>Context &</paramtype><description><para>The callable evaluation context </para></description></parameter><description><para>

</para></description><returns><para><computeroutput>context(Expr::proto_tag(), child_c<0>(expr), child_c<1>(expr), ...)</computeroutput> </para></returns></method></method-group></struct-specialization><struct-specialization name="callable_eval"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="Context"/>
     </template><specialization><template-arg>Expr</template-arg><template-arg>Context</template-arg><template-arg>1</template-arg></specialization><purpose>A BinaryFunction that accepts a Proto expression and a callable context and calls the context with the expression tag and children as arguments, effectively fanning the expression out. </purpose><description><para><computeroutput>callable_eval<></computeroutput> requires that <computeroutput>Context</computeroutput> is a PolymorphicFunctionObject that can be invoked with <computeroutput>Expr's</computeroutput> tag and children as expressions, as follows:</para><para><programlisting> context(Expr::proto_tag(), child_c\<0\>(expr), child_c\<1\>(expr), ...)
-</programlisting> </para></description><typedef name="child0"><type>proto::result_of::child_c< Expr, 0 >::const_reference</type></typedef><typedef name="result_type"><type>boost::result_of< Context(typename Expr::proto_tag, child0)>::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>Expr &</paramtype><description><para>The current expression </para></description></parameter><parameter name="context"><paramtype>Context &</paramtype><description><para>The callable evaluation context </para></description></parameter><description><para>
+</programlisting> </para></description><typedef name="child0"><type>proto::result_of::child_c< Expr const &, 0 >::type</type></typedef><typedef name="result_type"><type>boost::result_of< Context(typename Expr::proto_tag, child0)>::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>Expr &</paramtype><description><para>The current expression </para></description></parameter><parameter name="context"><paramtype>Context &</paramtype><description><para>The callable evaluation context </para></description></parameter><description><para>

</para></description><returns><para><computeroutput>context(Expr::proto_tag(), child_c<0>(expr), child_c<1>(expr), ...)</computeroutput> </para></returns></method></method-group></struct-specialization><struct-specialization name="callable_eval"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="Context"/>
     </template><specialization><template-arg>Expr</template-arg><template-arg>Context</template-arg><template-arg>2</template-arg></specialization><purpose>A BinaryFunction that accepts a Proto expression and a callable context and calls the context with the expression tag and children as arguments, effectively fanning the expression out. </purpose><description><para><computeroutput>callable_eval<></computeroutput> requires that <computeroutput>Context</computeroutput> is a PolymorphicFunctionObject that can be invoked with <computeroutput>Expr's</computeroutput> tag and children as expressions, as follows:</para><para><programlisting> context(Expr::proto_tag(), child_c\<0\>(expr), child_c\<1\>(expr), ...)
-</programlisting> </para></description><typedef name="child0"><type>proto::result_of::child_c< Expr, 0 >::const_reference</type></typedef><typedef name="child1"><type>proto::result_of::child_c< Expr, 1 >::const_reference</type></typedef><typedef name="result_type"><type>boost::result_of< Context(typename Expr::proto_tag, child0, child1)>::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>Expr &</paramtype><description><para>The current expression </para></description></parameter><parameter name="context"><paramtype>Context &</paramtype><description><para>The callable evaluation context </para></description></parameter><description><para>
+</programlisting> </para></description><typedef name="child0"><type>proto::result_of::child_c< Expr const &, 0 >::type</type></typedef><typedef name="child1"><type>proto::result_of::child_c< Expr const &, 1 >::type</type></typedef><typedef name="result_type"><type>boost::result_of< Context(typename Expr::proto_tag, child0, child1)>::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>Expr &</paramtype><description><para>The current expression </para></description></parameter><parameter name="context"><paramtype>Context &</paramtype><description><para>The callable evaluation context </para></description></parameter><description><para>

</para></description><returns><para><computeroutput>context(Expr::proto_tag(), child_c<0>(expr), child_c<1>(expr), ...)</computeroutput> </para></returns></method></method-group></struct-specialization><struct-specialization name="callable_eval"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="Context"/>
     </template><specialization><template-arg>Expr</template-arg><template-arg>Context</template-arg><template-arg>3</template-arg></specialization><purpose>A BinaryFunction that accepts a Proto expression and a callable context and calls the context with the expression tag and children as arguments, effectively fanning the expression out. </purpose><description><para><computeroutput>callable_eval<></computeroutput> requires that <computeroutput>Context</computeroutput> is a PolymorphicFunctionObject that can be invoked with <computeroutput>Expr's</computeroutput> tag and children as expressions, as follows:</para><para><programlisting> context(Expr::proto_tag(), child_c\<0\>(expr), child_c\<1\>(expr), ...)
-</programlisting> </para></description><typedef name="child0"><type>proto::result_of::child_c< Expr, 0 >::const_reference</type></typedef><typedef name="child1"><type>proto::result_of::child_c< Expr, 1 >::const_reference</type></typedef><typedef name="child2"><type>proto::result_of::child_c< Expr, 2 >::const_reference</type></typedef><typedef name="result_type"><type>boost::result_of< Context(typename Expr::proto_tag, child0, child1, child2)>::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>Expr &</paramtype><description><para>The current expression </para></description></parameter><parameter name="context"><paramtype>Context &</paramtype><description><para>The callable evaluation context </para></description></parameter><description><para>
+</programlisting> </para></description><typedef name="child0"><type>proto::result_of::child_c< Expr const &, 0 >::type</type></typedef><typedef name="child1"><type>proto::result_of::child_c< Expr const &, 1 >::type</type></typedef><typedef name="child2"><type>proto::result_of::child_c< Expr const &, 2 >::type</type></typedef><typedef name="result_type"><type>boost::result_of< Context(typename Expr::proto_tag, child0, child1, child2)>::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>Expr &</paramtype><description><para>The current expression </para></description></parameter><parameter name="context"><paramtype>Context &</paramtype><description><para>The callable evaluation context </para></description></parameter><description><para>

</para></description><returns><para><computeroutput>context(Expr::proto_tag(), child_c<0>(expr), child_c<1>(expr), ...)</computeroutput> </para></returns></method></method-group></struct-specialization><struct-specialization name="callable_eval"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="Context"/>
     </template><specialization><template-arg>Expr</template-arg><template-arg>Context</template-arg><template-arg>4</template-arg></specialization><purpose>A BinaryFunction that accepts a Proto expression and a callable context and calls the context with the expression tag and children as arguments, effectively fanning the expression out. </purpose><description><para><computeroutput>callable_eval<></computeroutput> requires that <computeroutput>Context</computeroutput> is a PolymorphicFunctionObject that can be invoked with <computeroutput>Expr's</computeroutput> tag and children as expressions, as follows:</para><para><programlisting> context(Expr::proto_tag(), child_c\<0\>(expr), child_c\<1\>(expr), ...)
-</programlisting> </para></description><typedef name="child0"><type>proto::result_of::child_c< Expr, 0 >::const_reference</type></typedef><typedef name="child1"><type>proto::result_of::child_c< Expr, 1 >::const_reference</type></typedef><typedef name="child2"><type>proto::result_of::child_c< Expr, 2 >::const_reference</type></typedef><typedef name="child3"><type>proto::result_of::child_c< Expr, 3 >::const_reference</type></typedef><typedef name="result_type"><type>boost::result_of< Context(typename Expr::proto_tag, child0, child1, child2, child3)>::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>Expr &</paramtype><description><para>The current expression </para></description></parameter><parameter name="context"><paramtype>Context &</paramtype><description><para>The callable evaluation context </para></description></parameter><description><para>
+</programlisting> </para></description><typedef name="child0"><type>proto::result_of::child_c< Expr const &, 0 >::type</type></typedef><typedef name="child1"><type>proto::result_of::child_c< Expr const &, 1 >::type</type></typedef><typedef name="child2"><type>proto::result_of::child_c< Expr const &, 2 >::type</type></typedef><typedef name="child3"><type>proto::result_of::child_c< Expr const &, 3 >::type</type></typedef><typedef name="result_type"><type>boost::result_of< Context(typename Expr::proto_tag, child0, child1, child2, child3)>::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>Expr &</paramtype><description><para>The current expression </para></description></parameter><parameter name="context"><paramtype>Context &</paramtype><description><para>The callable evaluation context </para></description></parameter><description><para>

</para></description><returns><para><computeroutput>context(Expr::proto_tag(), child_c<0>(expr), child_c<1>(expr), ...)</computeroutput> </para></returns></method></method-group></struct-specialization><struct-specialization name="callable_eval"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="Context"/>
     </template><specialization><template-arg>Expr</template-arg><template-arg>Context</template-arg><template-arg>5</template-arg></specialization><purpose>A BinaryFunction that accepts a Proto expression and a callable context and calls the context with the expression tag and children as arguments, effectively fanning the expression out. </purpose><description><para><computeroutput>callable_eval<></computeroutput> requires that <computeroutput>Context</computeroutput> is a PolymorphicFunctionObject that can be invoked with <computeroutput>Expr's</computeroutput> tag and children as expressions, as follows:</para><para><programlisting> context(Expr::proto_tag(), child_c\<0\>(expr), child_c\<1\>(expr), ...)
-</programlisting> </para></description><typedef name="child0"><type>proto::result_of::child_c< Expr, 0 >::const_reference</type></typedef><typedef name="child1"><type>proto::result_of::child_c< Expr, 1 >::const_reference</type></typedef><typedef name="child2"><type>proto::result_of::child_c< Expr, 2 >::const_reference</type></typedef><typedef name="child3"><type>proto::result_of::child_c< Expr, 3 >::const_reference</type></typedef><typedef name="child4"><type>proto::result_of::child_c< Expr, 4 >::const_reference</type></typedef><typedef name="result_type"><type>boost::result_of< Context(typename Expr::proto_tag, child0, child1, child2, child3, child4)>::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>Expr &</paramtype><description><para>The current expression </para></description></parameter><parameter name="context"><paramtype>Context &</paramtype><des
cription><para>The callable evaluation context </para></description></parameter><description><para>
+</programlisting> </para></description><typedef name="child0"><type>proto::result_of::child_c< Expr const &, 0 >::type</type></typedef><typedef name="child1"><type>proto::result_of::child_c< Expr const &, 1 >::type</type></typedef><typedef name="child2"><type>proto::result_of::child_c< Expr const &, 2 >::type</type></typedef><typedef name="child3"><type>proto::result_of::child_c< Expr const &, 3 >::type</type></typedef><typedef name="child4"><type>proto::result_of::child_c< Expr const &, 4 >::type</type></typedef><typedef name="result_type"><type>boost::result_of< Context(typename Expr::proto_tag, child0, child1, child2, child3, child4)>::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>Expr &</paramtype><description><para>The current expression </para></description></parameter><parameter name="context"><paramtype>Context &</paramtype
><description><para>The callable evaluation context </para></description></parameter><description><para>

-</para></description><returns><para><computeroutput>context(Expr::proto_tag(), child_c<0>(expr), child_c<1>(expr), ...)</computeroutput> </para></returns></method></method-group></struct-specialization></namespace></namespace></namespace></header><header name="boost/proto/context/default.hpp"><para>Definintion of default_context, a default evaluation context for proto::eval() that uses Boost.Typeof to deduce return types of the built-in operators. </para><namespace name="boost"><namespace name="proto"><namespace name="context"><struct name="default_eval"><template>
+</para></description><returns><para><computeroutput>context(Expr::proto_tag(), child_c<0>(expr), child_c<1>(expr), ...)</computeroutput> </para></returns></method></method-group></struct-specialization></namespace></namespace></namespace></header><header name="boost/proto/context/default.hpp"><namespace name="boost"><namespace name="proto"><struct name="_default"><template>
+ <template-type-parameter name="Grammar"/>
+ </template><inherit access="public">transform< boost::proto::_default< Grammar > ></inherit><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::address_of</template-arg><template-arg>1</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::assign</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::bitwise_and</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::bitwise_and_assign</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::bitwise_or</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::bitwise_or_assign</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::bitwise_xor</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::bitwise_xor_assign</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::complement</template-arg><template-arg>1</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::dereference</template-arg><template-arg>1</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::divides</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::divides_assign</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::equal_to</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::function</template-arg><template-arg>1</template-arg></specialization><typedef name="e0"><type>result_of::child_c< Expr, 0 >::type</type></typedef><typedef name="r0"><type>Grammar::template <classname>impl</classname>< e0, State, Data >::result_type</type></typedef><typedef name="function_type"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="result_type"><type>boost::result_of< function_type()>::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><str
uct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::function</template-arg><template-arg>2</template-arg></specialization><typedef name="e0"><type>result_of::child_c< Expr, 0 >::type</type></typedef><typedef name="r0"><type>Grammar::template <classname>impl</classname>< e0, State, Data >::result_type</type></typedef><typedef name="e1"><type>result_of::child_c< Expr, 1 >::type</type></typedef><typedef name="r1"><type>Grammar::template <classname>impl</classname>< e1, State, Data >::result_type</type></typedef><typedef name="function_type"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="result_type"><type>boost::result_of< function_type(e1)>::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter n
ame="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::function</template-arg><template-arg>3</template-arg></specialization><typedef name="e0"><type>result_of::child_c< Expr, 0 >::type</type></typedef><typedef name="r0"><type>Grammar::template <classname>impl</classname>< e0, State, Data >::result_type</type></typedef><typedef name="e1"><type>result_of::child_c< Expr, 1 >::type</type></typedef><typedef name="r1"><type>Grammar::template <classname>impl</classname>< e1, State, Data >::result_type</type></typedef><typedef name="e2"><type>result_of::child_c< Expr, 2 >::type</type></typedef><typedef name="r2"><type>Grammar::template <classname>impl</classname>< e2, State, Data >::result_type</type></typedef><typedef name="function_type"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="result_type"><type>boost::result_of< function_type(e1, e2)>::type</type>
</typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::function</template-arg><template-arg>4</template-arg></specialization><typedef name="e0"><type>result_of::child_c< Expr, 0 >::type</type></typedef><typedef name="r0"><type>Grammar::template <classname>impl</classname>< e0, State, Data >::result_type</type></typedef><typedef name="e1"><type>result_of::child_c< Expr, 1 >::type</type></typedef><typedef name="r1"><type>Grammar::template <classname>impl</classname>< e1, State, Data >::result_type</type></typedef><typedef name="e2"><type>result_of::child_c< Expr, 2 >::type</type></typedef><typedef name="r2"><type>Grammar::template <classname>impl</classname>< e2, State, Data >::result_type</type></typedef><typedef name="e3"><type>result_of::child_c< Expr, 3 >::type</type></typedef><typedef name="r3"><type>Grammar::template <classname>impl</classname>< e3, State, Data >
::result_type</type></typedef><typedef name="function_type"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="result_type"><type>boost::result_of< function_type(e1, e2, e3)>::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::function</template-arg><template-arg>5</template-arg></specialization><typedef name="e0"><type>result_of::child_c< Expr, 0 >::type</type></typedef><typedef name="r0"><type>Grammar::template <classname>impl</classname>< e0, State, Data >::result_type</type></typedef><typedef name="e1"><type>result_of::child_c< Expr, 1 >::type</type></typedef><typedef name="r1"><type>Grammar::template <classname>impl</classname>< e1, State, Data >::result_type</type></typedef><typedef name="e2"><type>result_of::child_c< Expr, 2 >::type</type></typedef><typedef name="r2"><type>Grammar::template <classname>impl</classname>< e2, State, Data >::result_type</type></typedef><typedef name="e3"><type>result_of::child_c< Expr, 3 >::type</type></typedef><typedef name="r3"><type>Grammar::template <classname>impl</classname>< e3, State, Data >
::result_type</type></typedef><typedef name="e4"><type>result_of::child_c< Expr, 4 >::type</type></typedef><typedef name="r4"><type>Grammar::template <classname>impl</classname>< e4, State, Data >::result_type</type></typedef><typedef name="function_type"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="result_type"><type>boost::result_of< function_type(e1, e2, e3, e4)>::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::greater</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::greater_equal</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::if_else_</template-arg><template-arg>3</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::less</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::less_equal</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::logical_and</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::logical_not</template-arg><template-arg>1</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::logical_or</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::mem_ptr</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::minus</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::minus_assign</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::modulus</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::modulus_assign</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::multiplies</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::multiplies_assign</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::negate</template-arg><template-arg>1</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::not_equal_to</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::plus</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::plus_assign</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::post_dec</template-arg><template-arg>1</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::post_inc</template-arg><template-arg>1</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::pre_dec</template-arg><template-arg>1</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::pre_inc</template-arg><template-arg>1</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::shift_left</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::shift_left_assign</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::shift_right</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::shift_right_assign</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::subscript</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::terminal</template-arg><template-arg>0</template-arg></specialization><inherit access="public">boost::proto::_child_c< I >::impl< Expr, State, Data ></inherit></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::unary_plus</template-arg><template-arg>1</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization></struct><struct-specialization name="is_callable"><template>
+ <template-type-parameter name="Grammar"/>
+ </template><specialization><template-arg>_default< Grammar ></template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><namespace name="context"><struct name="default_eval"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="Context"/>
       <template-type-parameter name="Tag"><default>typename Expr::proto_tag</default></template-type-parameter>
@@ -222,7 +424,7 @@
     </template><specialization><template-arg>Expr</template-arg><template-arg>Context</template-arg><template-arg>proto::tag::bitwise_xor_assign</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>Expr &</paramtype></parameter><parameter name="ctx"><paramtype>Context &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="default_eval"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="Context"/>
- </template><specialization><template-arg>Expr</template-arg><template-arg>Context</template-arg><template-arg>proto::tag::terminal</template-arg><template-arg>0</template-arg></specialization><typedef name="result_type"><type>mpl::if_< is_const< Expr >, typename <classname>proto::result_of::value</classname>< Expr >::const_reference, typename <classname>proto::result_of::value</classname>< Expr >::reference >::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>Expr &</paramtype></parameter><parameter name=""><paramtype>Context &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="default_eval"><template>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>Context</template-arg><template-arg>proto::tag::terminal</template-arg><template-arg>0</template-arg></specialization><typedef name="result_type"><type><classname>proto::result_of::value</classname>< Expr & >::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>Expr &</paramtype></parameter><parameter name=""><paramtype>Context &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="default_eval"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="Context"/>
     </template><specialization><template-arg>Expr</template-arg><template-arg>Context</template-arg><template-arg>proto::tag::post_inc</template-arg><template-arg>1</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>Expr &</paramtype></parameter><parameter name="ctx"><paramtype>Context &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="default_eval"><template>
@@ -240,9 +442,6 @@
     </template><specialization><template-arg>Expr</template-arg><template-arg>Context</template-arg><template-arg>proto::tag::comma</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>Expr &</paramtype></parameter><parameter name="ctx"><paramtype>Context &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="default_eval"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="Context"/>
- </template><specialization><template-arg>Expr</template-arg><template-arg>Context</template-arg><template-arg>proto::tag::function</template-arg><template-arg>0</template-arg></specialization><typedef name="function_type"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="result_type"><type>boost::result_of< function_type()>::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>Expr &</paramtype></parameter><parameter name="context"><paramtype>Context &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="default_eval"><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="Context"/>
     </template><specialization><template-arg>Expr</template-arg><template-arg>Context</template-arg><template-arg>proto::tag::function</template-arg><template-arg>1</template-arg></specialization><typedef name="function_type"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="result_type"><type>boost::result_of< function_type()>::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>Expr &</paramtype></parameter><parameter name="context"><paramtype>Context &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="default_eval"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="Context"/>
@@ -258,106 +457,306 @@
     </template><specialization><template-arg>Expr</template-arg><template-arg>Context</template-arg><template-arg>proto::tag::function</template-arg><template-arg>5</template-arg></specialization><typedef name="function_type"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="result_type"><type>boost::result_of< function_type(typename <classname>proto::result_of::eval</classname>< typename remove_reference< typename proto::result_of::child_c< Expr, 1 >::type >::type, Context >::type, typename <classname>proto::result_of::eval</classname>< typename remove_reference< typename proto::result_of::child_c< Expr, 2 >::type >::type, Context >::type, typename <classname>proto::result_of::eval</classname>< typename remove_reference< typename proto::result_of::child_c< Expr, 3 >::type >::type, Context >::type, typename <classname>proto::result_of::eval</classname>< typename remove_reference< typename proto::result_of::child_c< Expr, 4
>::type >::type, Context >::type)>::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>Expr &</paramtype></parameter><parameter name="context"><paramtype>Context &</paramtype></parameter></method></method-group></struct-specialization><struct name="default_context"><description><para>default_context </para></description><struct name="eval"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="ThisContext"><default>default_context const</default></template-type-parameter>
- </template><inherit access="public">boost::proto::context::default_eval< Expr, ThisContext ></inherit><description><para>default_context::eval </para></description></struct></struct></namespace></namespace></namespace></header><header name="boost/proto/context/null.hpp"><para>Definintion of null_context<>, an evaluation context for proto::eval() that simply evaluates each child expression, doesn't combine the results at all, and returns void. </para><namespace name="boost"><namespace name="proto"><namespace name="context"><struct name="null_eval"><template>
+ </template><inherit access="public">boost::proto::context::default_eval< Expr, ThisContext ></inherit><description><para>default_context::eval </para></description></struct></struct></namespace></namespace></namespace></header><header name="boost/proto/transform/default.hpp"><namespace name="boost"><namespace name="proto"><struct name="_default"><template>
+ <template-type-parameter name="Grammar"/>
+ </template><inherit access="public">transform< boost::proto::_default< Grammar > ></inherit><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
- <template-type-parameter name="Context"/>
- <template-nontype-parameter name="Arity"><type>long</type><default>Expr::proto_arity::value</default></template-nontype-parameter>
- </template></struct><struct-specialization name="null_eval"><template>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><struct-specialization name="impl2"><template>
       <template-type-parameter name="Expr"/>
- <template-type-parameter name="Context"/>
- </template><specialization><template-arg>Expr</template-arg><template-arg>Context</template-arg><template-arg>0</template-arg></specialization><typedef name="result_type"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>void</type><parameter name=""><paramtype>Expr &</paramtype></parameter><parameter name=""><paramtype>Context &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="null_eval"><template>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::address_of</template-arg><template-arg>1</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
       <template-type-parameter name="Expr"/>
- <template-type-parameter name="Context"/>
- </template><specialization><template-arg>Expr</template-arg><template-arg>Context</template-arg><template-arg>1</template-arg></specialization><typedef name="result_type"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>void</type><parameter name="expr"><paramtype>Expr &</paramtype></parameter><parameter name="ctx"><paramtype>Context &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="null_eval"><template>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::assign</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
       <template-type-parameter name="Expr"/>
- <template-type-parameter name="Context"/>
- </template><specialization><template-arg>Expr</template-arg><template-arg>Context</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>void</type><parameter name="expr"><paramtype>Expr &</paramtype></parameter><parameter name="ctx"><paramtype>Context &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="null_eval"><template>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::bitwise_and</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
       <template-type-parameter name="Expr"/>
- <template-type-parameter name="Context"/>
- </template><specialization><template-arg>Expr</template-arg><template-arg>Context</template-arg><template-arg>3</template-arg></specialization><typedef name="result_type"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>void</type><parameter name="expr"><paramtype>Expr &</paramtype></parameter><parameter name="ctx"><paramtype>Context &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="null_eval"><template>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::bitwise_and_assign</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
       <template-type-parameter name="Expr"/>
- <template-type-parameter name="Context"/>
- </template><specialization><template-arg>Expr</template-arg><template-arg>Context</template-arg><template-arg>4</template-arg></specialization><typedef name="result_type"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>void</type><parameter name="expr"><paramtype>Expr &</paramtype></parameter><parameter name="ctx"><paramtype>Context &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="null_eval"><template>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::bitwise_or</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
       <template-type-parameter name="Expr"/>
- <template-type-parameter name="Context"/>
- </template><specialization><template-arg>Expr</template-arg><template-arg>Context</template-arg><template-arg>5</template-arg></specialization><typedef name="result_type"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>void</type><parameter name="expr"><paramtype>Expr &</paramtype></parameter><parameter name="ctx"><paramtype>Context &</paramtype></parameter></method></method-group></struct-specialization><struct name="null_context"><description><para>null_context </para></description><struct name="eval"><template>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::bitwise_or_assign</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
       <template-type-parameter name="Expr"/>
- <template-type-parameter name="ThisContext"><default>null_context const</default></template-type-parameter>
- </template><inherit access="public">boost::proto::context::null_eval< Expr, ThisContext ></inherit><description><para>null_context::eval </para></description></struct></struct></namespace></namespace></namespace></header><header name="boost/proto/debug.hpp"><para>Utilities for debugging Proto expression trees </para><namespace name="boost"><namespace name="proto"><namespace name="functor"><struct name="display_expr"><purpose>Pretty-print a Proto expression tree. </purpose><description><para>A PolymorphicFunctionObject which accepts a Proto expression tree and pretty-prints it to an <computeroutput>ostream</computeroutput> for debugging purposes. </para></description><typedef name="result_type"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>void</type><template>
- <template-type-parameter name="Args"/>
- </template><parameter name="expr"><paramtype>proto::expr< <classname>tag::terminal</classname>, Args, 0 > const &</paramtype></parameter><purpose>Pretty-print the current node in a Proto expression tree. </purpose></method><method name="operator()" cv="const"><type>void</type><template>
- <template-type-parameter name="Tag"/>
- <template-type-parameter name="Args"/>
- </template><parameter name="expr"><paramtype>proto::expr< Tag, Args, 1 > const &</paramtype></parameter></method><method name="operator()" cv="const"><type>void</type><template>
- <template-type-parameter name="Tag"/>
- <template-type-parameter name="Args"/>
- </template><parameter name="expr"><paramtype>proto::expr< Tag, Args, 2 > const &</paramtype></parameter></method><method name="operator()" cv="const"><type>void</type><template>
- <template-type-parameter name="Tag"/>
- <template-type-parameter name="Args"/>
- </template><parameter name="expr"><paramtype>proto::expr< Tag, Args, 3 > const &</paramtype></parameter></method><method name="operator()" cv="const"><type>void</type><template>
- <template-type-parameter name="Tag"/>
- <template-type-parameter name="Args"/>
- </template><parameter name="expr"><paramtype>proto::expr< Tag, Args, 4 > const &</paramtype></parameter></method><method name="operator()" cv="const"><type>void</type><template>
- <template-type-parameter name="Tag"/>
- <template-type-parameter name="Args"/>
- </template><parameter name="expr"><paramtype>proto::expr< Tag, Args, 5 > const &</paramtype></parameter></method><method name="operator()" cv="const"><type>void</type><template>
- <template-type-parameter name="T"/>
- </template><parameter name="t"><paramtype>T const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method></method-group><constructor><parameter name="sout"><paramtype>std::ostream &</paramtype><default>std::cout</default><description><para>The <computeroutput>ostream</computeroutput> to which the expression tree will be written. </para></description></parameter><parameter name="depth"><paramtype>int</paramtype><default>0</default><description><para>The starting indentation depth for this node. Children nodes will be displayed at a starting depth of <computeroutput>depth+4</computeroutput>. </para></description></parameter><description><para>
-</para></description></constructor><method-group name="private member functions"/><copy-assignment><parameter name=""><paramtype><classname>display_expr</classname> const &</paramtype></parameter></copy-assignment></struct></namespace><namespace name="tag"><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::unary_plus</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::negate</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::dereference</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::complement</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::address_of</classname
></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::logical_not</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::pre_inc</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::pre_dec</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::post_inc</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::post_dec</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::shift_left</classname></paramtype></parameter></function><function name="proto_tag_name"><typ
e>char const *</type><parameter name=""><paramtype><classname>tag::shift_right</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::multiplies</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::divides</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::modulus</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::plus</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::minus</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::less</classn
ame></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::greater</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::less_equal</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::greater_equal</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::equal_to</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::not_equal_to</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::logical_or</classname></paramtype></parameter></function><function name="proto_ta
g_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::logical_and</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::bitwise_and</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::bitwise_or</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::bitwise_xor</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::comma</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::mem_ptr</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><clas
sname>tag::assign</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::shift_left_assign</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::shift_right_assign</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::multiplies_assign</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::divides_assign</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::modulus_assign</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::plus_assign</classname></p
aramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::minus_assign</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::bitwise_and_assign</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::bitwise_or_assign</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::bitwise_xor_assign</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::subscript</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::if_else_</classname></paramtype></parameter></function><function
name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::function</classname></paramtype></parameter></function></namespace><overloaded-function name="display_expr"><signature><type>void</type><template>
- <template-type-parameter name="Expr"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The Proto expression tree to pretty-print </para></description></parameter><parameter name="sout"><paramtype>std::ostream &</paramtype><description><para>The <computeroutput>ostream</computeroutput> to which the output should be written. If not specified, defaults to <computeroutput>std::cout</computeroutput>. </para></description></parameter></signature><signature><type>void</type><template>
- <template-type-parameter name="Expr"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></signature><purpose>Pretty-print a Proto expression tree. </purpose><description><para>
-
-</para></description><notes><para>Equivalent to <computeroutput>functor::display_expr(0, sout)(expr)</computeroutput> </para></notes></overloaded-function></namespace></namespace></header><header name="boost/proto/deep_copy.hpp"><para>Replace all nodes stored by reference by nodes stored by value. </para><namespace name="boost"><namespace name="proto"><namespace name="functor"><struct name="deep_copy"><purpose>A PolymorphicFunctionObject type for deep-copying Proto expression trees. </purpose><description><para>A PolymorphicFunctionObject type for deep-copying Proto expression trees. When a tree is deep-copied, all internal nodes and most terminals held by reference are instead held by value.</para><para>
-</para></description><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::bitwise_xor</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
       <template-type-parameter name="Expr"/>
- </template><specialization><template-arg>This(Expr)</template-arg></specialization><typedef name="type"><type><classname>result_of::deep_copy</classname>< typename boost::remove_const< typename boost::remove_reference< Expr >::type >::type >::type</type></typedef></struct-specialization><typedef name="proto_is_callable_"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result_of::deep_copy</classname>< Expr >::type</type><template>
- <template-type-parameter name="Expr"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><purpose>Deep-copies a Proto expression tree, turning all nodes and terminals held by reference into ones held by value. </purpose></method></method-group></struct></namespace><namespace name="result_of"><struct name="deep_copy"><template>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::bitwise_xor_assign</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
       <template-type-parameter name="Expr"/>
- </template><purpose>A metafunction for calculating the return type of <computeroutput>proto::deep_copy()</computeroutput>. </purpose><description><para>A metafunction for calculating the return type of <computeroutput>proto::deep_copy()</computeroutput>. The type parameter <computeroutput>Expr</computeroutput> should be the type of a Proto expression tree. It should not be a reference type, nor should it be cv-qualified. </para></description><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct></namespace><function name="deep_copy"><type><classname>proto::result_of::deep_copy</classname>< Expr >::type</type><template>
- <template-type-parameter name="Expr"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><purpose>A function for deep-copying Proto expression trees. </purpose><description><para>A function for deep-copying Proto expression trees. When a tree is deep-copied, all internal nodes and most terminals held by reference are instead held by value.</para><para>
-<para>proto::functor::deep_copy. </para>
-</para></description><notes><para>Terminals of reference-to-array type and of reference-to-function type are left unchanged.</para></notes></function></namespace></namespace></header><header name="boost/proto/domain.hpp"><para>Contains definition of domain<> class template and helpers for defining domains with a generator and a grammar for controlling operator overloading. </para><namespace name="boost"><namespace name="proto"><struct name="domain"><template>
- <template-type-parameter name="Generator"><default>default_generator</default></template-type-parameter>
- <template-type-parameter name="Grammar"><default>proto::_</default></template-type-parameter>
- </template><purpose>For use in defining domain tags to be used with <computeroutput>proto::extends<></computeroutput>. A Domain associates an expression type with a Generator, and optionally a Grammar. </purpose><description><para>The Generator determines how new expressions in the domain are constructed. Typically, a generator wraps all new expressions in a wrapper that imparts domain-specific behaviors to expressions within its domain. (See <computeroutput>proto::extends<></computeroutput>.)</para><para>The Grammar determines whether a given expression is valid within the domain, and automatically disables any operator overloads which would cause an invalid expression to be created. By default, the Grammar parameter defaults to the wildcard, <computeroutput>proto::_</computeroutput>, which makes all expressions valid within the domain.</para><para>Example: <programlisting> template<typename Expr>
- struct MyExpr;
-
- struct MyGrammar
- : or_< terminal<_>, plus<MyGrammar, MyGrammar> >
- {};
-
- // Define MyDomain, in which all expressions are
- // wrapped in MyExpr<> and only expressions that
- // conform to MyGrammar are allowed.
- struct MyDomain
- : domain<generator<MyExpr>, MyGrammar>
- {};
-
- // Use MyDomain to define MyExpr
- template<typename Expr>
- struct MyExpr
- : extends<Expr, MyExpr<Expr>, MyDomain>
- {
- // ...
- };
-</programlisting> </para></description><typedef name="proto_grammar"><type>Grammar</type></typedef><typedef name="proto_is_domain_"><type>void</type></typedef></struct><struct name="default_domain"><inherit access="public">boost::proto::domain< Generator, Grammar ></inherit><purpose>The domain expressions have by default, if <computeroutput>proto::extends<></computeroutput> has not been used to associate a domain with an expression. </purpose></struct><struct name="deduce_domain"><inherit access="public">boost::proto::domain< Generator, Grammar ></inherit><purpose>A pseudo-domain for use in functions and metafunctions that require a domain parameter. It indicates that the domain of the parent node should be inferred from the domains of the child nodes. </purpose><description><para>
-</para></description></struct><namespace name="result_of"><struct name="is_domain"><template>
- <template-type-parameter name="T"/>
- <template-type-parameter name="Void"><default>void</default></template-type-parameter>
- </template><inherit access="public">boost::mpl::false_</inherit><description><para>A metafunction that returns <computeroutput>mpl::true_</computeroutput> if the type <computeroutput>T</computeroutput> is the type of a Proto domain; <computeroutput>mpl::false_</computeroutput> otherwise. If <computeroutput>T</computeroutput> inherits from <computeroutput>proto::domain<></computeroutput>, <computeroutput>is_domain<T></computeroutput> is <computeroutput>mpl::true_</computeroutput>. </para></description></struct><struct name="domain_of"><template>
- <template-type-parameter name="T"/>
- <template-type-parameter name="Void"><default>void</default></template-type-parameter>
- </template><description><para>A metafunction that returns the domain of a given type. If <computeroutput>T</computeroutput> is a Proto expression type, it returns that expression's associated domain. If not, it returns <computeroutput>proto::default_domain</computeroutput>. </para></description><typedef name="type"><type><classname>default_domain</classname></type></typedef></struct></namespace></namespace></namespace></header><header name="boost/proto/eval.hpp"><para>Contains the eval() expression evaluator. </para><namespace name="boost"><namespace name="proto"><namespace name="functor"><struct name="eval"><purpose>A PolymorphicFunctionObject type for evaluating a given Proto expression with a given context. </purpose><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::complement</template-arg><template-arg>1</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
       <template-type-parameter name="Expr"/>
- <template-type-parameter name="Context"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>Context)</template-arg></specialization><typedef name="type"><type><classname>proto::result_of::eval</classname>< typename remove_reference< Expr >::type, typename remove_reference< Context >::type >::type</type></typedef></struct-specialization><typedef name="proto_is_callable_"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>proto::result_of::eval</classname>< Expr, Context >::type</type><template>
- <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::dereference</template-arg><template-arg>1</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::divides</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::divides_assign</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::equal_to</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::function</template-arg><template-arg>1</template-arg></specialization><typedef name="e0"><type>result_of::child_c< Expr, 0 >::type</type></typedef><typedef name="r0"><type>Grammar::template <classname>impl</classname>< e0, State, Data >::result_type</type></typedef><typedef name="function_type"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="result_type"><type>boost::result_of< function_type()>::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><str
uct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::function</template-arg><template-arg>2</template-arg></specialization><typedef name="e0"><type>result_of::child_c< Expr, 0 >::type</type></typedef><typedef name="r0"><type>Grammar::template <classname>impl</classname>< e0, State, Data >::result_type</type></typedef><typedef name="e1"><type>result_of::child_c< Expr, 1 >::type</type></typedef><typedef name="r1"><type>Grammar::template <classname>impl</classname>< e1, State, Data >::result_type</type></typedef><typedef name="function_type"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="result_type"><type>boost::result_of< function_type(e1)>::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter n
ame="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::function</template-arg><template-arg>3</template-arg></specialization><typedef name="e0"><type>result_of::child_c< Expr, 0 >::type</type></typedef><typedef name="r0"><type>Grammar::template <classname>impl</classname>< e0, State, Data >::result_type</type></typedef><typedef name="e1"><type>result_of::child_c< Expr, 1 >::type</type></typedef><typedef name="r1"><type>Grammar::template <classname>impl</classname>< e1, State, Data >::result_type</type></typedef><typedef name="e2"><type>result_of::child_c< Expr, 2 >::type</type></typedef><typedef name="r2"><type>Grammar::template <classname>impl</classname>< e2, State, Data >::result_type</type></typedef><typedef name="function_type"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="result_type"><type>boost::result_of< function_type(e1, e2)>::type</type>
</typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::function</template-arg><template-arg>4</template-arg></specialization><typedef name="e0"><type>result_of::child_c< Expr, 0 >::type</type></typedef><typedef name="r0"><type>Grammar::template <classname>impl</classname>< e0, State, Data >::result_type</type></typedef><typedef name="e1"><type>result_of::child_c< Expr, 1 >::type</type></typedef><typedef name="r1"><type>Grammar::template <classname>impl</classname>< e1, State, Data >::result_type</type></typedef><typedef name="e2"><type>result_of::child_c< Expr, 2 >::type</type></typedef><typedef name="r2"><type>Grammar::template <classname>impl</classname>< e2, State, Data >::result_type</type></typedef><typedef name="e3"><type>result_of::child_c< Expr, 3 >::type</type></typedef><typedef name="r3"><type>Grammar::template <classname>impl</classname>< e3, State, Data >
::result_type</type></typedef><typedef name="function_type"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="result_type"><type>boost::result_of< function_type(e1, e2, e3)>::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::function</template-arg><template-arg>5</template-arg></specialization><typedef name="e0"><type>result_of::child_c< Expr, 0 >::type</type></typedef><typedef name="r0"><type>Grammar::template <classname>impl</classname>< e0, State, Data >::result_type</type></typedef><typedef name="e1"><type>result_of::child_c< Expr, 1 >::type</type></typedef><typedef name="r1"><type>Grammar::template <classname>impl</classname>< e1, State, Data >::result_type</type></typedef><typedef name="e2"><type>result_of::child_c< Expr, 2 >::type</type></typedef><typedef name="r2"><type>Grammar::template <classname>impl</classname>< e2, State, Data >::result_type</type></typedef><typedef name="e3"><type>result_of::child_c< Expr, 3 >::type</type></typedef><typedef name="r3"><type>Grammar::template <classname>impl</classname>< e3, State, Data >
::result_type</type></typedef><typedef name="e4"><type>result_of::child_c< Expr, 4 >::type</type></typedef><typedef name="r4"><type>Grammar::template <classname>impl</classname>< e4, State, Data >::result_type</type></typedef><typedef name="function_type"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="result_type"><type>boost::result_of< function_type(e1, e2, e3, e4)>::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::greater</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::greater_equal</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::if_else_</template-arg><template-arg>3</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::less</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::less_equal</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::logical_and</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::logical_not</template-arg><template-arg>1</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::logical_or</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::mem_ptr</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::minus</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::minus_assign</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::modulus</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::modulus_assign</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::multiplies</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::multiplies_assign</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::negate</template-arg><template-arg>1</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::not_equal_to</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::plus</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::plus_assign</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::post_dec</template-arg><template-arg>1</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::post_inc</template-arg><template-arg>1</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::pre_dec</template-arg><template-arg>1</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::pre_inc</template-arg><template-arg>1</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::shift_left</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::shift_left_assign</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::shift_right</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::shift_right_assign</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::subscript</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::terminal</template-arg><template-arg>0</template-arg></specialization><inherit access="public">boost::proto::_child_c< I >::impl< Expr, State, Data ></inherit></struct-specialization><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>tag::unary_plus</template-arg><template-arg>1</template-arg></specialization><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization></struct><struct-specialization name="is_callable"><template>
+ <template-type-parameter name="Grammar"/>
+ </template><specialization><template-arg>_default< Grammar ></template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization></namespace></namespace></header><header name="boost/proto/context/null.hpp"><para>Definintion of null_context<>, an evaluation context for proto::eval() that simply evaluates each child expression, doesn't combine the results at all, and returns void. </para><namespace name="boost"><namespace name="proto"><namespace name="context"><struct name="null_eval"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="Context"/>
+ <template-nontype-parameter name="Arity"><type>long</type><default>Expr::proto_arity::value</default></template-nontype-parameter>
+ </template></struct><struct-specialization name="null_eval"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="Context"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>Context</template-arg><template-arg>0</template-arg></specialization><typedef name="result_type"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>void</type><parameter name=""><paramtype>Expr &</paramtype></parameter><parameter name=""><paramtype>Context &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="null_eval"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="Context"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>Context</template-arg><template-arg>1</template-arg></specialization><typedef name="result_type"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>void</type><parameter name="expr"><paramtype>Expr &</paramtype></parameter><parameter name="ctx"><paramtype>Context &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="null_eval"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="Context"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>Context</template-arg><template-arg>2</template-arg></specialization><typedef name="result_type"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>void</type><parameter name="expr"><paramtype>Expr &</paramtype></parameter><parameter name="ctx"><paramtype>Context &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="null_eval"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="Context"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>Context</template-arg><template-arg>3</template-arg></specialization><typedef name="result_type"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>void</type><parameter name="expr"><paramtype>Expr &</paramtype></parameter><parameter name="ctx"><paramtype>Context &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="null_eval"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="Context"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>Context</template-arg><template-arg>4</template-arg></specialization><typedef name="result_type"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>void</type><parameter name="expr"><paramtype>Expr &</paramtype></parameter><parameter name="ctx"><paramtype>Context &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="null_eval"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="Context"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>Context</template-arg><template-arg>5</template-arg></specialization><typedef name="result_type"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>void</type><parameter name="expr"><paramtype>Expr &</paramtype></parameter><parameter name="ctx"><paramtype>Context &</paramtype></parameter></method></method-group></struct-specialization><struct name="null_context"><description><para>null_context </para></description><struct name="eval"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="ThisContext"><default>null_context const</default></template-type-parameter>
+ </template><inherit access="public">boost::proto::context::null_eval< Expr, ThisContext ></inherit><description><para>null_context::eval </para></description></struct></struct></namespace></namespace></namespace></header><header name="boost/proto/core.hpp"><para>Includes the core of Proto. Not included are the contexts, transforms and debugging utilities. </para></header><header name="boost/proto/debug.hpp"><para>Utilities for debugging Proto expression trees </para><namespace name="boost"><namespace name="proto"><namespace name="functional"><struct name="display_expr"><purpose>Pretty-print a Proto expression tree. </purpose><description><para>A PolymorphicFunctionObject which accepts a Proto expression tree and pretty-prints it to an <computeroutput>ostream</computeroutput> for debugging purposes. </para></description><typedef name="result_type"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>void</type><template>
+ <template-type-parameter name="Args"/>
+ </template><parameter name="expr"><paramtype>proto::expr< <classname>tag::terminal</classname>, Args, 0 > const &</paramtype></parameter><purpose>Pretty-print the current node in a Proto expression tree. </purpose></method><method name="operator()" cv="const"><type>void</type><template>
+ <template-type-parameter name="Tag"/>
+ <template-type-parameter name="Args"/>
+ </template><parameter name="expr"><paramtype>proto::expr< Tag, Args, 1 > const &</paramtype></parameter></method><method name="operator()" cv="const"><type>void</type><template>
+ <template-type-parameter name="Tag"/>
+ <template-type-parameter name="Args"/>
+ </template><parameter name="expr"><paramtype>proto::expr< Tag, Args, 2 > const &</paramtype></parameter></method><method name="operator()" cv="const"><type>void</type><template>
+ <template-type-parameter name="Tag"/>
+ <template-type-parameter name="Args"/>
+ </template><parameter name="expr"><paramtype>proto::expr< Tag, Args, 3 > const &</paramtype></parameter></method><method name="operator()" cv="const"><type>void</type><template>
+ <template-type-parameter name="Tag"/>
+ <template-type-parameter name="Args"/>
+ </template><parameter name="expr"><paramtype>proto::expr< Tag, Args, 4 > const &</paramtype></parameter></method><method name="operator()" cv="const"><type>void</type><template>
+ <template-type-parameter name="Tag"/>
+ <template-type-parameter name="Args"/>
+ </template><parameter name="expr"><paramtype>proto::expr< Tag, Args, 5 > const &</paramtype></parameter></method><method name="operator()" cv="const"><type>void</type><template>
+ <template-type-parameter name="T"/>
+ </template><parameter name="t"><paramtype>T const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method></method-group><constructor><parameter name="sout"><paramtype>std::ostream &</paramtype><default>std::cout</default><description><para>The <computeroutput>ostream</computeroutput> to which the expression tree will be written. </para></description></parameter><parameter name="depth"><paramtype>int</paramtype><default>0</default><description><para>The starting indentation depth for this node. Children nodes will be displayed at a starting depth of <computeroutput>depth+4</computeroutput>. </para></description></parameter><description><para>
+</para></description></constructor><method-group name="private member functions"/><copy-assignment><parameter name=""><paramtype><classname>display_expr</classname> const &</paramtype></parameter></copy-assignment></struct></namespace><namespace name="tag"><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::unary_plus</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::negate</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::dereference</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::complement</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::address_of</classname
></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::logical_not</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::pre_inc</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::pre_dec</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::post_inc</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::post_dec</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::shift_left</classname></paramtype></parameter></function><function name="proto_tag_name"><typ
e>char const *</type><parameter name=""><paramtype><classname>tag::shift_right</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::multiplies</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::divides</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::modulus</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::plus</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::minus</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::less</classn
ame></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::greater</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::less_equal</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::greater_equal</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::equal_to</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::not_equal_to</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::logical_or</classname></paramtype></parameter></function><function name="proto_ta
g_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::logical_and</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::bitwise_and</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::bitwise_or</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::bitwise_xor</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::comma</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::mem_ptr</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><clas
sname>tag::assign</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::shift_left_assign</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::shift_right_assign</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::multiplies_assign</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::divides_assign</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::modulus_assign</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::plus_assign</classname></p
aramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::minus_assign</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::bitwise_and_assign</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::bitwise_or_assign</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::bitwise_xor_assign</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::subscript</classname></paramtype></parameter></function><function name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::if_else_</classname></paramtype></parameter></function><function
name="proto_tag_name"><type>char const *</type><parameter name=""><paramtype><classname>tag::function</classname></paramtype></parameter></function></namespace><overloaded-function name="display_expr"><signature><type>void</type><template>
+ <template-type-parameter name="Expr"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The Proto expression tree to pretty-print </para></description></parameter><parameter name="sout"><paramtype>std::ostream &</paramtype><description><para>The <computeroutput>ostream</computeroutput> to which the output should be written. If not specified, defaults to <computeroutput>std::cout</computeroutput>. </para></description></parameter></signature><signature><type>void</type><template>
+ <template-type-parameter name="Expr"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></signature><purpose>Pretty-print a Proto expression tree. </purpose><description><para>
+
+</para></description><notes><para>Equivalent to <computeroutput>functional::display_expr(0, sout)(expr)</computeroutput> </para></notes></overloaded-function></namespace></namespace></header><header name="boost/proto/deep_copy.hpp"><para>Replace all nodes stored by reference by nodes stored by value. </para><namespace name="boost"><namespace name="proto"><namespace name="functional"><struct name="deep_copy"><purpose>A PolymorphicFunctionObject type for deep-copying Proto expression trees. </purpose><description><para>A PolymorphicFunctionObject type for deep-copying Proto expression trees. When a tree is deep-copied, all internal nodes and most terminals held by reference are instead held by value.</para><para>
+</para></description><struct-specialization name="result"><template>
+ <template-type-parameter name="This"/>
+ <template-type-parameter name="Expr"/>
+ </template><specialization><template-arg>This(Expr)</template-arg></specialization><typedef name="type"><type><classname>result_of::deep_copy</classname>< Expr >::type</type></typedef></struct-specialization><typedef name="proto_is_callable_"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result_of::deep_copy</classname>< Expr >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><purpose>Deep-copies a Proto expression tree, turning all nodes and terminals held by reference into ones held by value. </purpose></method></method-group></struct></namespace><namespace name="result_of"><struct name="deep_copy"><template>
+ <template-type-parameter name="Expr"/>
+ </template><purpose>A metafunction for calculating the return type of <computeroutput>proto::deep_copy()</computeroutput>. </purpose><description><para>A metafunction for calculating the return type of <computeroutput>proto::deep_copy()</computeroutput>. The type parameter <computeroutput>Expr</computeroutput> should be the type of a Proto expression tree. It should not be a reference type, nor should it be cv-qualified. </para></description><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct></namespace><function name="deep_copy"><type><classname>proto::result_of::deep_copy</classname>< Expr >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><purpose>A function for deep-copying Proto expression trees. </purpose><description><para>A function for deep-copying Proto expression trees. When a tree is deep-copied, all internal nodes and most terminals held by reference are instead held by value.</para><para>
+<para>proto::functional::deep_copy. </para>
+</para></description><notes><para>Terminals of reference-to-array type and of reference-to-function type are left unchanged.</para></notes></function></namespace></namespace></header><header name="boost/proto/domain.hpp"><para>Contains definition of domain<> class template and helpers for defining domains with a generator and a grammar for controlling operator overloading. </para><namespace name="boost"><namespace name="proto"><struct name="domain"><template>
+ <template-type-parameter name="Generator"><default>default_generator</default></template-type-parameter>
+ <template-type-parameter name="Grammar"><default>proto::_</default></template-type-parameter>
+ </template><purpose>For use in defining domain tags to be used with <computeroutput>proto::extends<></computeroutput>. A Domain associates an expression type with a Generator, and optionally a Grammar. </purpose><description><para>The Generator determines how new expressions in the domain are constructed. Typically, a generator wraps all new expressions in a wrapper that imparts domain-specific behaviors to expressions within its domain. (See <computeroutput>proto::extends<></computeroutput>.)</para><para>The Grammar determines whether a given expression is valid within the domain, and automatically disables any operator overloads which would cause an invalid expression to be created. By default, the Grammar parameter defaults to the wildcard, <computeroutput>proto::_</computeroutput>, which makes all expressions valid within the domain.</para><para>Example: <programlisting> template<typename Expr>
+ struct MyExpr;
+
+ struct MyGrammar
+ : or_< terminal<_>, plus<MyGrammar, MyGrammar> >
+ {};
+
+ // Define MyDomain, in which all expressions are
+ // wrapped in MyExpr<> and only expressions that
+ // conform to MyGrammar are allowed.
+ struct MyDomain
+ : domain<generator<MyExpr>, MyGrammar>
+ {};
+
+ // Use MyDomain to define MyExpr
+ template<typename Expr>
+ struct MyExpr
+ : extends<Expr, MyExpr<Expr>, MyDomain>
+ {
+ // ...
+ };
+</programlisting> </para></description><typedef name="proto_grammar"><type>Grammar</type></typedef><typedef name="proto_is_domain_"><type>void</type></typedef></struct><struct name="default_domain"><inherit access="public">boost::proto::domain< Generator, Grammar ></inherit><purpose>The domain expressions have by default, if <computeroutput>proto::extends<></computeroutput> has not been used to associate a domain with an expression. </purpose></struct><struct name="deduce_domain"><inherit access="public">boost::proto::domain< Generator, Grammar ></inherit><purpose>A pseudo-domain for use in functions and metafunctions that require a domain parameter. It indicates that the domain of the parent node should be inferred from the domains of the child nodes. </purpose><description><para>
+</para></description></struct><namespace name="result_of"><struct name="is_domain"><template>
+ <template-type-parameter name="T"/>
+ <template-type-parameter name="Void"><default>void</default></template-type-parameter>
+ </template><inherit access="public">boost::mpl::false_</inherit><description><para>A metafunction that returns <computeroutput>mpl::true_</computeroutput> if the type <computeroutput>T</computeroutput> is the type of a Proto domain; <computeroutput>mpl::false_</computeroutput> otherwise. If <computeroutput>T</computeroutput> inherits from <computeroutput>proto::domain<></computeroutput>, <computeroutput>is_domain<T></computeroutput> is <computeroutput>mpl::true_</computeroutput>. </para></description></struct><struct name="domain_of"><template>
+ <template-type-parameter name="T"/>
+ <template-type-parameter name="Void"><default>void</default></template-type-parameter>
+ </template><description><para>A metafunction that returns the domain of a given type. If <computeroutput>T</computeroutput> is a Proto expression type, it returns that expression's associated domain. If not, it returns <computeroutput>proto::default_domain</computeroutput>. </para></description><typedef name="type"><type><classname>default_domain</classname></type></typedef></struct></namespace></namespace></namespace></header><header name="boost/proto/eval.hpp"><para>Contains the eval() expression evaluator. </para><namespace name="boost"><namespace name="proto"><namespace name="functional"><struct name="eval"><purpose>A PolymorphicFunctionObject type for evaluating a given Proto expression with a given context. </purpose><struct-specialization name="result"><template>
+ <template-type-parameter name="This"/>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="Context"/>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>Context)</template-arg></specialization><typedef name="type"><type><classname>proto::result_of::eval</classname>< typename remove_reference< Expr >::type, typename remove_reference< Context >::type >::type</type></typedef></struct-specialization><typedef name="proto_is_callable_"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>proto::result_of::eval</classname>< Expr, Context >::type</type><template>
+ <template-type-parameter name="Expr"/>
           <template-type-parameter name="Context"/>
         </template><parameter name="expr"><paramtype>Expr &</paramtype><description><para>The Proto expression to evaluate </para></description></parameter><parameter name="context"><paramtype>Context &</paramtype><description><para>The context in which the expression should be evaluated. </para></description></parameter><purpose>Evaluate a given Proto expression with a given context. </purpose><description><para>

@@ -379,21 +778,21 @@
</para></description><returns><para><computeroutput>typename Context::template eval<Expr>()(expr, context)</computeroutput> </para></returns></overloaded-function></namespace></namespace></header><header name="boost/proto/expr.hpp"><para>Contains definition of expr<> class template. </para><namespace name="boost"><namespace name="proto"><struct-specialization name="expr"><template>
       <template-type-parameter name="Tag"/>
       <template-type-parameter name="Args"/>
- </template><specialization><template-arg>Tag</template-arg><template-arg>Args</template-arg><template-arg>0</template-arg></specialization><purpose>Representation of a node in an expression tree. </purpose><description><para><computeroutput>proto::expr<></computeroutput> is a node in an expression template tree. It is a container for its child sub-trees. It also serves as the terminal nodes of the tree.</para><para><computeroutput>Tag</computeroutput> is type that represents the operation encoded by this expression. It is typically one of the structs in the <computeroutput>boost::proto::tag</computeroutput> namespace, but it doesn't have to be. If the <computeroutput>Tag</computeroutput> type is <computeroutput>boost::proto::tag::terminal</computeroutput> then this <computeroutput>expr<></computeroutput> type represents a leaf in the expression tree.</para><para><computeroutput>Args</computeroutput> is a type list representing the type of the children of this expression. It is an instantiati
on of one of <computeroutput>proto::list1<></computeroutput>, <computeroutput>proto::list2<></computeroutput>, etc. The child types must all themselves be either <computeroutput>expr<></computeroutput> or <computeroutput>proto::ref_<proto::expr<>></computeroutput>, unless the <computeroutput>Tag</computeroutput> type is <computeroutput>boost::proto::tag::terminal</computeroutput>, in which case <computeroutput>Args</computeroutput> must be <computeroutput>proto::term<T></computeroutput>, where <computeroutput>T</computeroutput> can be any type.</para><para><computeroutput>proto::expr<></computeroutput> is a valid Fusion random-access sequence, where the elements of the sequence are the child expressions. </para></description><struct name="result"><template>
+ </template><specialization><template-arg>Tag</template-arg><template-arg>Args</template-arg><template-arg>0</template-arg></specialization><purpose>Representation of a node in an expression tree. </purpose><description><para><computeroutput>proto::expr<></computeroutput> is a node in an expression template tree. It is a container for its child sub-trees. It also serves as the terminal nodes of the tree.</para><para><computeroutput>Tag</computeroutput> is type that represents the operation encoded by this expression. It is typically one of the structs in the <computeroutput>boost::proto::tag</computeroutput> namespace, but it doesn't have to be. If the <computeroutput>Tag</computeroutput> type is <computeroutput>boost::proto::tag::terminal</computeroutput> then this <computeroutput>expr<></computeroutput> type represents a leaf in the expression tree.</para><para><computeroutput>Args</computeroutput> is a type list representing the type of the children of this expression. It is an instantiati
on of one of <computeroutput>proto::list1<></computeroutput>, <computeroutput>proto::list2<></computeroutput>, etc. The child types must all themselves be either <computeroutput>expr<></computeroutput> or <computeroutput>proto::expr<>&</computeroutput>, unless the <computeroutput>Tag</computeroutput> type is <computeroutput>boost::proto::tag::terminal</computeroutput>, in which case <computeroutput>Args</computeroutput> must be <computeroutput>proto::term<T></computeroutput>, where <computeroutput>T</computeroutput> can be any type.</para><para><computeroutput>proto::expr<></computeroutput> is a valid Fusion random-access sequence, where the elements of the sequence are the child expressions. </para></description><struct name="result"><template>
       <template-type-parameter name="Sig"/>
- </template><description><para>Encodes the return type of <computeroutput>expr<>operator()</computeroutput>, for use with <computeroutput>boost::result_of<></computeroutput> </para></description><typedef name="type"><type>result_of::funop< Sig, expr, <classname>default_domain</classname> >::type</type></typedef></struct><typedef name="proto_tag"><type>Tag</type></typedef><typedef name="proto_arity"><type>mpl::long_< 0 ></type></typedef><typedef name="proto_base_expr"><type>expr</type></typedef><typedef name="proto_args"><type>Args</type></typedef><typedef name="proto_domain"><type><classname>default_domain</classname></type></typedef><typedef name="fusion_tag"><type>proto::tag::proto_expr</type></typedef><typedef name="proto_is_expr_"><type>void</type></typedef><typedef name="proto_derived_expr"><type>expr</type></typedef><typedef name="proto_child0"><type>Args::child0</type></typedef><typedef name="proto_child1"><type>void</type></typedef><typedef name="proto_child2"><type>void</
type></typedef><typedef name="proto_child3"><type>void</type></typedef><typedef name="proto_child4"><type>void</type></typedef><data-member name="child0"><type>proto_child0</type></data-member><method-group name="public member functions"><method name="proto_base" cv="const"><type>expr const &</type><description><para>
-</para></description><returns><para>*this </para></returns></method><method name="proto_base" cv=""><type>expr &</type><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator[]" cv="const"><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>list2</classname>< <classname>ref_</classname>< expr const >, typename <classname>result_of::as_child</classname>< A >::type > > const</type><template>
+ </template><description><para>Encodes the return type of <computeroutput>expr<>operator()</computeroutput>, for use with <computeroutput>boost::result_of<></computeroutput> </para></description><typedef name="type"><type>result_of::funop< Sig, expr, <classname>default_domain</classname> >::type</type></typedef></struct><typedef name="proto_tag"><type>Tag</type></typedef><typedef name="proto_arity"><type>mpl::long_< 0 ></type></typedef><typedef name="proto_base_expr"><type>expr</type></typedef><typedef name="proto_args"><type>Args</type></typedef><typedef name="proto_domain"><type><classname>default_domain</classname></type></typedef><typedef name="fusion_tag"><type>proto::tag::proto_expr</type></typedef><typedef name="proto_is_expr_"><type>void</type></typedef><typedef name="proto_derived_expr"><type>expr</type></typedef><typedef name="proto_child0"><type>Args::child0</type></typedef><typedef name="proto_child_ref0"><type>Args::child_ref0</type></typedef><typedef name="proto_chil
d1"><type>void</type></typedef><typedef name="proto_child_ref1"><type>void</type></typedef><typedef name="proto_child2"><type>void</type></typedef><typedef name="proto_child_ref2"><type>void</type></typedef><typedef name="proto_child3"><type>void</type></typedef><typedef name="proto_child_ref3"><type>void</type></typedef><typedef name="proto_child4"><type>void</type></typedef><typedef name="proto_child_ref4"><type>void</type></typedef><data-member name="child0"><type>proto_child0</type></data-member><method-group name="public member functions"><method name="proto_base" cv="const"><type>expr const &</type><description><para>
+</para></description><returns><para>*this </para></returns></method><method name="proto_base" cv=""><type>expr &</type><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator[]" cv="const"><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>list2</classname>< expr const &, typename <classname>result_of::as_child</classname>< A >::type >> const</type><template>
           <template-type-parameter name="A"/>
         </template><parameter name="a"><paramtype>A &</paramtype><description><para>The rhs. </para></description></parameter><description><para>Subscript</para><para>

-</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing <computeroutput>*this</computeroutput> subscripted with <computeroutput>a</computeroutput>. </para></returns></method><method name="operator[]" cv="const"><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>list2</classname>< <classname>ref_</classname>< expr const >, typename <classname>result_of::as_child</classname>< A const >::type > > const</type><template>
+</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing <computeroutput>*this</computeroutput> subscripted with <computeroutput>a</computeroutput>. </para></returns></method><method name="operator[]" cv="const"><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>list2</classname>< expr const &, typename <classname>result_of::as_child</classname>< A const >::type > > const</type><template>
           <template-type-parameter name="A"/>
- </template><parameter name="a"><paramtype>A const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator[]" cv=""><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>list2</classname>< <classname>ref_</classname>< expr >, typename <classname>result_of::as_child</classname>< A >::type > > const</type><template>
+ </template><parameter name="a"><paramtype>A const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator[]" cv=""><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>list2</classname>< expr &, typename <classname>result_of::as_child</classname>< A >::type >> const</type><template>
           <template-type-parameter name="A"/>
- </template><parameter name="a"><paramtype>A &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator[]" cv=""><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>list2</classname>< <classname>ref_</classname>< expr >, typename <classname>result_of::as_child</classname>< A const >::type > > const</type><template>
+ </template><parameter name="a"><paramtype>A &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator[]" cv=""><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>list2</classname>< expr &, typename <classname>result_of::as_child</classname>< A const >::type >> const</type><template>
           <template-type-parameter name="A"/>
- </template><parameter name="a"><paramtype>A const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type>proto::expr< <classname>proto::tag::function</classname>, <classname>list1</classname>< <classname>ref_</classname>< expr const > > > const</type><description><para>Function call</para><para>
-</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing the function invocation of <computeroutput/>(*this)(). </para></returns></method><method name="operator()" cv=""><type>proto::expr< <classname>proto::tag::function</classname>, <classname>list1</classname>< <classname>ref_</classname>< expr > > > const</type><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop1</classname>< expr const, <classname>default_domain</classname>, const A0 >::type const</type><template>
+ </template><parameter name="a"><paramtype>A const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type>proto::expr< <classname>proto::tag::function</classname>, <classname>list1</classname>< expr const & > > const</type><description><para>Function call</para><para>
+</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing the function invocation of <computeroutput/>(*this)(). </para></returns></method><method name="operator()" cv=""><type>proto::expr< <classname>proto::tag::function</classname>, <classname>list1</classname>< expr & > > const</type><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop1</classname>< expr const, <classname>default_domain</classname>, const A0 >::type const</type><template>
           <template-type-parameter name="A0"/>
         </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop2</classname>< expr const, <classname>default_domain</classname>, const A0, const A1 >::type const</type><template>
           <template-type-parameter name="A0"/>
@@ -431,18 +830,18 @@
         </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name=""><paramtype><emphasis>unspecified</emphasis></paramtype><default>0</default></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method></method-group></struct-specialization><struct-specialization name="expr"><template>
       <template-type-parameter name="Tag"/>
       <template-type-parameter name="Args"/>
- </template><specialization><template-arg>Tag</template-arg><template-arg>Args</template-arg><template-arg>1</template-arg></specialization><purpose>Representation of a node in an expression tree. </purpose><description><para><computeroutput>proto::expr<></computeroutput> is a node in an expression template tree. It is a container for its child sub-trees. It also serves as the terminal nodes of the tree.</para><para><computeroutput>Tag</computeroutput> is type that represents the operation encoded by this expression. It is typically one of the structs in the <computeroutput>boost::proto::tag</computeroutput> namespace, but it doesn't have to be. If the <computeroutput>Tag</computeroutput> type is <computeroutput>boost::proto::tag::terminal</computeroutput> then this <computeroutput>expr<></computeroutput> type represents a leaf in the expression tree.</para><para><computeroutput>Args</computeroutput> is a type list representing the type of the children of this expression. It is an instantiati
on of one of <computeroutput>proto::list1<></computeroutput>, <computeroutput>proto::list2<></computeroutput>, etc. The child types must all themselves be either <computeroutput>expr<></computeroutput> or <computeroutput>proto::ref_<proto::expr<>></computeroutput>, unless the <computeroutput>Tag</computeroutput> type is <computeroutput>boost::proto::tag::terminal</computeroutput>, in which case <computeroutput>Args</computeroutput> must be <computeroutput>proto::term<T></computeroutput>, where <computeroutput>T</computeroutput> can be any type.</para><para><computeroutput>proto::expr<></computeroutput> is a valid Fusion random-access sequence, where the elements of the sequence are the child expressions. </para></description><struct name="result"><template>
+ </template><specialization><template-arg>Tag</template-arg><template-arg>Args</template-arg><template-arg>1</template-arg></specialization><purpose>Representation of a node in an expression tree. </purpose><description><para><computeroutput>proto::expr<></computeroutput> is a node in an expression template tree. It is a container for its child sub-trees. It also serves as the terminal nodes of the tree.</para><para><computeroutput>Tag</computeroutput> is type that represents the operation encoded by this expression. It is typically one of the structs in the <computeroutput>boost::proto::tag</computeroutput> namespace, but it doesn't have to be. If the <computeroutput>Tag</computeroutput> type is <computeroutput>boost::proto::tag::terminal</computeroutput> then this <computeroutput>expr<></computeroutput> type represents a leaf in the expression tree.</para><para><computeroutput>Args</computeroutput> is a type list representing the type of the children of this expression. It is an instantiati
on of one of <computeroutput>proto::list1<></computeroutput>, <computeroutput>proto::list2<></computeroutput>, etc. The child types must all themselves be either <computeroutput>expr<></computeroutput> or <computeroutput>proto::expr<>&</computeroutput>, unless the <computeroutput>Tag</computeroutput> type is <computeroutput>boost::proto::tag::terminal</computeroutput>, in which case <computeroutput>Args</computeroutput> must be <computeroutput>proto::term<T></computeroutput>, where <computeroutput>T</computeroutput> can be any type.</para><para><computeroutput>proto::expr<></computeroutput> is a valid Fusion random-access sequence, where the elements of the sequence are the child expressions. </para></description><struct name="result"><template>
       <template-type-parameter name="Sig"/>
- </template><description><para>Encodes the return type of <computeroutput>expr<>operator()</computeroutput>, for use with <computeroutput>boost::result_of<></computeroutput> </para></description><typedef name="type"><type>result_of::funop< Sig, expr, <classname>default_domain</classname> >::type</type></typedef></struct><typedef name="proto_tag"><type>Tag</type></typedef><typedef name="proto_arity"><type>mpl::long_< 1 ></type></typedef><typedef name="proto_base_expr"><type>expr</type></typedef><typedef name="proto_args"><type>Args</type></typedef><typedef name="proto_domain"><type><classname>default_domain</classname></type></typedef><typedef name="fusion_tag"><type>proto::tag::proto_expr</type></typedef><typedef name="proto_is_expr_"><type>void</type></typedef><typedef name="proto_derived_expr"><type>expr</type></typedef><typedef name="proto_child0"><type>Args::child0</type></typedef><typedef name="proto_child1"><type>void</type></typedef><typedef name="proto_child2"><type>void</
type></typedef><typedef name="proto_child3"><type>void</type></typedef><typedef name="proto_child4"><type>void</type></typedef><typedef name="address_of_hack_type_"><description><para>If <computeroutput>Tag</computeroutput> is <computeroutput>boost::proto::tag::address_of</computeroutput> and <computeroutput>proto_child0</computeroutput> is <computeroutput>proto::ref_<T></computeroutput>, then <computeroutput>address_of_hack_type_</computeroutput> is <computeroutput>T*</computeroutput>. Otherwise, it is some undefined type. </para></description><type><emphasis>unspecified</emphasis></type></typedef><data-member name="child0"><type>proto_child0</type></data-member><method-group name="public member functions"><method name="proto_base" cv="const"><type>expr const &</type><description><para>
+ </template><description><para>Encodes the return type of <computeroutput>expr<>operator()</computeroutput>, for use with <computeroutput>boost::result_of<></computeroutput> </para></description><typedef name="type"><type>result_of::funop< Sig, expr, <classname>default_domain</classname> >::type</type></typedef></struct><typedef name="proto_tag"><type>Tag</type></typedef><typedef name="proto_arity"><type>mpl::long_< 1 ></type></typedef><typedef name="proto_base_expr"><type>expr</type></typedef><typedef name="proto_args"><type>Args</type></typedef><typedef name="proto_domain"><type><classname>default_domain</classname></type></typedef><typedef name="fusion_tag"><type>proto::tag::proto_expr</type></typedef><typedef name="proto_is_expr_"><type>void</type></typedef><typedef name="proto_derived_expr"><type>expr</type></typedef><typedef name="proto_child0"><type>Args::child0</type></typedef><typedef name="proto_child_ref0"><type>Args::child_ref0</type></typedef><typedef name="proto_chil
d1"><type>void</type></typedef><typedef name="proto_child_ref1"><type>void</type></typedef><typedef name="proto_child2"><type>void</type></typedef><typedef name="proto_child_ref2"><type>void</type></typedef><typedef name="proto_child3"><type>void</type></typedef><typedef name="proto_child_ref3"><type>void</type></typedef><typedef name="proto_child4"><type>void</type></typedef><typedef name="proto_child_ref4"><type>void</type></typedef><typedef name="address_of_hack_type_"><description><para>If <computeroutput>Tag</computeroutput> is <computeroutput>boost::proto::tag::address_of</computeroutput> and <computeroutput>proto_child0</computeroutput> is <computeroutput>T&</computeroutput>, then <computeroutput>address_of_hack_type_</computeroutput> is <computeroutput>T*</computeroutput>. Otherwise, it is some undefined type. </para></description><type><emphasis>unspecified</emphasis></type></typedef><data-member name="child0"><type>proto_child0</type></data-member><method-group name="public member functions"><m
ethod name="proto_base" cv="const"><type>expr const &</type><description><para>
</para></description><returns><para>*this </para></returns></method><method name="proto_base" cv=""><type>expr &</type><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="conversion-operator" cv="const"><type>address_of_hack_type_</type><description><para>

-</para></description><returns><para>The address of <computeroutput>this->child0</computeroutput> if <computeroutput>Tag</computeroutput> is <computeroutput>boost::proto::tag::address_of</computeroutput>. Otherwise, this function will fail to compile.</para></returns><notes><para>Proto overloads <computeroutput>operator&</computeroutput>, which means that proto-ified objects cannot have their addresses taken, unless we use the following hack to make <computeroutput>&x</computeroutput> implicitly convertible to <computeroutput>X*</computeroutput>. </para></notes></method><method name="operator[]" cv="const"><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>list2</classname>< <classname>ref_</classname>< expr const >, typename <classname>result_of::as_child</classname>< A >::type > > const</type><template>
+</para></description><returns><para>The address of <computeroutput>this->child0</computeroutput> if <computeroutput>Tag</computeroutput> is <computeroutput>boost::proto::tag::address_of</computeroutput>. Otherwise, this function will fail to compile.</para></returns><notes><para>Proto overloads <computeroutput>operator&</computeroutput>, which means that proto-ified objects cannot have their addresses taken, unless we use the following hack to make <computeroutput>&x</computeroutput> implicitly convertible to <computeroutput>X*</computeroutput>. </para></notes></method><method name="operator[]" cv="const"><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>list2</classname>< expr const &, typename <classname>result_of::as_child</classname>< A >::type >> const</type><template>
           <template-type-parameter name="A"/>
         </template><parameter name="a"><paramtype>A &</paramtype><description><para>The rhs. </para></description></parameter><description><para>Subscript</para><para>

-</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing <computeroutput>*this</computeroutput> subscripted with <computeroutput>a</computeroutput>. </para></returns></method><method name="operator[]" cv="const"><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>list2</classname>< <classname>ref_</classname>< expr const >, typename <classname>result_of::as_child</classname>< A const >::type > > const</type><template>
+</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing <computeroutput>*this</computeroutput> subscripted with <computeroutput>a</computeroutput>. </para></returns></method><method name="operator[]" cv="const"><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>list2</classname>< expr const &, typename <classname>result_of::as_child</classname>< A const >::type > > const</type><template>
           <template-type-parameter name="A"/>
- </template><parameter name="a"><paramtype>A const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type>proto::expr< <classname>proto::tag::function</classname>, <classname>list1</classname>< <classname>ref_</classname>< expr const > > > const</type><description><para>Function call</para><para>
+ </template><parameter name="a"><paramtype>A const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type>proto::expr< <classname>proto::tag::function</classname>, <classname>list1</classname>< expr const & > > const</type><description><para>Function call</para><para>
</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing the function invocation of <computeroutput/>(*this)(). </para></returns></method><method name="operator()" cv="const"><type><classname>result_of::funop1</classname>< expr const, <classname>default_domain</classname>, const A0 >::type const</type><template>
           <template-type-parameter name="A0"/>
         </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop2</classname>< expr const, <classname>default_domain</classname>, const A0, const A1 >::type const</type><template>
@@ -469,16 +868,16 @@
</para></description><returns><para>A new <computeroutput>expr<></computeroutput> object initialized with the specified arguments. </para></returns></method></method-group></struct-specialization><struct-specialization name="expr"><template>
       <template-type-parameter name="Tag"/>
       <template-type-parameter name="Args"/>
- </template><specialization><template-arg>Tag</template-arg><template-arg>Args</template-arg><template-arg>2</template-arg></specialization><purpose>Representation of a node in an expression tree. </purpose><description><para><computeroutput>proto::expr<></computeroutput> is a node in an expression template tree. It is a container for its child sub-trees. It also serves as the terminal nodes of the tree.</para><para><computeroutput>Tag</computeroutput> is type that represents the operation encoded by this expression. It is typically one of the structs in the <computeroutput>boost::proto::tag</computeroutput> namespace, but it doesn't have to be. If the <computeroutput>Tag</computeroutput> type is <computeroutput>boost::proto::tag::terminal</computeroutput> then this <computeroutput>expr<></computeroutput> type represents a leaf in the expression tree.</para><para><computeroutput>Args</computeroutput> is a type list representing the type of the children of this expression. It is an instantiati
on of one of <computeroutput>proto::list1<></computeroutput>, <computeroutput>proto::list2<></computeroutput>, etc. The child types must all themselves be either <computeroutput>expr<></computeroutput> or <computeroutput>proto::ref_<proto::expr<>></computeroutput>, unless the <computeroutput>Tag</computeroutput> type is <computeroutput>boost::proto::tag::terminal</computeroutput>, in which case <computeroutput>Args</computeroutput> must be <computeroutput>proto::term<T></computeroutput>, where <computeroutput>T</computeroutput> can be any type.</para><para><computeroutput>proto::expr<></computeroutput> is a valid Fusion random-access sequence, where the elements of the sequence are the child expressions. </para></description><struct name="result"><template>
+ </template><specialization><template-arg>Tag</template-arg><template-arg>Args</template-arg><template-arg>2</template-arg></specialization><purpose>Representation of a node in an expression tree. </purpose><description><para><computeroutput>proto::expr<></computeroutput> is a node in an expression template tree. It is a container for its child sub-trees. It also serves as the terminal nodes of the tree.</para><para><computeroutput>Tag</computeroutput> is type that represents the operation encoded by this expression. It is typically one of the structs in the <computeroutput>boost::proto::tag</computeroutput> namespace, but it doesn't have to be. If the <computeroutput>Tag</computeroutput> type is <computeroutput>boost::proto::tag::terminal</computeroutput> then this <computeroutput>expr<></computeroutput> type represents a leaf in the expression tree.</para><para><computeroutput>Args</computeroutput> is a type list representing the type of the children of this expression. It is an instantiati
on of one of <computeroutput>proto::list1<></computeroutput>, <computeroutput>proto::list2<></computeroutput>, etc. The child types must all themselves be either <computeroutput>expr<></computeroutput> or <computeroutput>proto::expr<>&</computeroutput>, unless the <computeroutput>Tag</computeroutput> type is <computeroutput>boost::proto::tag::terminal</computeroutput>, in which case <computeroutput>Args</computeroutput> must be <computeroutput>proto::term<T></computeroutput>, where <computeroutput>T</computeroutput> can be any type.</para><para><computeroutput>proto::expr<></computeroutput> is a valid Fusion random-access sequence, where the elements of the sequence are the child expressions. </para></description><struct name="result"><template>
       <template-type-parameter name="Sig"/>
- </template><description><para>Encodes the return type of <computeroutput>expr<>operator()</computeroutput>, for use with <computeroutput>boost::result_of<></computeroutput> </para></description><typedef name="type"><type>result_of::funop< Sig, expr, <classname>default_domain</classname> >::type</type></typedef></struct><typedef name="proto_tag"><type>Tag</type></typedef><typedef name="proto_arity"><type>mpl::long_< 2 ></type></typedef><typedef name="proto_base_expr"><type>expr</type></typedef><typedef name="proto_args"><type>Args</type></typedef><typedef name="proto_domain"><type><classname>default_domain</classname></type></typedef><typedef name="fusion_tag"><type>proto::tag::proto_expr</type></typedef><typedef name="proto_is_expr_"><type>void</type></typedef><typedef name="proto_derived_expr"><type>expr</type></typedef><typedef name="proto_child0"><type>Args::child0</type></typedef><typedef name="proto_child1"><type>Args::child1</type></typedef><typedef name="proto_child2"><typ
e>void</type></typedef><typedef name="proto_child3"><type>void</type></typedef><typedef name="proto_child4"><type>void</type></typedef><data-member name="child0"><type>proto_child0</type></data-member><data-member name="child1"><type>proto_child1</type></data-member><method-group name="public member functions"><method name="proto_base" cv="const"><type>expr const &</type><description><para>
-</para></description><returns><para>*this </para></returns></method><method name="proto_base" cv=""><type>expr &</type><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator[]" cv="const"><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>list2</classname>< <classname>ref_</classname>< expr const >, typename <classname>result_of::as_child</classname>< A >::type > > const</type><template>
+ </template><description><para>Encodes the return type of <computeroutput>expr<>operator()</computeroutput>, for use with <computeroutput>boost::result_of<></computeroutput> </para></description><typedef name="type"><type>result_of::funop< Sig, expr, <classname>default_domain</classname> >::type</type></typedef></struct><typedef name="proto_tag"><type>Tag</type></typedef><typedef name="proto_arity"><type>mpl::long_< 2 ></type></typedef><typedef name="proto_base_expr"><type>expr</type></typedef><typedef name="proto_args"><type>Args</type></typedef><typedef name="proto_domain"><type><classname>default_domain</classname></type></typedef><typedef name="fusion_tag"><type>proto::tag::proto_expr</type></typedef><typedef name="proto_is_expr_"><type>void</type></typedef><typedef name="proto_derived_expr"><type>expr</type></typedef><typedef name="proto_child0"><type>Args::child0</type></typedef><typedef name="proto_child_ref0"><type>Args::child_ref0</type></typedef><typedef name="proto_chil
d1"><type>Args::child1</type></typedef><typedef name="proto_child_ref1"><type>Args::child_ref1</type></typedef><typedef name="proto_child2"><type>void</type></typedef><typedef name="proto_child_ref2"><type>void</type></typedef><typedef name="proto_child3"><type>void</type></typedef><typedef name="proto_child_ref3"><type>void</type></typedef><typedef name="proto_child4"><type>void</type></typedef><typedef name="proto_child_ref4"><type>void</type></typedef><data-member name="child0"><type>proto_child0</type></data-member><data-member name="child1"><type>proto_child1</type></data-member><method-group name="public member functions"><method name="proto_base" cv="const"><type>expr const &</type><description><para>
+</para></description><returns><para>*this </para></returns></method><method name="proto_base" cv=""><type>expr &</type><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator[]" cv="const"><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>list2</classname>< expr const &, typename <classname>result_of::as_child</classname>< A >::type >> const</type><template>
           <template-type-parameter name="A"/>
         </template><parameter name="a"><paramtype>A &</paramtype><description><para>The rhs. </para></description></parameter><description><para>Subscript</para><para>

-</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing <computeroutput>*this</computeroutput> subscripted with <computeroutput>a</computeroutput>. </para></returns></method><method name="operator[]" cv="const"><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>list2</classname>< <classname>ref_</classname>< expr const >, typename <classname>result_of::as_child</classname>< A const >::type > > const</type><template>
+</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing <computeroutput>*this</computeroutput> subscripted with <computeroutput>a</computeroutput>. </para></returns></method><method name="operator[]" cv="const"><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>list2</classname>< expr const &, typename <classname>result_of::as_child</classname>< A const >::type > > const</type><template>
           <template-type-parameter name="A"/>
- </template><parameter name="a"><paramtype>A const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type>proto::expr< <classname>proto::tag::function</classname>, <classname>list1</classname>< <classname>ref_</classname>< expr const > > > const</type><description><para>Function call</para><para>
+ </template><parameter name="a"><paramtype>A const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type>proto::expr< <classname>proto::tag::function</classname>, <classname>list1</classname>< expr const & > > const</type><description><para>Function call</para><para>
</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing the function invocation of <computeroutput/>(*this)(). </para></returns></method><method name="operator()" cv="const"><type><classname>result_of::funop1</classname>< expr const, <classname>default_domain</classname>, const A0 >::type const</type><template>
           <template-type-parameter name="A0"/>
         </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop2</classname>< expr const, <classname>default_domain</classname>, const A0, const A1 >::type const</type><template>
@@ -506,16 +905,16 @@
</para></description><returns><para>A new <computeroutput>expr<></computeroutput> object initialized with the specified arguments. </para></returns></method></method-group></struct-specialization><struct-specialization name="expr"><template>
       <template-type-parameter name="Tag"/>
       <template-type-parameter name="Args"/>
- </template><specialization><template-arg>Tag</template-arg><template-arg>Args</template-arg><template-arg>3</template-arg></specialization><purpose>Representation of a node in an expression tree. </purpose><description><para><computeroutput>proto::expr<></computeroutput> is a node in an expression template tree. It is a container for its child sub-trees. It also serves as the terminal nodes of the tree.</para><para><computeroutput>Tag</computeroutput> is type that represents the operation encoded by this expression. It is typically one of the structs in the <computeroutput>boost::proto::tag</computeroutput> namespace, but it doesn't have to be. If the <computeroutput>Tag</computeroutput> type is <computeroutput>boost::proto::tag::terminal</computeroutput> then this <computeroutput>expr<></computeroutput> type represents a leaf in the expression tree.</para><para><computeroutput>Args</computeroutput> is a type list representing the type of the children of this expression. It is an instantiati
on of one of <computeroutput>proto::list1<></computeroutput>, <computeroutput>proto::list2<></computeroutput>, etc. The child types must all themselves be either <computeroutput>expr<></computeroutput> or <computeroutput>proto::ref_<proto::expr<>></computeroutput>, unless the <computeroutput>Tag</computeroutput> type is <computeroutput>boost::proto::tag::terminal</computeroutput>, in which case <computeroutput>Args</computeroutput> must be <computeroutput>proto::term<T></computeroutput>, where <computeroutput>T</computeroutput> can be any type.</para><para><computeroutput>proto::expr<></computeroutput> is a valid Fusion random-access sequence, where the elements of the sequence are the child expressions. </para></description><struct name="result"><template>
+ </template><specialization><template-arg>Tag</template-arg><template-arg>Args</template-arg><template-arg>3</template-arg></specialization><purpose>Representation of a node in an expression tree. </purpose><description><para><computeroutput>proto::expr<></computeroutput> is a node in an expression template tree. It is a container for its child sub-trees. It also serves as the terminal nodes of the tree.</para><para><computeroutput>Tag</computeroutput> is type that represents the operation encoded by this expression. It is typically one of the structs in the <computeroutput>boost::proto::tag</computeroutput> namespace, but it doesn't have to be. If the <computeroutput>Tag</computeroutput> type is <computeroutput>boost::proto::tag::terminal</computeroutput> then this <computeroutput>expr<></computeroutput> type represents a leaf in the expression tree.</para><para><computeroutput>Args</computeroutput> is a type list representing the type of the children of this expression. It is an instantiati
on of one of <computeroutput>proto::list1<></computeroutput>, <computeroutput>proto::list2<></computeroutput>, etc. The child types must all themselves be either <computeroutput>expr<></computeroutput> or <computeroutput>proto::expr<>&</computeroutput>, unless the <computeroutput>Tag</computeroutput> type is <computeroutput>boost::proto::tag::terminal</computeroutput>, in which case <computeroutput>Args</computeroutput> must be <computeroutput>proto::term<T></computeroutput>, where <computeroutput>T</computeroutput> can be any type.</para><para><computeroutput>proto::expr<></computeroutput> is a valid Fusion random-access sequence, where the elements of the sequence are the child expressions. </para></description><struct name="result"><template>
       <template-type-parameter name="Sig"/>
- </template><description><para>Encodes the return type of <computeroutput>expr<>operator()</computeroutput>, for use with <computeroutput>boost::result_of<></computeroutput> </para></description><typedef name="type"><type>result_of::funop< Sig, expr, <classname>default_domain</classname> >::type</type></typedef></struct><typedef name="proto_tag"><type>Tag</type></typedef><typedef name="proto_arity"><type>mpl::long_< 3 ></type></typedef><typedef name="proto_base_expr"><type>expr</type></typedef><typedef name="proto_args"><type>Args</type></typedef><typedef name="proto_domain"><type><classname>default_domain</classname></type></typedef><typedef name="fusion_tag"><type>proto::tag::proto_expr</type></typedef><typedef name="proto_is_expr_"><type>void</type></typedef><typedef name="proto_derived_expr"><type>expr</type></typedef><typedef name="proto_child0"><type>Args::child0</type></typedef><typedef name="proto_child1"><type>Args::child1</type></typedef><typedef name="proto_child2"><typ
e>Args::child2</type></typedef><typedef name="proto_child3"><type>void</type></typedef><typedef name="proto_child4"><type>void</type></typedef><data-member name="child0"><type>proto_child0</type></data-member><data-member name="child1"><type>proto_child1</type></data-member><data-member name="child2"><type>proto_child2</type></data-member><method-group name="public member functions"><method name="proto_base" cv="const"><type>expr const &</type><description><para>
-</para></description><returns><para>*this </para></returns></method><method name="proto_base" cv=""><type>expr &</type><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator[]" cv="const"><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>list2</classname>< <classname>ref_</classname>< expr const >, typename <classname>result_of::as_child</classname>< A >::type > > const</type><template>
+ </template><description><para>Encodes the return type of <computeroutput>expr<>operator()</computeroutput>, for use with <computeroutput>boost::result_of<></computeroutput> </para></description><typedef name="type"><type>result_of::funop< Sig, expr, <classname>default_domain</classname> >::type</type></typedef></struct><typedef name="proto_tag"><type>Tag</type></typedef><typedef name="proto_arity"><type>mpl::long_< 3 ></type></typedef><typedef name="proto_base_expr"><type>expr</type></typedef><typedef name="proto_args"><type>Args</type></typedef><typedef name="proto_domain"><type><classname>default_domain</classname></type></typedef><typedef name="fusion_tag"><type>proto::tag::proto_expr</type></typedef><typedef name="proto_is_expr_"><type>void</type></typedef><typedef name="proto_derived_expr"><type>expr</type></typedef><typedef name="proto_child0"><type>Args::child0</type></typedef><typedef name="proto_child_ref0"><type>Args::child_ref0</type></typedef><typedef name="proto_chil
d1"><type>Args::child1</type></typedef><typedef name="proto_child_ref1"><type>Args::child_ref1</type></typedef><typedef name="proto_child2"><type>Args::child2</type></typedef><typedef name="proto_child_ref2"><type>Args::child_ref2</type></typedef><typedef name="proto_child3"><type>void</type></typedef><typedef name="proto_child_ref3"><type>void</type></typedef><typedef name="proto_child4"><type>void</type></typedef><typedef name="proto_child_ref4"><type>void</type></typedef><data-member name="child0"><type>proto_child0</type></data-member><data-member name="child1"><type>proto_child1</type></data-member><data-member name="child2"><type>proto_child2</type></data-member><method-group name="public member functions"><method name="proto_base" cv="const"><type>expr const &</type><description><para>
+</para></description><returns><para>*this </para></returns></method><method name="proto_base" cv=""><type>expr &</type><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator[]" cv="const"><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>list2</classname>< expr const &, typename <classname>result_of::as_child</classname>< A >::type >> const</type><template>
           <template-type-parameter name="A"/>
         </template><parameter name="a"><paramtype>A &</paramtype><description><para>The rhs. </para></description></parameter><description><para>Subscript</para><para>

-</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing <computeroutput>*this</computeroutput> subscripted with <computeroutput>a</computeroutput>. </para></returns></method><method name="operator[]" cv="const"><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>list2</classname>< <classname>ref_</classname>< expr const >, typename <classname>result_of::as_child</classname>< A const >::type > > const</type><template>
+</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing <computeroutput>*this</computeroutput> subscripted with <computeroutput>a</computeroutput>. </para></returns></method><method name="operator[]" cv="const"><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>list2</classname>< expr const &, typename <classname>result_of::as_child</classname>< A const >::type > > const</type><template>
           <template-type-parameter name="A"/>
- </template><parameter name="a"><paramtype>A const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type>proto::expr< <classname>proto::tag::function</classname>, <classname>list1</classname>< <classname>ref_</classname>< expr const > > > const</type><description><para>Function call</para><para>
+ </template><parameter name="a"><paramtype>A const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type>proto::expr< <classname>proto::tag::function</classname>, <classname>list1</classname>< expr const & > > const</type><description><para>Function call</para><para>
</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing the function invocation of <computeroutput/>(*this)(). </para></returns></method><method name="operator()" cv="const"><type><classname>result_of::funop1</classname>< expr const, <classname>default_domain</classname>, const A0 >::type const</type><template>
           <template-type-parameter name="A0"/>
         </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop2</classname>< expr const, <classname>default_domain</classname>, const A0, const A1 >::type const</type><template>
@@ -544,16 +943,16 @@
</para></description><returns><para>A new <computeroutput>expr<></computeroutput> object initialized with the specified arguments. </para></returns></method></method-group></struct-specialization><struct-specialization name="expr"><template>
       <template-type-parameter name="Tag"/>
       <template-type-parameter name="Args"/>
- </template><specialization><template-arg>Tag</template-arg><template-arg>Args</template-arg><template-arg>4</template-arg></specialization><purpose>Representation of a node in an expression tree. </purpose><description><para><computeroutput>proto::expr<></computeroutput> is a node in an expression template tree. It is a container for its child sub-trees. It also serves as the terminal nodes of the tree.</para><para><computeroutput>Tag</computeroutput> is type that represents the operation encoded by this expression. It is typically one of the structs in the <computeroutput>boost::proto::tag</computeroutput> namespace, but it doesn't have to be. If the <computeroutput>Tag</computeroutput> type is <computeroutput>boost::proto::tag::terminal</computeroutput> then this <computeroutput>expr<></computeroutput> type represents a leaf in the expression tree.</para><para><computeroutput>Args</computeroutput> is a type list representing the type of the children of this expression. It is an instantiati
on of one of <computeroutput>proto::list1<></computeroutput>, <computeroutput>proto::list2<></computeroutput>, etc. The child types must all themselves be either <computeroutput>expr<></computeroutput> or <computeroutput>proto::ref_<proto::expr<>></computeroutput>, unless the <computeroutput>Tag</computeroutput> type is <computeroutput>boost::proto::tag::terminal</computeroutput>, in which case <computeroutput>Args</computeroutput> must be <computeroutput>proto::term<T></computeroutput>, where <computeroutput>T</computeroutput> can be any type.</para><para><computeroutput>proto::expr<></computeroutput> is a valid Fusion random-access sequence, where the elements of the sequence are the child expressions. </para></description><struct name="result"><template>
+ </template><specialization><template-arg>Tag</template-arg><template-arg>Args</template-arg><template-arg>4</template-arg></specialization><purpose>Representation of a node in an expression tree. </purpose><description><para><computeroutput>proto::expr<></computeroutput> is a node in an expression template tree. It is a container for its child sub-trees. It also serves as the terminal nodes of the tree.</para><para><computeroutput>Tag</computeroutput> is type that represents the operation encoded by this expression. It is typically one of the structs in the <computeroutput>boost::proto::tag</computeroutput> namespace, but it doesn't have to be. If the <computeroutput>Tag</computeroutput> type is <computeroutput>boost::proto::tag::terminal</computeroutput> then this <computeroutput>expr<></computeroutput> type represents a leaf in the expression tree.</para><para><computeroutput>Args</computeroutput> is a type list representing the type of the children of this expression. It is an instantiati
on of one of <computeroutput>proto::list1<></computeroutput>, <computeroutput>proto::list2<></computeroutput>, etc. The child types must all themselves be either <computeroutput>expr<></computeroutput> or <computeroutput>proto::expr<>&</computeroutput>, unless the <computeroutput>Tag</computeroutput> type is <computeroutput>boost::proto::tag::terminal</computeroutput>, in which case <computeroutput>Args</computeroutput> must be <computeroutput>proto::term<T></computeroutput>, where <computeroutput>T</computeroutput> can be any type.</para><para><computeroutput>proto::expr<></computeroutput> is a valid Fusion random-access sequence, where the elements of the sequence are the child expressions. </para></description><struct name="result"><template>
       <template-type-parameter name="Sig"/>
- </template><description><para>Encodes the return type of <computeroutput>expr<>operator()</computeroutput>, for use with <computeroutput>boost::result_of<></computeroutput> </para></description><typedef name="type"><type>result_of::funop< Sig, expr, <classname>default_domain</classname> >::type</type></typedef></struct><typedef name="proto_tag"><type>Tag</type></typedef><typedef name="proto_arity"><type>mpl::long_< 4 ></type></typedef><typedef name="proto_base_expr"><type>expr</type></typedef><typedef name="proto_args"><type>Args</type></typedef><typedef name="proto_domain"><type><classname>default_domain</classname></type></typedef><typedef name="fusion_tag"><type>proto::tag::proto_expr</type></typedef><typedef name="proto_is_expr_"><type>void</type></typedef><typedef name="proto_derived_expr"><type>expr</type></typedef><typedef name="proto_child0"><type>Args::child0</type></typedef><typedef name="proto_child1"><type>Args::child1</type></typedef><typedef name="proto_child2"><typ
e>Args::child2</type></typedef><typedef name="proto_child3"><type>Args::child3</type></typedef><typedef name="proto_child4"><type>void</type></typedef><data-member name="child0"><type>proto_child0</type></data-member><data-member name="child1"><type>proto_child1</type></data-member><data-member name="child2"><type>proto_child2</type></data-member><data-member name="child3"><type>proto_child3</type></data-member><method-group name="public member functions"><method name="proto_base" cv="const"><type>expr const &</type><description><para>
-</para></description><returns><para>*this </para></returns></method><method name="proto_base" cv=""><type>expr &</type><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator[]" cv="const"><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>list2</classname>< <classname>ref_</classname>< expr const >, typename <classname>result_of::as_child</classname>< A >::type > > const</type><template>
+ </template><description><para>Encodes the return type of <computeroutput>expr<>operator()</computeroutput>, for use with <computeroutput>boost::result_of<></computeroutput> </para></description><typedef name="type"><type>result_of::funop< Sig, expr, <classname>default_domain</classname> >::type</type></typedef></struct><typedef name="proto_tag"><type>Tag</type></typedef><typedef name="proto_arity"><type>mpl::long_< 4 ></type></typedef><typedef name="proto_base_expr"><type>expr</type></typedef><typedef name="proto_args"><type>Args</type></typedef><typedef name="proto_domain"><type><classname>default_domain</classname></type></typedef><typedef name="fusion_tag"><type>proto::tag::proto_expr</type></typedef><typedef name="proto_is_expr_"><type>void</type></typedef><typedef name="proto_derived_expr"><type>expr</type></typedef><typedef name="proto_child0"><type>Args::child0</type></typedef><typedef name="proto_child_ref0"><type>Args::child_ref0</type></typedef><typedef name="proto_chil
d1"><type>Args::child1</type></typedef><typedef name="proto_child_ref1"><type>Args::child_ref1</type></typedef><typedef name="proto_child2"><type>Args::child2</type></typedef><typedef name="proto_child_ref2"><type>Args::child_ref2</type></typedef><typedef name="proto_child3"><type>Args::child3</type></typedef><typedef name="proto_child_ref3"><type>Args::child_ref3</type></typedef><typedef name="proto_child4"><type>void</type></typedef><typedef name="proto_child_ref4"><type>void</type></typedef><data-member name="child0"><type>proto_child0</type></data-member><data-member name="child1"><type>proto_child1</type></data-member><data-member name="child2"><type>proto_child2</type></data-member><data-member name="child3"><type>proto_child3</type></data-member><method-group name="public member functions"><method name="proto_base" cv="const"><type>expr const &</type><description><para>
+</para></description><returns><para>*this </para></returns></method><method name="proto_base" cv=""><type>expr &</type><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator[]" cv="const"><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>list2</classname>< expr const &, typename <classname>result_of::as_child</classname>< A >::type >> const</type><template>
           <template-type-parameter name="A"/>
         </template><parameter name="a"><paramtype>A &</paramtype><description><para>The rhs. </para></description></parameter><description><para>Subscript</para><para>

-</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing <computeroutput>*this</computeroutput> subscripted with <computeroutput>a</computeroutput>. </para></returns></method><method name="operator[]" cv="const"><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>list2</classname>< <classname>ref_</classname>< expr const >, typename <classname>result_of::as_child</classname>< A const >::type > > const</type><template>
+</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing <computeroutput>*this</computeroutput> subscripted with <computeroutput>a</computeroutput>. </para></returns></method><method name="operator[]" cv="const"><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>list2</classname>< expr const &, typename <classname>result_of::as_child</classname>< A const >::type > > const</type><template>
           <template-type-parameter name="A"/>
- </template><parameter name="a"><paramtype>A const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type>proto::expr< <classname>proto::tag::function</classname>, <classname>list1</classname>< <classname>ref_</classname>< expr const > > > const</type><description><para>Function call</para><para>
+ </template><parameter name="a"><paramtype>A const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type>proto::expr< <classname>proto::tag::function</classname>, <classname>list1</classname>< expr const & > > const</type><description><para>Function call</para><para>
</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing the function invocation of <computeroutput/>(*this)(). </para></returns></method><method name="operator()" cv="const"><type><classname>result_of::funop1</classname>< expr const, <classname>default_domain</classname>, const A0 >::type const</type><template>
           <template-type-parameter name="A0"/>
         </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop2</classname>< expr const, <classname>default_domain</classname>, const A0, const A1 >::type const</type><template>
@@ -583,16 +982,16 @@
</para></description><returns><para>A new <computeroutput>expr<></computeroutput> object initialized with the specified arguments. </para></returns></method></method-group></struct-specialization><struct-specialization name="expr"><template>
       <template-type-parameter name="Tag"/>
       <template-type-parameter name="Args"/>
- </template><specialization><template-arg>Tag</template-arg><template-arg>Args</template-arg><template-arg>5</template-arg></specialization><purpose>Representation of a node in an expression tree. </purpose><description><para><computeroutput>proto::expr<></computeroutput> is a node in an expression template tree. It is a container for its child sub-trees. It also serves as the terminal nodes of the tree.</para><para><computeroutput>Tag</computeroutput> is type that represents the operation encoded by this expression. It is typically one of the structs in the <computeroutput>boost::proto::tag</computeroutput> namespace, but it doesn't have to be. If the <computeroutput>Tag</computeroutput> type is <computeroutput>boost::proto::tag::terminal</computeroutput> then this <computeroutput>expr<></computeroutput> type represents a leaf in the expression tree.</para><para><computeroutput>Args</computeroutput> is a type list representing the type of the children of this expression. It is an instantiati
on of one of <computeroutput>proto::list1<></computeroutput>, <computeroutput>proto::list2<></computeroutput>, etc. The child types must all themselves be either <computeroutput>expr<></computeroutput> or <computeroutput>proto::ref_<proto::expr<>></computeroutput>, unless the <computeroutput>Tag</computeroutput> type is <computeroutput>boost::proto::tag::terminal</computeroutput>, in which case <computeroutput>Args</computeroutput> must be <computeroutput>proto::term<T></computeroutput>, where <computeroutput>T</computeroutput> can be any type.</para><para><computeroutput>proto::expr<></computeroutput> is a valid Fusion random-access sequence, where the elements of the sequence are the child expressions. </para></description><struct name="result"><template>
+ </template><specialization><template-arg>Tag</template-arg><template-arg>Args</template-arg><template-arg>5</template-arg></specialization><purpose>Representation of a node in an expression tree. </purpose><description><para><computeroutput>proto::expr<></computeroutput> is a node in an expression template tree. It is a container for its child sub-trees. It also serves as the terminal nodes of the tree.</para><para><computeroutput>Tag</computeroutput> is type that represents the operation encoded by this expression. It is typically one of the structs in the <computeroutput>boost::proto::tag</computeroutput> namespace, but it doesn't have to be. If the <computeroutput>Tag</computeroutput> type is <computeroutput>boost::proto::tag::terminal</computeroutput> then this <computeroutput>expr<></computeroutput> type represents a leaf in the expression tree.</para><para><computeroutput>Args</computeroutput> is a type list representing the type of the children of this expression. It is an instantiati
on of one of <computeroutput>proto::list1<></computeroutput>, <computeroutput>proto::list2<></computeroutput>, etc. The child types must all themselves be either <computeroutput>expr<></computeroutput> or <computeroutput>proto::expr<>&</computeroutput>, unless the <computeroutput>Tag</computeroutput> type is <computeroutput>boost::proto::tag::terminal</computeroutput>, in which case <computeroutput>Args</computeroutput> must be <computeroutput>proto::term<T></computeroutput>, where <computeroutput>T</computeroutput> can be any type.</para><para><computeroutput>proto::expr<></computeroutput> is a valid Fusion random-access sequence, where the elements of the sequence are the child expressions. </para></description><struct name="result"><template>
       <template-type-parameter name="Sig"/>
- </template><description><para>Encodes the return type of <computeroutput>expr<>operator()</computeroutput>, for use with <computeroutput>boost::result_of<></computeroutput> </para></description><typedef name="type"><type>result_of::funop< Sig, expr, <classname>default_domain</classname> >::type</type></typedef></struct><typedef name="proto_tag"><type>Tag</type></typedef><typedef name="proto_arity"><type>mpl::long_< 5 ></type></typedef><typedef name="proto_base_expr"><type>expr</type></typedef><typedef name="proto_args"><type>Args</type></typedef><typedef name="proto_domain"><type><classname>default_domain</classname></type></typedef><typedef name="fusion_tag"><type>proto::tag::proto_expr</type></typedef><typedef name="proto_is_expr_"><type>void</type></typedef><typedef name="proto_derived_expr"><type>expr</type></typedef><typedef name="proto_child0"><type>Args::child0</type></typedef><typedef name="proto_child1"><type>Args::child1</type></typedef><typedef name="proto_child2"><typ
e>Args::child2</type></typedef><typedef name="proto_child3"><type>Args::child3</type></typedef><typedef name="proto_child4"><type>Args::child4</type></typedef><data-member name="child0"><type>proto_child0</type></data-member><data-member name="child1"><type>proto_child1</type></data-member><data-member name="child2"><type>proto_child2</type></data-member><data-member name="child3"><type>proto_child3</type></data-member><data-member name="child4"><type>proto_child4</type></data-member><method-group name="public member functions"><method name="proto_base" cv="const"><type>expr const &</type><description><para>
-</para></description><returns><para>*this </para></returns></method><method name="proto_base" cv=""><type>expr &</type><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator[]" cv="const"><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>list2</classname>< <classname>ref_</classname>< expr const >, typename <classname>result_of::as_child</classname>< A >::type > > const</type><template>
+ </template><description><para>Encodes the return type of <computeroutput>expr<>operator()</computeroutput>, for use with <computeroutput>boost::result_of<></computeroutput> </para></description><typedef name="type"><type>result_of::funop< Sig, expr, <classname>default_domain</classname> >::type</type></typedef></struct><typedef name="proto_tag"><type>Tag</type></typedef><typedef name="proto_arity"><type>mpl::long_< 5 ></type></typedef><typedef name="proto_base_expr"><type>expr</type></typedef><typedef name="proto_args"><type>Args</type></typedef><typedef name="proto_domain"><type><classname>default_domain</classname></type></typedef><typedef name="fusion_tag"><type>proto::tag::proto_expr</type></typedef><typedef name="proto_is_expr_"><type>void</type></typedef><typedef name="proto_derived_expr"><type>expr</type></typedef><typedef name="proto_child0"><type>Args::child0</type></typedef><typedef name="proto_child_ref0"><type>Args::child_ref0</type></typedef><typedef name="proto_chil
d1"><type>Args::child1</type></typedef><typedef name="proto_child_ref1"><type>Args::child_ref1</type></typedef><typedef name="proto_child2"><type>Args::child2</type></typedef><typedef name="proto_child_ref2"><type>Args::child_ref2</type></typedef><typedef name="proto_child3"><type>Args::child3</type></typedef><typedef name="proto_child_ref3"><type>Args::child_ref3</type></typedef><typedef name="proto_child4"><type>Args::child4</type></typedef><typedef name="proto_child_ref4"><type>Args::child_ref4</type></typedef><data-member name="child0"><type>proto_child0</type></data-member><data-member name="child1"><type>proto_child1</type></data-member><data-member name="child2"><type>proto_child2</type></data-member><data-member name="child3"><type>proto_child3</type></data-member><data-member name="child4"><type>proto_child4</type></data-member><method-group name="public member functions"><method name="proto_base" cv="const"><type>expr const &</type><description><para>
+</para></description><returns><para>*this </para></returns></method><method name="proto_base" cv=""><type>expr &</type><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator[]" cv="const"><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>list2</classname>< expr const &, typename <classname>result_of::as_child</classname>< A >::type >> const</type><template>
           <template-type-parameter name="A"/>
         </template><parameter name="a"><paramtype>A &</paramtype><description><para>The rhs. </para></description></parameter><description><para>Subscript</para><para>

-</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing <computeroutput>*this</computeroutput> subscripted with <computeroutput>a</computeroutput>. </para></returns></method><method name="operator[]" cv="const"><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>list2</classname>< <classname>ref_</classname>< expr const >, typename <classname>result_of::as_child</classname>< A const >::type > > const</type><template>
+</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing <computeroutput>*this</computeroutput> subscripted with <computeroutput>a</computeroutput>. </para></returns></method><method name="operator[]" cv="const"><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>list2</classname>< expr const &, typename <classname>result_of::as_child</classname>< A const >::type > > const</type><template>
           <template-type-parameter name="A"/>
- </template><parameter name="a"><paramtype>A const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type>proto::expr< <classname>proto::tag::function</classname>, <classname>list1</classname>< <classname>ref_</classname>< expr const > > > const</type><description><para>Function call</para><para>
+ </template><parameter name="a"><paramtype>A const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type>proto::expr< <classname>proto::tag::function</classname>, <classname>list1</classname>< expr const & > > const</type><description><para>Function call</para><para>
</para></description><returns><para>A new <computeroutput>expr<></computeroutput> node representing the function invocation of <computeroutput/>(*this)(). </para></returns></method><method name="operator()" cv="const"><type><classname>result_of::funop1</classname>< expr const, <classname>default_domain</classname>, const A0 >::type const</type><template>
           <template-type-parameter name="A0"/>
         </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::funop2</classname>< expr const, <classname>default_domain</classname>, const A0, const A1 >::type const</type><template>
@@ -623,7 +1022,7 @@
</para></description><returns><para>A new <computeroutput>expr<></computeroutput> object initialized with the specified arguments. </para></returns></method></method-group></struct-specialization><namespace name="result_of"><struct name="funop0"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="Domain"/>
- </template><purpose>A helper metafunction for computing the return type of <computeroutput>proto::expr<>operator()</computeroutput>. </purpose><typedef name="type"><type>proto::expr< <classname>tag::function</classname>, <classname>list1</classname>< <classname>ref_</classname>< Expr >>></type></typedef><method-group name="public static functions"><method name="call" cv=""><type>static type const</type><parameter name="expr"><paramtype>Expr &</paramtype></parameter></method></method-group></struct><struct-specialization name="funop"><template>
+ </template><purpose>A helper metafunction for computing the return type of <computeroutput>proto::expr<>operator()</computeroutput>. </purpose><typedef name="type"><type>proto::expr< <classname>tag::function</classname>, <classname>list1</classname>< Expr & >></type></typedef><method-group name="public static functions"><method name="call" cv=""><type>static type const</type><parameter name="expr"><paramtype>Expr &</paramtype></parameter></method></method-group></struct><struct-specialization name="funop"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Domain"/>
@@ -635,7 +1034,7 @@
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="Domain"/>
       <template-type-parameter name="A0"/>
- </template><purpose>A helper metafunction for computing the return type of <computeroutput>proto::expr<>operator()</computeroutput>. </purpose><typedef name="type"><type>proto::expr< <classname>tag::function</classname>, <classname>list2</classname>< <classname>ref_</classname>< Expr >, typename <classname>proto::result_of::as_child</classname>< A0, Domain >::type >></type></typedef><method-group name="public static functions"><method name="call" cv=""><type>static type const</type><parameter name="expr"><paramtype>Expr &</paramtype></parameter><parameter name="a0"><paramtype>A0 &</paramtype></parameter></method></method-group></struct><struct-specialization name="funop"><template>
+ </template><purpose>A helper metafunction for computing the return type of <computeroutput>proto::expr<>operator()</computeroutput>. </purpose><typedef name="type"><type>proto::expr< <classname>tag::function</classname>, <classname>list2</classname>< Expr &, typename <classname>proto::result_of::as_child</classname>< A0, Domain >::type >></type></typedef><method-group name="public static functions"><method name="call" cv=""><type>static type const</type><parameter name="expr"><paramtype>Expr &</paramtype></parameter><parameter name="a0"><paramtype>A0 &</paramtype></parameter></method></method-group></struct><struct-specialization name="funop"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="A0"/>
       <template-type-parameter name="This"/>
@@ -650,7 +1049,7 @@
       <template-type-parameter name="Domain"/>
       <template-type-parameter name="A0"/>
       <template-type-parameter name="A1"/>
- </template><purpose>A helper metafunction for computing the return type of <computeroutput>proto::expr<>operator()</computeroutput>. </purpose><typedef name="type"><type>proto::expr< <classname>tag::function</classname>, <classname>list3</classname>< <classname>ref_</classname>< Expr >, typename <classname>proto::result_of::as_child</classname>< A0, Domain >::type, typename <classname>proto::result_of::as_child</classname>< A1, Domain >::type >></type></typedef><method-group name="public static functions"><method name="call" cv=""><type>static type const</type><parameter name="expr"><paramtype>Expr &</paramtype></parameter><parameter name="a0"><paramtype>A0 &</paramtype></parameter><parameter name="a1"><paramtype>A1 &</paramtype></parameter></method></method-group></struct><struct-specialization name="funop"><template>
+ </template><purpose>A helper metafunction for computing the return type of <computeroutput>proto::expr<>operator()</computeroutput>. </purpose><typedef name="type"><type>proto::expr< <classname>tag::function</classname>, <classname>list3</classname>< Expr &, typename <classname>proto::result_of::as_child</classname>< A0, Domain >::type, typename <classname>proto::result_of::as_child</classname>< A1, Domain >::type >></type></typedef><method-group name="public static functions"><method name="call" cv=""><type>static type const</type><parameter name="expr"><paramtype>Expr &</paramtype></parameter><parameter name="a0"><paramtype>A0 &</paramtype></parameter><parameter name="a1"><paramtype>A1 &</paramtype></parameter></method></method-group></struct><struct-specialization name="funop"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="A0"/>
       <template-type-parameter name="A1"/>
@@ -668,7 +1067,7 @@
       <template-type-parameter name="A0"/>
       <template-type-parameter name="A1"/>
       <template-type-parameter name="A2"/>
- </template><purpose>A helper metafunction for computing the return type of <computeroutput>proto::expr<>operator()</computeroutput>. </purpose><typedef name="type"><type>proto::expr< <classname>tag::function</classname>, <classname>list4</classname>< <classname>ref_</classname>< Expr >, typename <classname>proto::result_of::as_child</classname>< A0, Domain >::type, typename <classname>proto::result_of::as_child</classname>< A1, Domain >::type, typename <classname>proto::result_of::as_child</classname>< A2, Domain >::type >></type></typedef><method-group name="public static functions"><method name="call" cv=""><type>static type const</type><parameter name="expr"><paramtype>Expr &</paramtype></parameter><parameter name="a0"><paramtype>A0 &</paramtype></parameter><parameter name="a1"><paramtype>A1 &</paramtype></parameter><parameter name="a2"><paramtype>A2 &</paramtype></parameter></method></method-group></struct><struct-specialization name="funop">
<template>
+ </template><purpose>A helper metafunction for computing the return type of <computeroutput>proto::expr<>operator()</computeroutput>. </purpose><typedef name="type"><type>proto::expr< <classname>tag::function</classname>, <classname>list4</classname>< Expr &, typename <classname>proto::result_of::as_child</classname>< A0, Domain >::type, typename <classname>proto::result_of::as_child</classname>< A1, Domain >::type, typename <classname>proto::result_of::as_child</classname>< A2, Domain >::type >></type></typedef><method-group name="public static functions"><method name="call" cv=""><type>static type const</type><parameter name="expr"><paramtype>Expr &</paramtype></parameter><parameter name="a0"><paramtype>A0 &</paramtype></parameter><parameter name="a1"><paramtype>A1 &</paramtype></parameter><parameter name="a2"><paramtype>A2 &</paramtype></parameter></method></method-group></struct><struct-specialization name="funop"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="A0"/>
       <template-type-parameter name="A1"/>
@@ -689,7 +1088,7 @@
       <template-type-parameter name="A1"/>
       <template-type-parameter name="A2"/>
       <template-type-parameter name="A3"/>
- </template><purpose>A helper metafunction for computing the return type of <computeroutput>proto::expr<>operator()</computeroutput>. </purpose><typedef name="type"><type>proto::expr< <classname>tag::function</classname>, <classname>list5</classname>< <classname>ref_</classname>< Expr >, typename <classname>proto::result_of::as_child</classname>< A0, Domain >::type, typename <classname>proto::result_of::as_child</classname>< A1, Domain >::type, typename <classname>proto::result_of::as_child</classname>< A2, Domain >::type, typename <classname>proto::result_of::as_child</classname>< A3, Domain >::type >></type></typedef><method-group name="public static functions"><method name="call" cv=""><type>static type const</type><parameter name="expr"><paramtype>Expr &</paramtype></parameter><parameter name="a0"><paramtype>A0 &</paramtype></parameter><parameter name="a1"><paramtype>A1 &</paramtype></parameter><parameter name="a2"><paramtype>A2 &</param
type></parameter><parameter name="a3"><paramtype>A3 &</paramtype></parameter></method></method-group></struct><struct-specialization name="funop"><template>
+ </template><purpose>A helper metafunction for computing the return type of <computeroutput>proto::expr<>operator()</computeroutput>. </purpose><typedef name="type"><type>proto::expr< <classname>tag::function</classname>, <classname>list5</classname>< Expr &, typename <classname>proto::result_of::as_child</classname>< A0, Domain >::type, typename <classname>proto::result_of::as_child</classname>< A1, Domain >::type, typename <classname>proto::result_of::as_child</classname>< A2, Domain >::type, typename <classname>proto::result_of::as_child</classname>< A3, Domain >::type >></type></typedef><method-group name="public static functions"><method name="call" cv=""><type>static type const</type><parameter name="expr"><paramtype>Expr &</paramtype></parameter><parameter name="a0"><paramtype>A0 &</paramtype></parameter><parameter name="a1"><paramtype>A1 &</paramtype></parameter><parameter name="a2"><paramtype>A2 &</paramtype></parameter><parameter nam
e="a3"><paramtype>A3 &</paramtype></parameter></method></method-group></struct><struct-specialization name="funop"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="A0"/>
       <template-type-parameter name="A1"/>
@@ -731,7 +1130,7 @@
       <template-type-parameter name="Domain"/>
     </template><specialization><template-arg>Expr</template-arg><template-arg>Derived</template-arg><template-arg>Domain</template-arg><template-arg>tag::terminal</template-arg></specialization><purpose>extends<> class template for adding behaviors to a Proto expression template </purpose><struct name="result"><template>
       <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type>boost::result_of< proto_domain(typename boost::proto::result_of::funop< Sig, proto_derived_expr, proto_domain >::type) >::type</type></typedef></struct><data-member name="expr"><type>Expr</type></data-member><typedef name="proto_base_expr"><type>Expr::proto_base_expr</type></typedef><typedef name="proto_domain"><type>Domain</type></typedef><typedef name="proto_derived_expr"><type>Derived</type></typedef><typedef name="proto_tag"><type>proto_base_expr::proto_tag</type></typedef><typedef name="proto_args"><type>proto_base_expr::proto_args</type></typedef><typedef name="proto_arity"><type>proto_base_expr::proto_arity</type></typedef><typedef name="proto_is_expr_"><type>void</type></typedef><typedef name="fusion_tag"><type>boost::proto::tag::proto_expr</type></typedef><typedef name="proto_child0"><type>proto_base_expr::proto_child0</type></typedef><typedef name="proto_child1"><type>proto_base_expr::proto_child1</type></typedef><typedef name="proto_child2"><t
ype>proto_base_expr::proto_child2</type></typedef><typedef name="proto_child3"><type>proto_base_expr::proto_child3</type></typedef><typedef name="proto_child4"><type>proto_base_expr::proto_child4</type></typedef><method-group name="public member functions"><method name="extends" cv=""><type/></method><method name="extends" cv=""><type/><parameter name="that"><paramtype><classname>extends</classname> const &</paramtype></parameter></method><method name="extends" cv=""><type/><parameter name="expr_"><paramtype>Expr const &</paramtype></parameter></method><method name="proto_base" cv=""><type>proto_base_expr &</type></method><method name="proto_base" cv="const"><type>proto_base_expr const &</type></method></method-group><method-group name="public static functions"><method name="make" cv=""><type>static proto_derived_expr const</type><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></method></method-group></struct-specialization></namespace></namespace></header><header na
me="boost/proto/fusion.hpp"><para>Make any Proto expression a valid Fusion sequence </para><namespace name="boost"><namespace name="proto"><namespace name="functor"><struct name="flatten"><purpose>A PolymorphicFunctionObject type that returns a "flattened" view of a Proto expression tree. </purpose><description><para>A PolymorphicFunctionObject type that returns a "flattened" view of a Proto expression tree. For a tree with a top-most node tag of type <computeroutput>T</computeroutput>, the elements of the flattened sequence are determined by recursing into each child node with the same tag type and returning those nodes of different type. So for instance, the Proto expression tree corresponding to the expression <computeroutput>a | b | c</computeroutput> has a flattened view with elements [a, b, c], even though the tree is grouped as <computeroutput>((a | b) | c)</computeroutput>. </para></description><struct-specialization name="result"><template>
+ </template><typedef name="type"><type>boost::result_of< proto_domain(typename boost::proto::result_of::funop< Sig, proto_derived_expr, proto_domain >::type) >::type</type></typedef></struct><data-member name="expr"><type>Expr</type></data-member><typedef name="proto_base_expr"><type>Expr::proto_base_expr</type></typedef><typedef name="proto_domain"><type>Domain</type></typedef><typedef name="proto_derived_expr"><type>Derived</type></typedef><typedef name="proto_tag"><type>proto_base_expr::proto_tag</type></typedef><typedef name="proto_args"><type>proto_base_expr::proto_args</type></typedef><typedef name="proto_arity"><type>proto_base_expr::proto_arity</type></typedef><typedef name="proto_is_expr_"><type>void</type></typedef><typedef name="fusion_tag"><type>boost::proto::tag::proto_expr</type></typedef><typedef name="proto_child0"><type>proto_base_expr::proto_child0</type></typedef><typedef name="proto_child1"><type>proto_base_expr::proto_child1</type></typedef><typedef name="proto_child2"><t
ype>proto_base_expr::proto_child2</type></typedef><typedef name="proto_child3"><type>proto_base_expr::proto_child3</type></typedef><typedef name="proto_child4"><type>proto_base_expr::proto_child4</type></typedef><method-group name="public member functions"><method name="extends" cv=""><type/></method><method name="extends" cv=""><type/><parameter name="that"><paramtype><classname>extends</classname> const &</paramtype></parameter></method><method name="extends" cv=""><type/><parameter name="expr_"><paramtype>Expr const &</paramtype></parameter></method><method name="proto_base" cv=""><type>proto_base_expr &</type></method><method name="proto_base" cv="const"><type>proto_base_expr const &</type></method></method-group><method-group name="public static functions"><method name="make" cv=""><type>static proto_derived_expr const</type><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></method></method-group></struct-specialization></namespace></namespace></header><header na
me="boost/proto/fusion.hpp"><para>Make any Proto expression a valid Fusion sequence </para><namespace name="boost"><namespace name="proto"><namespace name="functional"><struct name="flatten"><purpose>A PolymorphicFunctionObject type that returns a "flattened" view of a Proto expression tree. </purpose><description><para>A PolymorphicFunctionObject type that returns a "flattened" view of a Proto expression tree. For a tree with a top-most node tag of type <computeroutput>T</computeroutput>, the elements of the flattened sequence are determined by recursing into each child node with the same tag type and returning those nodes of different type. So for instance, the Proto expression tree corresponding to the expression <computeroutput>a | b | c</computeroutput> has a flattened view with elements [a, b, c], even though the tree is grouped as <computeroutput>((a | b) | c)</computeroutput>. </para></description><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
     </template><specialization><template-arg>This(Expr)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><typedef name="proto_is_callable_"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><emphasis>unspecified</emphasis></type><template>
@@ -793,24 +1192,49 @@
</para></description><returns><para>Second()(First()(expr)) </para></returns></method></method-group></struct></namespace></namespace></header><header name="boost/proto/literal.hpp"><para>The literal<> terminal wrapper, and the proto::lit() function for creating literal<> wrappers. </para><namespace name="boost"><namespace name="proto"><namespace name="utility"><struct name="literal"><template>
       <template-type-parameter name="T"/>
       <template-type-parameter name="Domain"><default>default_domain</default></template-type-parameter>
- </template><inherit access="public">boost::proto::extends< Expr, Derived, Domain, Tag ></inherit><purpose>A simple wrapper for a terminal, provided for ease of use. </purpose><description><para>A simple wrapper for a terminal, provided for ease of use. In all cases, <computeroutput>literal<X> l(x);</computeroutput> is equivalent to <computeroutput>terminal<X>::type l = {x};</computeroutput>.</para><para>The <computeroutput>Domain</computeroutput> template parameter defaults to <computeroutput>proto::default_domain</computeroutput>. </para></description><typedef name="value_type"><type><classname>proto::result_of::value</classname>< terminal_type >::type</type></typedef><typedef name="reference"><type><classname>proto::result_of::value</classname>< terminal_type >::reference</type></typedef><typedef name="const_reference"><type><classname>proto::result_of::value</classname>< terminal_type >::const_reference</type></typedef><method-group name="public member functions"><
method name="get" cv=""><type>reference</type></method><method name="get" cv="const"><type>const_reference</type></method></method-group><constructor><template>
+ </template><inherit access="public">boost::proto::extends< Expr, Derived, Domain, Tag ></inherit><purpose>A simple wrapper for a terminal, provided for ease of use. </purpose><description><para>A simple wrapper for a terminal, provided for ease of use. In all cases, <computeroutput>literal<X> l(x);</computeroutput> is equivalent to <computeroutput>terminal<X>::type l = {x};</computeroutput>.</para><para>The <computeroutput>Domain</computeroutput> template parameter defaults to <computeroutput>proto::default_domain</computeroutput>. </para></description><typedef name="value_type"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="reference"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="const_reference"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="get" cv=""><type>reference</type></method><method name="get" cv="const"><type>const_reference</type></method></method-group><constru
ctor><template>
           <template-type-parameter name="U"/>
         </template><parameter name="u"><paramtype>U &</paramtype></parameter></constructor><constructor><template>
           <template-type-parameter name="U"/>
         </template><parameter name="u"><paramtype>U const &</paramtype></parameter></constructor><constructor><template>
           <template-type-parameter name="U"/>
- </template><parameter name="u"><paramtype><classname>literal</classname>< U, Domain > const &</paramtype></parameter></constructor></struct></namespace><overloaded-function name="lit"><signature><type>literal< T & ></type><template>
+ </template><parameter name="u"><paramtype><classname>literal</classname>< U, Domain > const &</paramtype></parameter></constructor></struct></namespace><overloaded-function name="lit"><signature><type>literal< T & > const</type><template>
           <template-type-parameter name="T"/>
- </template><parameter name="t"><paramtype>T &</paramtype><description><para>The object to wrap. </para></description></parameter></signature><signature><type>literal< T const & ></type><template>
+ </template><parameter name="t"><paramtype>T &</paramtype><description><para>The object to wrap. </para></description></parameter></signature><signature><type>literal< T const & > const</type><template>
           <template-type-parameter name="T"/>
         </template><parameter name="t"><paramtype>T const &</paramtype></parameter></signature><purpose>A helper function for creating a <computeroutput>literal<></computeroutput> wrapper. </purpose><description><para>

-</para></description><returns><para>literal<T &>(t) </para></returns><throws><simpara>Will not throw.</simpara></throws><notes><para>The returned value holds the argument by reference. </para></notes></overloaded-function></namespace></namespace></header><header name="boost/proto/make_expr.hpp"><para>Definition of the <computeroutput>make_expr()</computeroutput> and <computeroutput>unpack_expr()</computeroutput> utilities for building Proto expression nodes from child nodes or from a Fusion sequence of child nodes, respectively. </para><namespace name="boost"><namespace name="proto"><namespace name="functor"><struct name="make_expr"><template>
+</para></description><returns><para>literal<T &>(t) </para></returns><throws><simpara>Will not throw.</simpara></throws><notes><para>The returned value holds the argument by reference. </para></notes></overloaded-function></namespace></namespace></header><header name="boost/proto/make_expr.hpp"><para>Definition of the <computeroutput>make_expr()</computeroutput> and <computeroutput>unpack_expr()</computeroutput> utilities for building Proto expression nodes from child nodes or from a Fusion sequence of child nodes, respectively. </para><namespace name="boost"><namespace name="proto"><struct name="_make_expr"><template>
+ <template-type-parameter name="Tag"/>
+ <template-type-parameter name="Domain"><default>deduce_domain</default></template-type-parameter>
+ </template><inherit access="public">boost::proto::callable</inherit><purpose>TODO document me. </purpose><struct name="result"><template>
+ <template-type-parameter name="Sig"/>
+ </template></struct><method-group name="public member functions"><method name="operator()" cv="const"><type><emphasis>unspecified</emphasis></type><template>
+ <template-type-parameter name="A0"/>
+ </template><parameter name="a0"><paramtype>A0 &</paramtype></parameter></method><method name="operator()" cv="const"><type><emphasis>unspecified</emphasis></type><template>
+ <template-type-parameter name="A0"/>
+ <template-type-parameter name="A1"/>
+ </template><parameter name="a0"><paramtype>A0 &</paramtype></parameter><parameter name="a1"><paramtype>A1 &</paramtype></parameter></method><method name="operator()" cv="const"><type><emphasis>unspecified</emphasis></type><template>
+ <template-type-parameter name="A0"/>
+ <template-type-parameter name="A1"/>
+ <template-type-parameter name="A2"/>
+ </template><parameter name="a0"><paramtype>A0 &</paramtype></parameter><parameter name="a1"><paramtype>A1 &</paramtype></parameter><parameter name="a2"><paramtype>A2 &</paramtype></parameter></method><method name="operator()" cv="const"><type><emphasis>unspecified</emphasis></type><template>
+ <template-type-parameter name="A0"/>
+ <template-type-parameter name="A1"/>
+ <template-type-parameter name="A2"/>
+ <template-type-parameter name="A3"/>
+ </template><parameter name="a0"><paramtype>A0 &</paramtype></parameter><parameter name="a1"><paramtype>A1 &</paramtype></parameter><parameter name="a2"><paramtype>A2 &</paramtype></parameter><parameter name="a3"><paramtype>A3 &</paramtype></parameter></method><method name="operator()" cv="const"><type><emphasis>unspecified</emphasis></type><template>
+ <template-type-parameter name="A0"/>
+ <template-type-parameter name="A1"/>
+ <template-type-parameter name="A2"/>
+ <template-type-parameter name="A3"/>
+ <template-type-parameter name="A4"/>
+ </template><parameter name="a0"><paramtype>A0 &</paramtype></parameter><parameter name="a1"><paramtype>A1 &</paramtype></parameter><parameter name="a2"><paramtype>A2 &</paramtype></parameter><parameter name="a3"><paramtype>A3 &</paramtype></parameter><parameter name="a4"><paramtype>A4 &</paramtype></parameter></method></method-group></struct><namespace name="functional"><struct name="make_expr"><template>
       <template-type-parameter name="Tag"/>
       <template-type-parameter name="Domain"><default>deduce_domain</default></template-type-parameter>
- </template><purpose>A callable function object equivalent to the <computeroutput>proto::make_expr()</computeroutput> function. </purpose><description><para>In all cases, <computeroutput>functor::make_expr<Tag, Domain>()(a0, ... aN)</computeroutput> is equivalent to <computeroutput>proto::make_expr<Tag, Domain>(a0, ... aN)</computeroutput>.</para><para><computeroutput>functor::make_expr<Tag>()(a0, ... aN)</computeroutput> is equivalent to <computeroutput>proto::make_expr<Tag>(a0, ... aN)</computeroutput>. </para></description><struct-specialization name="result"><template>
+ </template><purpose>A callable function object equivalent to the <computeroutput>proto::make_expr()</computeroutput> function. </purpose><description><para>In all cases, <computeroutput>functional::make_expr<Tag, Domain>()(a0, ... aN)</computeroutput> is equivalent to <computeroutput>proto::make_expr<Tag, Domain>(a0, ... aN)</computeroutput>.</para><para><computeroutput>functional::make_expr<Tag>()(a0, ... aN)</computeroutput> is equivalent to <computeroutput>proto::make_expr<Tag>(a0, ... aN)</computeroutput>. </para></description><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="A0"/>
     </template><specialization><template-arg>This(A0)</template-arg></specialization><typedef name="type"><type><classname>result_of::make_expr</classname>< Tag, Domain, A0 >::type</type></typedef></struct-specialization><struct-specialization name="result"><template>
@@ -859,7 +1283,7 @@
         </template><parameter name="a0"><paramtype>const A0 &</paramtype></parameter><parameter name="a1"><paramtype>const A1 &</paramtype></parameter><parameter name="a2"><paramtype>const A2 &</paramtype></parameter><parameter name="a3"><paramtype>const A3 &</paramtype></parameter><parameter name="a4"><paramtype>const A4 &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method></method-group></struct><struct name="unpack_expr"><template>
       <template-type-parameter name="Tag"/>
       <template-type-parameter name="Domain"><default>deduce_domain</default></template-type-parameter>
- </template><purpose>A callable function object equivalent to the <computeroutput>proto::unpack_expr()</computeroutput> function. </purpose><description><para>In all cases, <computeroutput>functor::unpack_expr<Tag, Domain>()(seq)</computeroutput> is equivalent to <computeroutput>proto::unpack_expr<Tag, Domain>(seq)</computeroutput>.</para><para><computeroutput>functor::unpack_expr<Tag>()(seq)</computeroutput> is equivalent to <computeroutput>proto::unpack_expr<Tag>(seq)</computeroutput>. </para></description><struct name="result"><template>
+ </template><purpose>A callable function object equivalent to the <computeroutput>proto::unpack_expr()</computeroutput> function. </purpose><description><para>In all cases, <computeroutput>functional::unpack_expr<Tag, Domain>()(seq)</computeroutput> is equivalent to <computeroutput>proto::unpack_expr<Tag, Domain>(seq)</computeroutput>.</para><para><computeroutput>functional::unpack_expr<Tag>()(seq)</computeroutput> is equivalent to <computeroutput>proto::unpack_expr<Tag>(seq)</computeroutput>. </para></description><struct name="result"><template>
       <template-type-parameter name="Sig"/>
     </template></struct><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
@@ -887,7 +1311,7 @@
       <template-type-parameter name="A4"/>
     </template><specialization><template-arg>Tag</template-arg><template-arg>Domain</template-arg><template-arg>A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3</template-arg><template-arg>A4</template-arg><template-arg>typename Domain::proto_is_domain_</template-arg></specialization><purpose>Metafunction that computes the return type of the <computeroutput>make_expr()</computeroutput> function, within the specified domain. </purpose><description><para>Use the <computeroutput>result_of::make_expr<></computeroutput> metafunction to compute the return type of the <computeroutput>make_expr()</computeroutput> function. </para></description><typedef name="type"><description><para>If <computeroutput>Tag</computeroutput> is <computeroutput>tag::terminal</computeroutput>, then <computeroutput>type</computeroutput> is a typedef for <computeroutput>boost::result_of<Domain(expr<tag::terminal, term<A0> >)>::type</computeroutput>.</para><para>Otherwi
se, <computeroutput>type</computeroutput> is a typedef for <computeroutput>boost::result_of<Domain(expr<Tag, listN< as_child<A0>::type, ... as_child<AN>::type>) >::type</computeroutput>, where <computeroutput>N</computeroutput> is the number of non-void template arguments, and <computeroutput>as_child<A>::type</computeroutput> is evaluated as follows:</para><para><itemizedlist>
<listitem><para>If <computeroutput>is_expr<A>::value</computeroutput> is <computeroutput>true</computeroutput>, then the child type is <computeroutput>A</computeroutput>. </para></listitem>
-<listitem><para>If <computeroutput>A</computeroutput> is <computeroutput>B &</computeroutput> or <computeroutput>cv boost::reference_wrapper<B></computeroutput>, and <computeroutput>is_expr<B>::value</computeroutput> is <computeroutput>true</computeroutput>, then the child type is <computeroutput>ref_<B></computeroutput>. </para></listitem>
+<listitem><para>If <computeroutput>A</computeroutput> is <computeroutput>B &</computeroutput> or <computeroutput>cv boost::reference_wrapper<B></computeroutput>, and <computeroutput>is_expr<B>::value</computeroutput> is <computeroutput>true</computeroutput>, then the child type is <computeroutput>B &</computeroutput>. </para></listitem>
<listitem><para>If <computeroutput>is_expr<A>::value</computeroutput> is <computeroutput>false</computeroutput>, then the child type is <computeroutput>boost::result_of<Domain(expr<tag::terminal, term<A> > )>::type</computeroutput>. </para></listitem>
<listitem><para>If <computeroutput>A</computeroutput> is <computeroutput>B &</computeroutput> or <computeroutput>cv boost::reference_wrapper<B></computeroutput>, and <computeroutput>is_expr<B>::value</computeroutput> is <computeroutput>false</computeroutput>, then the child type is <computeroutput>boost::result_of<Domain(expr<tag::terminal, term<B &> > )>::type</computeroutput>. </para></listitem>
</itemizedlist>
@@ -975,23 +1399,18 @@

</para></description><returns><para><computeroutput>Domain()(make_<Tag>(wrap_<0>(s),...wrap_<N-1>(S)))</computeroutput>, where N is the size of <computeroutput>Sequence</computeroutput>. </para></returns></overloaded-function></namespace></namespace></header><header name="boost/proto/matches.hpp"><para>Contains definition of matches<> metafunction for determining if a given expression matches a given pattern. </para><namespace name="boost"><namespace name="proto"><namespace name="control"><struct name="not_"><template>
       <template-type-parameter name="Grammar"/>
- </template><inherit access="public">boost::proto::callable</inherit><purpose>Inverts the set of expressions matched by a grammar. When used as a transform, <computeroutput>not_<></computeroutput> returns the current expression unchanged. </purpose><description><para>If an expression type <computeroutput>E</computeroutput> does not match a grammar <computeroutput>G</computeroutput>, then <computeroutput>E</computeroutput> does match <computeroutput>not_<G></computeroutput>. For example, <computeroutput>not_<terminal<_> ></computeroutput> will match any non-terminal. </para></description><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+ </template><inherit access="public">transform< boost::proto::control::not_< Grammar > ></inherit><purpose>Inverts the set of expressions matched by a grammar. When used as a transform, <computeroutput>not_<></computeroutput> returns the current expression unchanged. </purpose><description><para>If an expression type <computeroutput>E</computeroutput> does not match a grammar <computeroutput>G</computeroutput>, then <computeroutput>E</computeroutput> does match <computeroutput>not_<G></computeroutput>. For example, <computeroutput>not_<terminal<_> ></computeroutput> will match any non-terminal. </para></description><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Data"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Data)</template-arg></specialization><typedef name="type"><type>Expr</type></typedef></struct-specialization><typedef name="proto_base_expr"><type><classname>not_</classname></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>Expr const &</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>An expression </para></description></parameter><parameter name=""><paramtype>State const &</paramtype></parameter><parameter name=""><paramtype>Data &</paramtype></parameter><description><para>
+ </template><typedef name="result_type"><type>Expr</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>impl::expr_param</type><parameter name="expr"><paramtype>typename impl::expr_param</paramtype><description><para>An expression </para></description></parameter><parameter name=""><paramtype>typename impl::state_param</paramtype></parameter><parameter name=""><paramtype>typename impl::data_param</paramtype></parameter><description><para>

-</para></description><requires><para><computeroutput>matches<Expr,not_>::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>expr</computeroutput> </para></returns></method></method-group></struct><struct name="if_"><template>
+</para></description><requires><para><computeroutput>matches<Expr,not_>::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>expr</computeroutput> </para></returns></method></method-group></struct><typedef name="proto_base_expr"><type><classname>not_</classname></type></typedef></struct><struct name="if_"><template>
       <template-type-parameter name="If"/>
       <template-type-parameter name="Then"><default>_</default></template-type-parameter>
       <template-type-parameter name="Else"><default>not_<_></default></template-type-parameter>
- </template><inherit access="public">boost::proto::callable</inherit><purpose>Used to select one grammar or another based on the result of a compile-time Boolean. When used as a transform, <computeroutput>if_<></computeroutput> selects between two transforms based on a compile-time Boolean. </purpose><description><para>When <computeroutput>if_<If,Then,Else></computeroutput> is used as a grammar, <computeroutput>If</computeroutput> must be a Proto transform and <computeroutput>Then</computeroutput> and <computeroutput>Else</computeroutput> must be grammars. An expression type <computeroutput>E</computeroutput> matches <computeroutput>if_<If,Then,Else></computeroutput> if <computeroutput>when<_,If>::result<void(E,int,int)>::type::value</computeroutput> is <computeroutput>true</computeroutput> and <computeroutput>E</computeroutput> matches <computeroutput>U</computeroutput>; or, if <computeroutput>when<_,If>::result<void(E,int,int)>::type::value</computeroutput> is
<computeroutput>false</computeroutput> and <computeroutput>E</computeroutput> matches <computeroutput>V</computeroutput>.</para><para>The template parameter <computeroutput>Then</computeroutput> defaults to <computeroutput>_</computeroutput> and <computeroutput>Else</computeroutput> defaults to <computeroutput>not<_></computeroutput>, so an expression type <computeroutput>E</computeroutput> will match <computeroutput>if_<If></computeroutput> if and only if <computeroutput>when<_,If>::result<void(E,int,int)>::type::value</computeroutput> is <computeroutput>true</computeroutput>.</para><para><programlisting> // A grammar that only matches integral terminals,
+ </template><inherit access="public">transform< boost::proto::control::if_< If, Then, Else > ></inherit><purpose>Used to select one grammar or another based on the result of a compile-time Boolean. When used as a transform, <computeroutput>if_<></computeroutput> selects between two transforms based on a compile-time Boolean. </purpose><description><para>When <computeroutput>if_<If,Then,Else></computeroutput> is used as a grammar, <computeroutput>If</computeroutput> must be a Proto transform and <computeroutput>Then</computeroutput> and <computeroutput>Else</computeroutput> must be grammars. An expression type <computeroutput>E</computeroutput> matches <computeroutput>if_<If,Then,Else></computeroutput> if <computeroutput>when<_,If>::result<void(E,int,int)>::type::value</computeroutput> is <computeroutput>true</computeroutput> and <computeroutput>E</computeroutput> matches <computeroutput>U</computeroutput>; or, if <computeroutput>when<_,If>::result<void(E
,int,int)>::type::value</computeroutput> is <computeroutput>false</computeroutput> and <computeroutput>E</computeroutput> matches <computeroutput>V</computeroutput>.</para><para>The template parameter <computeroutput>Then</computeroutput> defaults to <computeroutput>_</computeroutput> and <computeroutput>Else</computeroutput> defaults to <computeroutput>not<_></computeroutput>, so an expression type <computeroutput>E</computeroutput> will match <computeroutput>if_<If></computeroutput> if and only if <computeroutput>when<_,If>::result<void(E,int,int)>::type::value</computeroutput> is <computeroutput>true</computeroutput>.</para><para><programlisting> // A grammar that only matches integral terminals,
  // using is_integral<> from Boost.Type_traits.
  struct IsIntegral
    : and_<
@@ -1011,18 +1430,13 @@
          >
      >
  {};
-</programlisting> </para></description><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+</programlisting> </para></description><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Data"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Data)</template-arg></specialization><typedef name="condition"><type><classname>when</classname>< _, If >::template result< void(Expr, State, Data)>::type</type></typedef><typedef name="which"><type>mpl::if_< condition, <classname>when</classname>< _, Then >, <classname>when</classname>< _, Else >>::type</type></typedef><typedef name="type"><type>which::template result< void(Expr, State, Data)>::type</type></typedef></struct-specialization><typedef name="proto_base_expr"><type><classname>if_</classname></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>An expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>A data of arbitrary type </para></description></parameter><description><para>
+ </template><typedef name="condition"><type><classname>when</classname>< _, If >::template <classname>impl</classname>< Expr, State, Data >::result_type</type></typedef><typedef name="which"><type>mpl::if_c< remove_reference< condition >::type::value, <classname>when</classname>< _, Then >, <classname>when</classname>< _, Else >>::type</type></typedef><typedef name="result_type"><type>which::template <classname>impl</classname>< Expr, State, Data >::result_type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl::expr_param</paramtype><description><para>An expression </para></description></parameter><parameter name="state"><paramtype>typename impl::state_param</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>typename impl::data_param</paramtype><description><para>A data of arbitrary
type </para></description></parameter><description><para>

-</para></description><returns><para><computeroutput>result<void(Expr, State, Data)>::which()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="or_"><template>
+</para></description><returns><para><computeroutput>which::impl<Expr, State, Data>()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><typedef name="proto_base_expr"><type><classname>if_</classname></type></typedef></struct><struct name="or_"><template>
       <template-type-parameter name="G0"/>
       <template-type-parameter name="G1"/>
       <template-type-parameter name="G2"/>
@@ -1031,19 +1445,18 @@
       <template-type-parameter name="G5"/>
       <template-type-parameter name="G6"/>
       <template-type-parameter name="G7"/>
- </template><inherit access="public">boost::proto::callable</inherit><purpose>For matching one of a set of alternate grammars. Alternates tried in order to avoid ambiguity. When used as a transform, <computeroutput>or_<></computeroutput> applies the transform associated with the first grammar that matches the expression. </purpose><description><para>An expression type <computeroutput>E</computeroutput> matches <computeroutput>or_<B0,B1,...Bn></computeroutput> if <computeroutput>E</computeroutput> matches any <computeroutput>Bx</computeroutput> for <computeroutput>x</computeroutput> in <computeroutput>[0,n)</computeroutput>.</para><para>When applying <computeroutput>or_<B0,B1,...Bn></computeroutput> as a transform with an expression <computeroutput>e</computeroutput> of type <computeroutput>E</computeroutput>, state <computeroutput>s</computeroutput> and data <computeroutput>v</computeroutput>, it is equivalent to <computeroutput>Bx()(e, s, v)</computeroutput>, where <computeroutput>x</c
omputeroutput> is the lowest number such that <computeroutput>matches<E,Bx>::value</computeroutput> is <computeroutput>true</computeroutput>. </para></description><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+ </template><inherit access="public">transform< boost::proto::control::or_< G0, G1, G2, G3, G4, G5, G6, G7 > ></inherit><purpose>For matching one of a set of alternate grammars. Alternates tried in order to avoid ambiguity. When used as a transform, <computeroutput>or_<></computeroutput> applies the transform associated with the first grammar that matches the expression. </purpose><description><para>An expression type <computeroutput>E</computeroutput> matches <computeroutput>or_<B0,B1,...Bn></computeroutput> if <computeroutput>E</computeroutput> matches any <computeroutput>Bx</computeroutput> for <computeroutput>x</computeroutput> in <computeroutput>[0,n)</computeroutput>.</para><para>When applying <computeroutput>or_<B0,B1,...Bn></computeroutput> as a transform with an expression <computeroutput>e</computeroutput> of type <computeroutput>E</computeroutput>, state <computeroutput>s</computeroutput> and data <computeroutput>v</computeroutput>, it is equivalent to <computerou
tput>Bx()(e, s, v)</computeroutput>, where <computeroutput>x</computeroutput> is the lowest number such that <computeroutput>matches<E,Bx>::value</computeroutput> is <computeroutput>true</computeroutput>. </para></description><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Data"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Data)</template-arg></specialization><typedef name="which"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="type"><type>which::template result< void(Expr, State, Data)>::type</type></typedef></struct-specialization><typedef name="proto_base_expr"><type><classname>or_</classname></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>An expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>A data of arbitrary type </para></description></parameter><description><para>
+ </template><description><para>

-</para></description><requires><para><computeroutput>matches<Expr,or_>::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>result<void(Expr, State, Data)>::which()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="and_"><template>
+</para></description></struct><struct-specialization name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr &</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg></specialization></struct-specialization><typedef name="proto_base_expr"><type><classname>or_</classname></type></typedef></struct><struct name="and_"><template>
       <template-type-parameter name="G0"/>
       <template-type-parameter name="G1"/>
       <template-type-parameter name="G2"/>
@@ -1052,34 +1465,25 @@
       <template-type-parameter name="G5"/>
       <template-type-parameter name="G6"/>
       <template-type-parameter name="G7"/>
- </template><inherit access="public">boost::proto::callable</inherit><purpose>For matching all of a set of grammars. When used as a transform, <computeroutput>and_<></computeroutput> applies the transform associated with the last grammar in the set. </purpose><description><para>An expression type <computeroutput>E</computeroutput> matches <computeroutput>and_<B0,B1,...Bn></computeroutput> if <computeroutput>E</computeroutput> matches all <computeroutput>Bx</computeroutput> for <computeroutput>x</computeroutput> in <computeroutput>[0,n)</computeroutput>.</para><para>When applying <computeroutput>and_<B0,B1,...Bn></computeroutput> as a transform with an expression <computeroutput>e</computeroutput>, state <computeroutput>s</computeroutput> and data <computeroutput>v</computeroutput>, it is equivalent to <computeroutput>Bn()(e, s, v)</computeroutput>. </para></description><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+ </template><inherit access="public">transform< boost::proto::control::and_< G0, G1, G2, G3, G4, G5, G6, G7 > ></inherit><purpose>For matching all of a set of grammars. When used as a transform, <computeroutput>and_<></computeroutput> applies the transform associated with the last grammar in the set. </purpose><description><para>An expression type <computeroutput>E</computeroutput> matches <computeroutput>and_<B0,B1,...Bn></computeroutput> if <computeroutput>E</computeroutput> matches all <computeroutput>Bx</computeroutput> for <computeroutput>x</computeroutput> in <computeroutput>[0,n)</computeroutput>.</para><para>When applying <computeroutput>and_<B0,B1,...Bn></computeroutput> as a transform with an expression <computeroutput>e</computeroutput>, state <computeroutput>s</computeroutput> and data <computeroutput>v</computeroutput>, it is equivalent to <computeroutput>Bn()(e, s, v)</computeroutput>. </para></description><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Data"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Data)</template-arg></specialization><typedef name="which"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="type"><type>which::template result< void(Expr, State, Data)>::type</type></typedef></struct-specialization><typedef name="proto_base_expr"><type><classname>and_</classname></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>An expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>A data of arbitrary type </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr,and_>::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>result<void(Expr, State, Data)>::which()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="switch_"><template>
+ </template></struct><typedef name="proto_base_expr"><type><classname>and_</classname></type></typedef></struct><struct name="switch_"><template>
       <template-type-parameter name="Cases"/>
- </template><inherit access="public">boost::proto::callable</inherit><purpose>For matching one of a set of alternate grammars, which are looked up based on an expression's tag type. When used as a transform, <computeroutput>switch_<></computeroutput> applies the transform associated with the grammar that matches the expression. </purpose><description><para>
-An expression type <computeroutput>E</computeroutput> matches <computeroutput>switch_<C></computeroutput> if <computeroutput>E</computeroutput> matches <computeroutput>C::case_<E::proto_tag></computeroutput>.</para><para>When applying <computeroutput>switch_<C></computeroutput> as a transform with an expression <computeroutput>e</computeroutput> of type <computeroutput>E</computeroutput>, state <computeroutput>s</computeroutput> and data <computeroutput>v</computeroutput>, it is equivalent to <computeroutput>C::case_<E::proto_tag>()(e, s, v)</computeroutput>. </para></description><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+ </template><inherit access="public">transform< boost::proto::control::switch_< Cases > ></inherit><purpose>For matching one of a set of alternate grammars, which are looked up based on an expression's tag type. When used as a transform, <computeroutput>switch_<></computeroutput> applies the transform associated with the grammar that matches the expression. </purpose><description><para>
+An expression type <computeroutput>E</computeroutput> matches <computeroutput>switch_<C></computeroutput> if <computeroutput>E</computeroutput> matches <computeroutput>C::case_<E::proto_tag></computeroutput>.</para><para>When applying <computeroutput>switch_<C></computeroutput> as a transform with an expression <computeroutput>e</computeroutput> of type <computeroutput>E</computeroutput>, state <computeroutput>s</computeroutput> and data <computeroutput>v</computeroutput>, it is equivalent to <computeroutput>C::case_<E::proto_tag>()(e, s, v)</computeroutput>. </para></description><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Data"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Data)</template-arg></specialization><typedef name="which"><type>Cases::template case_< typename Expr::proto_tag ></type></typedef><typedef name="type"><type>which::template result< void(Expr, State, Data)>::type</type></typedef></struct-specialization><typedef name="proto_base_expr"><type><classname>switch_</classname></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>An expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>A data of arbitrary type </para></description></parameter><description><para>
+ </template><description><para>

-</para></description><requires><para><computeroutput>matches<Expr,switch_>::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>result<void(Expr, State, Data)>::which()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="exact"><template>
+</para></description></struct><struct-specialization name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr &</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg></specialization></struct-specialization><typedef name="proto_base_expr"><type><classname>switch_</classname></type></typedef></struct><struct name="exact"><template>
       <template-type-parameter name="T"/>
     </template><purpose>For forcing exact matches of terminal types. </purpose><description><para>By default, matching terminals ignores references and cv-qualifiers. For instance, a terminal expression of type <computeroutput>terminal<int const &>::type</computeroutput> will match the grammar <computeroutput>terminal<int></computeroutput>. If that is not desired, you can force an exact match with <computeroutput>terminal<exact<int> ></computeroutput>. This will only match integer terminals where the terminal is held by value. </para></description></struct><struct name="convertible_to"><template>
       <template-type-parameter name="T"/>
@@ -1121,7 +1525,10 @@
<listitem><para><computeroutput>B</computeroutput> is the wildcard pattern, <computeroutput>_</computeroutput> </para></listitem>
<listitem><para><computeroutput>B</computeroutput> is <computeroutput>T<B0,B1,...Bn></computeroutput> and <computeroutput>A</computeroutput> is <computeroutput>T<A0,A1,...An></computeroutput> and for each <computeroutput>x</computeroutput> in <computeroutput>[0,n)</computeroutput>, <computeroutput>Ax</computeroutput> and <computeroutput>Bx</computeroutput> are types such that <computeroutput>Ax</computeroutput> lambda-matches <computeroutput>Bx</computeroutput> </para></listitem>
</itemizedlist>
-</para></description></struct></namespace><namespace name="wildcardns_"><struct name="_"><inherit access="public">boost::proto::callable</inherit><purpose>A wildcard grammar element that matches any expression, and a transform that returns the current expression unchanged. </purpose><description><para>The wildcard type, <computeroutput>_</computeroutput>, is a grammar element such that <computeroutput>matches<E,_>::value</computeroutput> is <computeroutput>true</computeroutput> for any expression type <computeroutput>E</computeroutput>.</para><para>The wildcard can also be used as a stand-in for a template argument when matching terminals. For instance, the following is a grammar that will match any <computeroutput>std::complex<></computeroutput> terminal:</para><para><programlisting> BOOST_MPL_ASSERT((
+</para></description></struct><struct-specialization name="matches"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="Grammar"/>
+ </template><specialization><template-arg>Expr &</template-arg><template-arg>Grammar</template-arg></specialization></struct-specialization></namespace><namespace name="wildcardns_"><struct name="_"><inherit access="public">transform< boost::proto::wildcardns_::_ ></inherit><purpose>A wildcard grammar element that matches any expression, and a transform that returns the current expression unchanged. </purpose><description><para>The wildcard type, <computeroutput>_</computeroutput>, is a grammar element such that <computeroutput>matches<E,_>::value</computeroutput> is <computeroutput>true</computeroutput> for any expression type <computeroutput>E</computeroutput>.</para><para>The wildcard can also be used as a stand-in for a template argument when matching terminals. For instance, the following is a grammar that will match any <computeroutput>std::complex<></computeroutput> terminal:</para><para><programlisting> BOOST_MPL_ASSERT((
      matches<
          terminal<std::complex<double> >::type
        , terminal<std::complex< _ > >
@@ -1141,18 +1548,13 @@
          >
      >
  {};
-</programlisting> </para></description><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+</programlisting> </para></description><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Data"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Data)</template-arg></specialization><typedef name="type"><type>Expr</type></typedef></struct-specialization><typedef name="proto_base_expr"><type><classname>_</classname></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>Expr const &</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>An expression </para></description></parameter><parameter name=""><paramtype>State const &</paramtype></parameter><parameter name=""><paramtype>Data &</paramtype></parameter><description><para>
+ </template><typedef name="result_type"><type>Expr</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>impl::expr_param</type><parameter name="expr"><paramtype>typename impl::expr_param</paramtype><description><para>An expression </para></description></parameter><parameter name=""><paramtype>typename impl::state_param</paramtype></parameter><parameter name=""><paramtype>typename impl::data_param</paramtype></parameter><description><para>

-</para></description><returns><para><computeroutput>expr</computeroutput> </para></returns></method></method-group></struct></namespace></namespace></namespace></header><header name="boost/proto/operators.hpp"><para>Contains all the overloaded operators that make it possible to build Proto expression trees. </para><namespace name="boost"><namespace name="proto"><struct name="is_extension"><template>
+</para></description><returns><para><computeroutput>expr</computeroutput> </para></returns></method></method-group></struct><typedef name="proto_base_expr"><type><classname>_</classname></type></typedef></struct></namespace></namespace></namespace></header><header name="boost/proto/operators.hpp"><para>Contains all the overloaded operators that make it possible to build Proto expression trees. </para><namespace name="boost"><namespace name="proto"><struct name="is_extension"><template>
       <template-type-parameter name="T"/>
     </template><inherit access="public">boost::mpl::false_</inherit></struct><function name="operator+"><type><emphasis>unspecified</emphasis></type><template>
           <template-type-parameter name="Arg"/>
@@ -1558,43 +1960,7 @@
           <template-type-parameter name="A0"/>
           <template-type-parameter name="A1"/>
           <template-type-parameter name="A2"/>
- </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 const &</paramtype></parameter><parameter name="a2"><paramtype>A2 const &</paramtype></parameter><description><para>if_else </para></description></function></namespace></namespace></header><header name="boost/proto/proto.hpp"><para>Includes all of Proto. </para></header><header name="boost/proto/proto_fwd.hpp"><para>Forward declarations of all of proto's public types and functions. </para><namespace name="boost"><namespace name="proto"><struct name="callable"><typedef name="proto_is_callable_"><type>void</type></typedef></struct><namespace name="context"/><namespace name="control"><data-member name="N"><type>int const</type></data-member></namespace><namespace name="exops"/><namespace name="functor"><typedef name="make_terminal"><type><classname>make_expr</classname>< <classname>tag::terminal</classname> ></type></typedef><typedef name="make_posit"><type><classname>make_e
xpr</classname>< <classname>tag::unary_plus</classname> ></type></typedef><typedef name="make_negate"><type><classname>make_expr</classname>< <classname>tag::negate</classname> ></type></typedef><typedef name="make_dereference"><type><classname>make_expr</classname>< <classname>tag::dereference</classname> ></type></typedef><typedef name="make_complement"><type><classname>make_expr</classname>< <classname>tag::complement</classname> ></type></typedef><typedef name="make_address_of"><type><classname>make_expr</classname>< <classname>tag::address_of</classname> ></type></typedef><typedef name="make_logical_not"><type><classname>make_expr</classname>< <classname>tag::logical_not</classname> ></type></typedef><typedef name="make_pre_inc"><type><classname>make_expr</classname>< <classname>tag::pre_inc</classname> ></type></typedef><typedef name="make_pre_dec"><type><classname>make_expr</classname>< <classname>tag::pre_dec</classname> ></type></typedef><typedef name=
"make_post_inc"><type><classname>make_expr</classname>< <classname>tag::post_inc</classname> ></type></typedef><typedef name="make_post_dec"><type><classname>make_expr</classname>< <classname>tag::post_dec</classname> ></type></typedef><typedef name="make_shift_left"><type><classname>make_expr</classname>< <classname>tag::shift_left</classname> ></type></typedef><typedef name="make_shift_right"><type><classname>make_expr</classname>< <classname>tag::shift_right</classname> ></type></typedef><typedef name="make_multiplies"><type><classname>make_expr</classname>< <classname>tag::multiplies</classname> ></type></typedef><typedef name="make_divides"><type><classname>make_expr</classname>< <classname>tag::divides</classname> ></type></typedef><typedef name="make_modulus"><type><classname>make_expr</classname>< <classname>tag::modulus</classname> ></type></typedef><typedef name="make_plus"><type><classname>make_expr</classname>< <classname>tag::plus</classname> ></ty
pe></typedef><typedef name="make_minus"><type><classname>make_expr</classname>< <classname>tag::minus</classname> ></type></typedef><typedef name="make_less"><type><classname>make_expr</classname>< <classname>tag::less</classname> ></type></typedef><typedef name="make_greater"><type><classname>make_expr</classname>< <classname>tag::greater</classname> ></type></typedef><typedef name="make_less_equal"><type><classname>make_expr</classname>< <classname>tag::less_equal</classname> ></type></typedef><typedef name="make_greater_equal"><type><classname>make_expr</classname>< <classname>tag::greater_equal</classname> ></type></typedef><typedef name="make_equal_to"><type><classname>make_expr</classname>< <classname>tag::equal_to</classname> ></type></typedef><typedef name="make_not_equal_to"><type><classname>make_expr</classname>< <classname>tag::not_equal_to</classname> ></type></typedef><typedef name="make_logical_or"><type><classname>make_expr</classname>< <classname>t
ag::logical_or</classname> ></type></typedef><typedef name="make_logical_and"><type><classname>make_expr</classname>< <classname>tag::logical_and</classname> ></type></typedef><typedef name="make_bitwise_and"><type><classname>make_expr</classname>< <classname>tag::bitwise_and</classname> ></type></typedef><typedef name="make_bitwise_or"><type><classname>make_expr</classname>< <classname>tag::bitwise_or</classname> ></type></typedef><typedef name="make_bitwise_xor"><type><classname>make_expr</classname>< <classname>tag::bitwise_xor</classname> ></type></typedef><typedef name="make_comma"><type><classname>make_expr</classname>< <classname>tag::comma</classname> ></type></typedef><typedef name="make_mem_ptr"><type><classname>make_expr</classname>< <classname>tag::mem_ptr</classname> ></type></typedef><typedef name="make_assign"><type><classname>make_expr</classname>< <classname>tag::assign</classname> ></type></typedef><typedef name="make_shift_left_assign"><type><cl
assname>make_expr</classname>< <classname>tag::shift_left_assign</classname> ></type></typedef><typedef name="make_shift_right_assign"><type><classname>make_expr</classname>< <classname>tag::shift_right_assign</classname> ></type></typedef><typedef name="make_multiplies_assign"><type><classname>make_expr</classname>< <classname>tag::multiplies_assign</classname> ></type></typedef><typedef name="make_divides_assign"><type><classname>make_expr</classname>< <classname>tag::divides_assign</classname> ></type></typedef><typedef name="make_modulus_assign"><type><classname>make_expr</classname>< <classname>tag::modulus_assign</classname> ></type></typedef><typedef name="make_plus_assign"><type><classname>make_expr</classname>< <classname>tag::plus_assign</classname> ></type></typedef><typedef name="make_minus_assign"><type><classname>make_expr</classname>< <classname>tag::minus_assign</classname> ></type></typedef><typedef name="make_bitwise_and_assign"><type><classname>mak
e_expr</classname>< <classname>tag::bitwise_and_assign</classname> ></type></typedef><typedef name="make_bitwise_or_assign"><type><classname>make_expr</classname>< <classname>tag::bitwise_or_assign</classname> ></type></typedef><typedef name="make_bitwise_xor_assign"><type><classname>make_expr</classname>< <classname>tag::bitwise_xor_assign</classname> ></type></typedef><typedef name="make_subscript"><type><classname>make_expr</classname>< <classname>tag::subscript</classname> ></type></typedef><typedef name="make_if_else"><type><classname>make_expr</classname>< <classname>tag::if_else_</classname> ></type></typedef><typedef name="make_function"><type><classname>make_expr</classname>< <classname>tag::function</classname> ></type></typedef></namespace><namespace name="op"/><namespace name="result_of"/><namespace name="tag"/><namespace name="utility"/><typedef name="_make_terminal"><type><classname>functor::make_terminal</classname></type></typedef><typedef name="_make_posit
"><type><classname>functor::make_posit</classname></type></typedef><typedef name="_make_negate"><type><classname>functor::make_negate</classname></type></typedef><typedef name="_make_dereference"><type><classname>functor::make_dereference</classname></type></typedef><typedef name="_make_complement"><type><classname>functor::make_complement</classname></type></typedef><typedef name="_make_address_of"><type><classname>functor::make_address_of</classname></type></typedef><typedef name="_make_logical_not"><type><classname>functor::make_logical_not</classname></type></typedef><typedef name="_make_pre_inc"><type><classname>functor::make_pre_inc</classname></type></typedef><typedef name="_make_pre_dec"><type><classname>functor::make_pre_dec</classname></type></typedef><typedef name="_make_post_inc"><type><classname>functor::make_post_inc</classname></type></typedef><typedef name="_make_post_dec"><type><classname>functor::make_post_dec</classname></type></typedef><typedef name="_make_shift_left"><type><classname>fun
ctor::make_shift_left</classname></type></typedef><typedef name="_make_shift_right"><type><classname>functor::make_shift_right</classname></type></typedef><typedef name="_make_multiplies"><type><classname>functor::make_multiplies</classname></type></typedef><typedef name="_make_divides"><type><classname>functor::make_divides</classname></type></typedef><typedef name="_make_modulus"><type><classname>functor::make_modulus</classname></type></typedef><typedef name="_make_plus"><type><classname>functor::make_plus</classname></type></typedef><typedef name="_make_minus"><type><classname>functor::make_minus</classname></type></typedef><typedef name="_make_less"><type><classname>functor::make_less</classname></type></typedef><typedef name="_make_greater"><type><classname>functor::make_greater</classname></type></typedef><typedef name="_make_less_equal"><type><classname>functor::make_less_equal</classname></type></typedef><typedef name="_make_greater_equal"><type><classname>functor::make_greater_equal</classname></ty
pe></typedef><typedef name="_make_equal_to"><type><classname>functor::make_equal_to</classname></type></typedef><typedef name="_make_not_equal_to"><type><classname>functor::make_not_equal_to</classname></type></typedef><typedef name="_make_logical_or"><type><classname>functor::make_logical_or</classname></type></typedef><typedef name="_make_logical_and"><type><classname>functor::make_logical_and</classname></type></typedef><typedef name="_make_bitwise_and"><type><classname>functor::make_bitwise_and</classname></type></typedef><typedef name="_make_bitwise_or"><type><classname>functor::make_bitwise_or</classname></type></typedef><typedef name="_make_bitwise_xor"><type><classname>functor::make_bitwise_xor</classname></type></typedef><typedef name="_make_comma"><type><classname>functor::make_comma</classname></type></typedef><typedef name="_make_mem_ptr"><type><classname>functor::make_mem_ptr</classname></type></typedef><typedef name="_make_assign"><type><classname>functor::make_assign</classname></type></typede
f><typedef name="_make_shift_left_assign"><type><classname>functor::make_shift_left_assign</classname></type></typedef><typedef name="_make_shift_right_assign"><type><classname>functor::make_shift_right_assign</classname></type></typedef><typedef name="_make_multiplies_assign"><type><classname>functor::make_multiplies_assign</classname></type></typedef><typedef name="_make_divides_assign"><type><classname>functor::make_divides_assign</classname></type></typedef><typedef name="_make_modulus_assign"><type><classname>functor::make_modulus_assign</classname></type></typedef><typedef name="_make_plus_assign"><type><classname>functor::make_plus_assign</classname></type></typedef><typedef name="_make_minus_assign"><type><classname>functor::make_minus_assign</classname></type></typedef><typedef name="_make_bitwise_and_assign"><type><classname>functor::make_bitwise_and_assign</classname></type></typedef><typedef name="_make_bitwise_or_assign"><type><classname>functor::make_bitwise_or_assign</classname></type></typede
f><typedef name="_make_bitwise_xor_assign"><type><classname>functor::make_bitwise_xor_assign</classname></type></typedef><typedef name="_make_subscript"><type><classname>functor::make_subscript</classname></type></typedef><typedef name="_make_if_else"><type><classname>functor::make_if_else</classname></type></typedef><typedef name="_make_function"><type><classname>functor::make_function</classname></type></typedef><typedef name="_flatten"><type><classname>functor::flatten</classname></type></typedef><typedef name="_pop_front"><type><classname>functor::pop_front</classname></type></typedef><typedef name="_reverse"><type><classname>functor::reverse</classname></type></typedef><typedef name="_eval"><type><classname>functor::deep_copy</classname></type></typedef><typedef name="_deep_copy"><type><classname>functor::deep_copy</classname></type></typedef><typedef name="_child0"><type><classname>_child_c</classname>< 0 ></type></typedef><typedef name="_child1"><type><classname>_child_c</classname>< 1 ></
type></typedef><typedef name="_child2"><type><classname>_child_c</classname>< 2 ></type></typedef><typedef name="_child"><type><classname>_child0</classname></type></typedef><typedef name="_value"><type><classname>_child0</classname></type></typedef><typedef name="_left"><type><classname>_child0</classname></type></typedef><typedef name="_right"><type><classname>_child1</classname></type></typedef><typedef name="_child3"><type><classname>_child_c</classname>< 3 ></type></typedef></namespace></namespace></header><header name="boost/proto/ref.hpp"><para>Utility for storing a sub-expr by reference </para><namespace name="boost"><namespace name="proto"><struct name="ref_"><template>
- <template-type-parameter name="Expr"/>
- </template><purpose>A simple reference wrapper for a Proto expression type, used by <computeroutput>expr<></computeroutput> to hold child expressions by reference. </purpose><description><para><computeroutput>ref_<></computeroutput> is used by <computeroutput>expr<></computeroutput> to hold child expression types by reference. It forwards enough of the child expression's interface so that <computeroutput>expr<></computeroutput> can handle children uniformly regardless of whether it is stored by reference or by value.</para><para>This type is largely an implementation detail. </para></description><typedef name="proto_base_expr"><type>Expr::proto_base_expr</type></typedef><typedef name="proto_tag"><type>Expr::proto_tag</type></typedef><typedef name="proto_args"><type>Expr::proto_args</type></typedef><typedef name="proto_arity"><type>Expr::proto_arity</type></typedef><typedef name="proto_domain"><type>Expr::proto_domain</type></typedef><typedef name="proto_is_ref_"><type>void</type>
</typedef><typedef name="proto_is_expr_"><type>void</type></typedef><typedef name="proto_derived_expr"><type>Expr</type></typedef><typedef name="proto_child0"><type>Expr::proto_child0</type></typedef><typedef name="proto_child1"><type>Expr::proto_child1</type></typedef><typedef name="proto_child2"><type>Expr::proto_child2</type></typedef><typedef name="proto_child3"><type>Expr::proto_child3</type></typedef><typedef name="proto_child4"><type>Expr::proto_child4</type></typedef><data-member name="expr"><type>Expr &</type></data-member><method-group name="public member functions"><method name="proto_base" cv="const"><type>mpl::if_c< is_const< Expr >::value, proto_base_expr const &, proto_base_expr & >::type</type></method></method-group><method-group name="public static functions"><method name="make" cv=""><type>static <classname>ref_</classname>< Expr ></type><parameter name="expr"><paramtype>Expr &</paramtype></parameter></method></method-group></struct><namespace name="functo
r"><struct name="unref"><purpose>A callable PolymorphicFunctionObject equivalent to the <computeroutput>proto::unref()</computeroutput> function that removes top-level reference wrappers. </purpose><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
- <template-type-parameter name="T"/>
- </template><specialization><template-arg>This(T)</template-arg></specialization><typedef name="uncvref_type"><type>boost::remove_const< typename boost::remove_reference< T >::type >::type</type></typedef><typedef name="type"><type><classname>result_of::unref</classname>< uncvref_type >::type</type></typedef></struct-specialization><typedef name="proto_is_callable_"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>T &</type><template>
- <template-type-parameter name="T"/>
- </template><parameter name="t"><paramtype>T &</paramtype><description><para>The object to unwrap </para></description></parameter><purpose>Remove a top-level <computeroutput>ref_<></computeroutput> reference wrapper, if it exists. </purpose><description><para>
-
-</para></description><returns><para>If <computeroutput>T</computeroutput> t is a <computeroutput>ref_<></computeroutput>, return <computeroutput>t.expr</computeroutput>. Otherwise, return <computeroutput>t</computeroutput>. </para></returns></method><method name="operator()" cv="const"><type>T const &</type><template>
- <template-type-parameter name="T"/>
- </template><parameter name="t"><paramtype>T const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type>T &</type><template>
- <template-type-parameter name="T"/>
- </template><parameter name="t"><paramtype><classname>ref_</classname>< T > &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method><method name="operator()" cv="const"><type>T &</type><template>
- <template-type-parameter name="T"/>
- </template><parameter name="t"><paramtype><classname>ref_</classname>< T > const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method></method-group></struct></namespace><namespace name="result_of"><struct name="unref"><template>
- <template-type-parameter name="T"/>
- </template><purpose>Trait for stripping top-level references and reference wrappers. </purpose><typedef name="type"><purpose>Suitable for return by value. </purpose><type>T</type></typedef><typedef name="reference"><purpose>Suitable for return by reference. </purpose><type>T &</type></typedef><typedef name="const_reference"><purpose>Suitable for return by const reference. </purpose><type>T const &</type></typedef></struct><struct-specialization name="unref"><template>
- <template-type-parameter name="T"/>
- </template><specialization><template-arg>ref_< T ></template-arg></specialization><purpose>Trait for stripping top-level references and reference wrappers. </purpose><typedef name="type"><purpose>Suitable for return by value. </purpose><type>T</type></typedef><typedef name="reference"><purpose>Suitable for return by reference. </purpose><type>T &</type></typedef><typedef name="const_reference"><purpose>Suitable for return by const reference. </purpose><type>T &</type></typedef></struct-specialization><struct-specialization name="unref"><template>
- <template-type-parameter name="T"/>
- </template><specialization><template-arg>ref_< T const ></template-arg></specialization><purpose>Trait for stripping top-level references and reference wrappers. </purpose><typedef name="type"><purpose>Suitable for return by value. </purpose><type>T</type></typedef><typedef name="reference"><purpose>Suitable for return by reference. </purpose><type>T const &</type></typedef><typedef name="const_reference"><purpose>Suitable for return by const reference. </purpose><type>T const &</type></typedef></struct-specialization><struct-specialization name="unref"><template>
- <template-type-parameter name="T"/>
- </template><specialization><template-arg>T &</template-arg></specialization><purpose>Trait for stripping top-level references and reference wrappers. </purpose><typedef name="type"><purpose>Suitable for return by value. </purpose><type>T</type></typedef><typedef name="reference"><purpose>Suitable for return by reference. </purpose><type>T &</type></typedef><typedef name="const_reference"><purpose>Suitable for return by const reference. </purpose><type>T &</type></typedef></struct-specialization><struct-specialization name="unref"><template>
- <template-type-parameter name="T"/>
- </template><specialization><template-arg>T const &</template-arg></specialization><purpose>Trait for stripping top-level references and reference wrappers. </purpose><typedef name="type"><purpose>Suitable for return by value. </purpose><type>T</type></typedef><typedef name="reference"><purpose>Suitable for return by reference. </purpose><type>T const &</type></typedef><typedef name="const_reference"><purpose>Suitable for return by const reference. </purpose><type>T const &</type></typedef></struct-specialization></namespace><overloaded-function name="unref"><signature><type>T &</type><template>
- <template-type-parameter name="T"/>
- </template><parameter name="t"><paramtype>T &</paramtype><description><para>The object to unwrap </para></description></parameter></signature><signature><type>T const &</type><template>
- <template-type-parameter name="T"/>
- </template><parameter name="t"><paramtype>T const &</paramtype></parameter></signature><signature><type>T &</type><template>
- <template-type-parameter name="T"/>
- </template><parameter name="t"><paramtype><classname>ref_</classname>< T > &</paramtype></parameter></signature><signature><type>T &</type><template>
- <template-type-parameter name="T"/>
- </template><parameter name="t"><paramtype><classname>ref_</classname>< T > const &</paramtype></parameter></signature><purpose>Remove a top-level <computeroutput>ref_<></computeroutput> reference wrapper, if it exists. </purpose><description><para>
-
-
-</para></description><returns><para>If <computeroutput>T</computeroutput> t is a <computeroutput>ref_<></computeroutput>, return <computeroutput>t.expr</computeroutput>. Otherwise, return <computeroutput>t</computeroutput>. </para></returns><throws><simpara>Will not throw.</simpara></throws></overloaded-function></namespace></namespace></header><header name="boost/proto/tags.hpp"><para>Contains the tags for all the overloadable operators in C++ </para><namespace name="boost"><namespace name="proto"><namespace name="tag"><struct name="terminal"><purpose>Tag type for terminals; aka, leaves in the expression tree. </purpose></struct><struct name="unary_plus"><purpose>Tag type for the unary + operator. </purpose></struct><struct name="negate"><purpose>Tag type for the unary - operator. </purpose></struct><struct name="dereference"><purpose>Tag type for the unary * operator. </purpose></struct><struct name="complement"><purpose>Tag type for the unary ~ operator. </purpose></struct><struct name="address_of"
><purpose>Tag type for the unary & operator. </purpose></struct><struct name="logical_not"><purpose>Tag type for the unary ! operator. </purpose></struct><struct name="pre_inc"><purpose>Tag type for the unary prefix ++ operator. </purpose></struct><struct name="pre_dec"><purpose>Tag type for the unary prefix -- operator. </purpose></struct><struct name="post_inc"><purpose>Tag type for the unary postfix ++ operator. </purpose></struct><struct name="post_dec"><purpose>Tag type for the unary postfix -- operator. </purpose></struct><struct name="shift_left"><purpose>Tag type for the binary << operator. </purpose></struct><struct name="shift_right"><purpose>Tag type for the binary >> operator. </purpose></struct><struct name="multiplies"><purpose>Tag type for the binary * operator. </purpose></struct><struct name="divides"><purpose>Tag type for the binary / operator. </purpose></struct><struct name="modulus"><purpose>Tag type for the binary % operator. </purpose></struct><struct name="plus"><purpo
se>Tag type for the binary + operator. </purpose></struct><struct name="minus"><purpose>Tag type for the binary - operator. </purpose></struct><struct name="less"><purpose>Tag type for the binary < operator. </purpose></struct><struct name="greater"><purpose>Tag type for the binary > operator. </purpose></struct><struct name="less_equal"><purpose>Tag type for the binary <= operator. </purpose></struct><struct name="greater_equal"><purpose>Tag type for the binary >= operator. </purpose></struct><struct name="equal_to"><purpose>Tag type for the binary == operator. </purpose></struct><struct name="not_equal_to"><purpose>Tag type for the binary != operator. </purpose></struct><struct name="logical_or"><purpose>Tag type for the binary || operator. </purpose></struct><struct name="logical_and"><purpose>Tag type for the binary && operator. </purpose></struct><struct name="bitwise_and"><purpose>Tag type for the binary & operator. </purpose></struct><struct name="bitwise_or"><purpose>Tag type
for the binary | operator. </purpose></struct><struct name="bitwise_xor"><purpose>Tag type for the binary ^ operator. </purpose></struct><struct name="comma"><purpose>Tag type for the binary , operator. </purpose></struct><struct name="mem_ptr"><purpose>Tag type for the binary ->* operator. </purpose></struct><struct name="assign"><purpose>Tag type for the binary = operator. </purpose></struct><struct name="shift_left_assign"><purpose>Tag type for the binary <<= operator. </purpose></struct><struct name="shift_right_assign"><purpose>Tag type for the binary >>= operator. </purpose></struct><struct name="multiplies_assign"><purpose>Tag type for the binary *= operator. </purpose></struct><struct name="divides_assign"><purpose>Tag type for the binary /= operator. </purpose></struct><struct name="modulus_assign"><purpose>Tag type for the binary = operator. </purpose></struct><struct name="plus_assign"><purpose>Tag type for the binary += operator. </purpose></struct><struct name="minus_assign"><purp
ose>Tag type for the binary -= operator. </purpose></struct><struct name="bitwise_and_assign"><purpose>Tag type for the binary &= operator. </purpose></struct><struct name="bitwise_or_assign"><purpose>Tag type for the binary |= operator. </purpose></struct><struct name="bitwise_xor_assign"><purpose>Tag type for the binary ^= operator. </purpose></struct><struct name="subscript"><purpose>Tag type for the binary subscript operator. </purpose></struct><struct name="if_else_"><purpose>Tag type for the ternary ?: conditional operator. </purpose></struct><struct name="function"><purpose>Tag type for the n-ary function call operator. </purpose></struct></namespace></namespace></namespace></header><header name="boost/proto/traits.hpp"><para>Contains definitions for child<>, child_c<>, left<>, right<>, tag_of<>, and the helper functions child(), child_c(), value(), left() and right(). </para><namespace name="boost"><namespace name="proto"><struct name="is_callable"><template>
+ </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 const &</paramtype></parameter><parameter name="a2"><paramtype>A2 const &</paramtype></parameter><description><para>if_else </para></description></function></namespace></namespace></header><header name="boost/proto/proto.hpp"><para>Includes all of Proto. </para></header><header name="boost/proto/proto_fwd.hpp"><para>Forward declarations of all of proto's public types and functions. </para><namespace name="boost"><namespace name="proto"><struct name="callable"><typedef name="proto_is_callable_"><type>void</type></typedef></struct><namespace name="context"/><namespace name="control"><data-member name="N"><type>int const</type></data-member></namespace><namespace name="exops"/><namespace name="functional"><typedef name="make_terminal"><type><classname>make_expr</classname>< <classname>tag::terminal</classname> ></type></typedef><typedef name="make_unary_plus"><type><classnam
e>make_expr</classname>< <classname>tag::unary_plus</classname> ></type></typedef><typedef name="make_negate"><type><classname>make_expr</classname>< <classname>tag::negate</classname> ></type></typedef><typedef name="make_dereference"><type><classname>make_expr</classname>< <classname>tag::dereference</classname> ></type></typedef><typedef name="make_complement"><type><classname>make_expr</classname>< <classname>tag::complement</classname> ></type></typedef><typedef name="make_address_of"><type><classname>make_expr</classname>< <classname>tag::address_of</classname> ></type></typedef><typedef name="make_logical_not"><type><classname>make_expr</classname>< <classname>tag::logical_not</classname> ></type></typedef><typedef name="make_pre_inc"><type><classname>make_expr</classname>< <classname>tag::pre_inc</classname> ></type></typedef><typedef name="make_pre_dec"><type><classname>make_expr</classname>< <classname>tag::pre_dec</classname> ></type></typedef><typed
ef name="make_post_inc"><type><classname>make_expr</classname>< <classname>tag::post_inc</classname> ></type></typedef><typedef name="make_post_dec"><type><classname>make_expr</classname>< <classname>tag::post_dec</classname> ></type></typedef><typedef name="make_shift_left"><type><classname>make_expr</classname>< <classname>tag::shift_left</classname> ></type></typedef><typedef name="make_shift_right"><type><classname>make_expr</classname>< <classname>tag::shift_right</classname> ></type></typedef><typedef name="make_multiplies"><type><classname>make_expr</classname>< <classname>tag::multiplies</classname> ></type></typedef><typedef name="make_divides"><type><classname>make_expr</classname>< <classname>tag::divides</classname> ></type></typedef><typedef name="make_modulus"><type><classname>make_expr</classname>< <classname>tag::modulus</classname> ></type></typedef><typedef name="make_plus"><type><classname>make_expr</classname>< <classname>tag::plus</classname>
></type></typedef><typedef name="make_minus"><type><classname>make_expr</classname>< <classname>tag::minus</classname> ></type></typedef><typedef name="make_less"><type><classname>make_expr</classname>< <classname>tag::less</classname> ></type></typedef><typedef name="make_greater"><type><classname>make_expr</classname>< <classname>tag::greater</classname> ></type></typedef><typedef name="make_less_equal"><type><classname>make_expr</classname>< <classname>tag::less_equal</classname> ></type></typedef><typedef name="make_greater_equal"><type><classname>make_expr</classname>< <classname>tag::greater_equal</classname> ></type></typedef><typedef name="make_equal_to"><type><classname>make_expr</classname>< <classname>tag::equal_to</classname> ></type></typedef><typedef name="make_not_equal_to"><type><classname>make_expr</classname>< <classname>tag::not_equal_to</classname> ></type></typedef><typedef name="make_logical_or"><type><classname>make_expr</classname>< <cla
ssname>tag::logical_or</classname> ></type></typedef><typedef name="make_logical_and"><type><classname>make_expr</classname>< <classname>tag::logical_and</classname> ></type></typedef><typedef name="make_bitwise_and"><type><classname>make_expr</classname>< <classname>tag::bitwise_and</classname> ></type></typedef><typedef name="make_bitwise_or"><type><classname>make_expr</classname>< <classname>tag::bitwise_or</classname> ></type></typedef><typedef name="make_bitwise_xor"><type><classname>make_expr</classname>< <classname>tag::bitwise_xor</classname> ></type></typedef><typedef name="make_comma"><type><classname>make_expr</classname>< <classname>tag::comma</classname> ></type></typedef><typedef name="make_mem_ptr"><type><classname>make_expr</classname>< <classname>tag::mem_ptr</classname> ></type></typedef><typedef name="make_assign"><type><classname>make_expr</classname>< <classname>tag::assign</classname> ></type></typedef><typedef name="make_shift_left_assign"><
type><classname>make_expr</classname>< <classname>tag::shift_left_assign</classname> ></type></typedef><typedef name="make_shift_right_assign"><type><classname>make_expr</classname>< <classname>tag::shift_right_assign</classname> ></type></typedef><typedef name="make_multiplies_assign"><type><classname>make_expr</classname>< <classname>tag::multiplies_assign</classname> ></type></typedef><typedef name="make_divides_assign"><type><classname>make_expr</classname>< <classname>tag::divides_assign</classname> ></type></typedef><typedef name="make_modulus_assign"><type><classname>make_expr</classname>< <classname>tag::modulus_assign</classname> ></type></typedef><typedef name="make_plus_assign"><type><classname>make_expr</classname>< <classname>tag::plus_assign</classname> ></type></typedef><typedef name="make_minus_assign"><type><classname>make_expr</classname>< <classname>tag::minus_assign</classname> ></type></typedef><typedef name="make_bitwise_and_assign"><type><class
name>make_expr</classname>< <classname>tag::bitwise_and_assign</classname> ></type></typedef><typedef name="make_bitwise_or_assign"><type><classname>make_expr</classname>< <classname>tag::bitwise_or_assign</classname> ></type></typedef><typedef name="make_bitwise_xor_assign"><type><classname>make_expr</classname>< <classname>tag::bitwise_xor_assign</classname> ></type></typedef><typedef name="make_subscript"><type><classname>make_expr</classname>< <classname>tag::subscript</classname> ></type></typedef><typedef name="make_if_else"><type><classname>make_expr</classname>< <classname>tag::if_else_</classname> ></type></typedef><typedef name="make_function"><type><classname>make_expr</classname>< <classname>tag::function</classname> ></type></typedef></namespace><namespace name="op"/><namespace name="result_of"/><namespace name="tag"/><namespace name="utility"/><typedef name="ignore"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="_flatten"><type><classna
me>functional::flatten</classname></type></typedef><typedef name="_pop_front"><type><classname>functional::pop_front</classname></type></typedef><typedef name="_reverse"><type><classname>functional::reverse</classname></type></typedef><typedef name="_eval"><type><classname>functional::eval</classname></type></typedef><typedef name="_deep_copy"><type><classname>functional::deep_copy</classname></type></typedef><typedef name="_make_terminal"><type><classname>_make_expr</classname>< <classname>tag::terminal</classname> ></type></typedef><typedef name="_make_unary_plus"><type><classname>_make_expr</classname>< <classname>tag::unary_plus</classname> ></type></typedef><typedef name="_make_negate"><type><classname>_make_expr</classname>< <classname>tag::negate</classname> ></type></typedef><typedef name="_make_dereference"><type><classname>_make_expr</classname>< <classname>tag::dereference</classname> ></type></typedef><typedef name="_make_complement"><type><classname>_make_expr</classname>
< <classname>tag::complement</classname> ></type></typedef><typedef name="_make_address_of"><type><classname>_make_expr</classname>< <classname>tag::address_of</classname> ></type></typedef><typedef name="_make_logical_not"><type><classname>_make_expr</classname>< <classname>tag::logical_not</classname> ></type></typedef><typedef name="_make_pre_inc"><type><classname>_make_expr</classname>< <classname>tag::pre_inc</classname> ></type></typedef><typedef name="_make_pre_dec"><type><classname>_make_expr</classname>< <classname>tag::pre_dec</classname> ></type></typedef><typedef name="_make_post_inc"><type><classname>_make_expr</classname>< <classname>tag::post_inc</classname> ></type></typedef><typedef name="_make_post_dec"><type><classname>_make_expr</classname>< <classname>tag::post_dec</classname> ></type></typedef><typedef name="_make_shift_left"><type><classname>_make_expr</classname>< <classname>tag::shift_left</classname> ></type></typedef><typedef name="_m
ake_shift_right"><type><classname>_make_expr</classname>< <classname>tag::shift_right</classname> ></type></typedef><typedef name="_make_multiplies"><type><classname>_make_expr</classname>< <classname>tag::multiplies</classname> ></type></typedef><typedef name="_make_divides"><type><classname>_make_expr</classname>< <classname>tag::divides</classname> ></type></typedef><typedef name="_make_modulus"><type><classname>_make_expr</classname>< <classname>tag::modulus</classname> ></type></typedef><typedef name="_make_plus"><type><classname>_make_expr</classname>< <classname>tag::plus</classname> ></type></typedef><typedef name="_make_minus"><type><classname>_make_expr</classname>< <classname>tag::minus</classname> ></type></typedef><typedef name="_make_less"><type><classname>_make_expr</classname>< <classname>tag::less</classname> ></type></typedef><typedef name="_make_greater"><type><classname>_make_expr</classname>< <classname>tag::greater</classname> ></type></ty
pedef><typedef name="_make_less_equal"><type><classname>_make_expr</classname>< <classname>tag::less_equal</classname> ></type></typedef><typedef name="_make_greater_equal"><type><classname>_make_expr</classname>< <classname>tag::greater_equal</classname> ></type></typedef><typedef name="_make_equal_to"><type><classname>_make_expr</classname>< <classname>tag::equal_to</classname> ></type></typedef><typedef name="_make_not_equal_to"><type><classname>_make_expr</classname>< <classname>tag::not_equal_to</classname> ></type></typedef><typedef name="_make_logical_or"><type><classname>_make_expr</classname>< <classname>tag::logical_or</classname> ></type></typedef><typedef name="_make_logical_and"><type><classname>_make_expr</classname>< <classname>tag::logical_and</classname> ></type></typedef><typedef name="_make_bitwise_and"><type><classname>_make_expr</classname>< <classname>tag::bitwise_and</classname> ></type></typedef><typedef name="_make_bitwise_or"><type><classnam
e>_make_expr</classname>< <classname>tag::bitwise_or</classname> ></type></typedef><typedef name="_make_bitwise_xor"><type><classname>_make_expr</classname>< <classname>tag::bitwise_xor</classname> ></type></typedef><typedef name="_make_comma"><type><classname>_make_expr</classname>< <classname>tag::comma</classname> ></type></typedef><typedef name="_make_mem_ptr"><type><classname>_make_expr</classname>< <classname>tag::mem_ptr</classname> ></type></typedef><typedef name="_make_assign"><type><classname>_make_expr</classname>< <classname>tag::assign</classname> ></type></typedef><typedef name="_make_shift_left_assign"><type><classname>_make_expr</classname>< <classname>tag::shift_left_assign</classname> ></type></typedef><typedef name="_make_shift_right_assign"><type><classname>_make_expr</classname>< <classname>tag::shift_right_assign</classname> ></type></typedef><typedef name="_make_multiplies_assign"><type><classname>_make_expr</classname>< <classname>tag::mult
iplies_assign</classname> ></type></typedef><typedef name="_make_divides_assign"><type><classname>_make_expr</classname>< <classname>tag::divides_assign</classname> ></type></typedef><typedef name="_make_modulus_assign"><type><classname>_make_expr</classname>< <classname>tag::modulus_assign</classname> ></type></typedef><typedef name="_make_plus_assign"><type><classname>_make_expr</classname>< <classname>tag::plus_assign</classname> ></type></typedef><typedef name="_make_minus_assign"><type><classname>_make_expr</classname>< <classname>tag::minus_assign</classname> ></type></typedef><typedef name="_make_bitwise_and_assign"><type><classname>_make_expr</classname>< <classname>tag::bitwise_and_assign</classname> ></type></typedef><typedef name="_make_bitwise_or_assign"><type><classname>_make_expr</classname>< <classname>tag::bitwise_or_assign</classname> ></type></typedef><typedef name="_make_bitwise_xor_assign"><type><classname>_make_expr</classname>< <classname>tag::b
itwise_xor_assign</classname> ></type></typedef><typedef name="_make_subscript"><type><classname>_make_expr</classname>< <classname>tag::subscript</classname> ></type></typedef><typedef name="_make_if_else"><type><classname>_make_expr</classname>< <classname>tag::if_else_</classname> ></type></typedef><typedef name="_make_function"><type><classname>_make_expr</classname>< <classname>tag::function</classname> ></type></typedef><typedef name="_child0"><type><classname>_child_c</classname>< 0 ></type></typedef><typedef name="_child1"><type><classname>_child_c</classname>< 1 ></type></typedef><typedef name="_child"><type><classname>_child0</classname></type></typedef><typedef name="_value"><type><classname>_child0</classname></type></typedef><typedef name="_left"><type><classname>_child0</classname></type></typedef><typedef name="_right"><type><classname>_child1</classname></type></typedef><typedef name="_child2"><type><classname>_child_c</classname>< 2 ></type></typedef><t
ypedef name="_child3"><type><classname>_child_c</classname>< 3 ></type></typedef></namespace></namespace></header><header name="boost/proto/tags.hpp"><para>Contains the tags for all the overloadable operators in C++ </para><namespace name="boost"><namespace name="proto"><namespace name="tag"><struct name="terminal"><purpose>Tag type for terminals; aka, leaves in the expression tree. </purpose></struct><struct name="unary_plus"><purpose>Tag type for the unary + operator. </purpose></struct><struct name="negate"><purpose>Tag type for the unary - operator. </purpose></struct><struct name="dereference"><purpose>Tag type for the unary * operator. </purpose></struct><struct name="complement"><purpose>Tag type for the unary ~ operator. </purpose></struct><struct name="address_of"><purpose>Tag type for the unary & operator. </purpose></struct><struct name="logical_not"><purpose>Tag type for the unary ! operator. </purpose></struct><struct name="pre_inc"><purpose>Tag type for the unary prefix ++ operator. <
/purpose></struct><struct name="pre_dec"><purpose>Tag type for the unary prefix -- operator. </purpose></struct><struct name="post_inc"><purpose>Tag type for the unary postfix ++ operator. </purpose></struct><struct name="post_dec"><purpose>Tag type for the unary postfix -- operator. </purpose></struct><struct name="shift_left"><purpose>Tag type for the binary << operator. </purpose></struct><struct name="shift_right"><purpose>Tag type for the binary >> operator. </purpose></struct><struct name="multiplies"><purpose>Tag type for the binary * operator. </purpose></struct><struct name="divides"><purpose>Tag type for the binary / operator. </purpose></struct><struct name="modulus"><purpose>Tag type for the binary % operator. </purpose></struct><struct name="plus"><purpose>Tag type for the binary + operator. </purpose></struct><struct name="minus"><purpose>Tag type for the binary - operator. </purpose></struct><struct name="less"><purpose>Tag type for the binary < operator. </purpose></struct><str
uct name="greater"><purpose>Tag type for the binary > operator. </purpose></struct><struct name="less_equal"><purpose>Tag type for the binary <= operator. </purpose></struct><struct name="greater_equal"><purpose>Tag type for the binary >= operator. </purpose></struct><struct name="equal_to"><purpose>Tag type for the binary == operator. </purpose></struct><struct name="not_equal_to"><purpose>Tag type for the binary != operator. </purpose></struct><struct name="logical_or"><purpose>Tag type for the binary || operator. </purpose></struct><struct name="logical_and"><purpose>Tag type for the binary && operator. </purpose></struct><struct name="bitwise_and"><purpose>Tag type for the binary & operator. </purpose></struct><struct name="bitwise_or"><purpose>Tag type for the binary | operator. </purpose></struct><struct name="bitwise_xor"><purpose>Tag type for the binary ^ operator. </purpose></struct><struct name="comma"><purpose>Tag type for the binary , operator. </purpose></struct><struct name
="mem_ptr"><purpose>Tag type for the binary ->* operator. </purpose></struct><struct name="assign"><purpose>Tag type for the binary = operator. </purpose></struct><struct name="shift_left_assign"><purpose>Tag type for the binary <<= operator. </purpose></struct><struct name="shift_right_assign"><purpose>Tag type for the binary >>= operator. </purpose></struct><struct name="multiplies_assign"><purpose>Tag type for the binary *= operator. </purpose></struct><struct name="divides_assign"><purpose>Tag type for the binary /= operator. </purpose></struct><struct name="modulus_assign"><purpose>Tag type for the binary = operator. </purpose></struct><struct name="plus_assign"><purpose>Tag type for the binary += operator. </purpose></struct><struct name="minus_assign"><purpose>Tag type for the binary -= operator. </purpose></struct><struct name="bitwise_and_assign"><purpose>Tag type for the binary &= operator. </purpose></struct><struct name="bitwise_or_assign"><purpose>Tag type for the binary |= op
erator. </purpose></struct><struct name="bitwise_xor_assign"><purpose>Tag type for the binary ^= operator. </purpose></struct><struct name="subscript"><purpose>Tag type for the binary subscript operator. </purpose></struct><struct name="if_else_"><purpose>Tag type for the ternary ?: conditional operator. </purpose></struct><struct name="function"><purpose>Tag type for the n-ary function call operator. </purpose></struct></namespace></namespace></namespace></header><header name="boost/proto/traits.hpp"><para>Contains definitions for child<>, child_c<>, left<>, right<>, tag_of<>, and the helper functions child(), child_c(), value(), left() and right(). </para><namespace name="boost"><namespace name="proto"><struct name="is_callable"><template>
       <template-type-parameter name="T"/>
     </template><purpose>Boolean metafunction which detects whether a type is a callable function object type or not. </purpose><description><para><computeroutput>is_callable<></computeroutput> is used by the <computeroutput>when<></computeroutput> transform to determine whether a function type <computeroutput>R(A1,A2,...AN)</computeroutput> is a callable transform or an object transform. (The former are evaluated using <computeroutput>call<></computeroutput> and the later with <computeroutput>make<></computeroutput>.) If <computeroutput>is_callable<R>::value</computeroutput> is <computeroutput>true</computeroutput>, the function type is a callable transform; otherwise, it is an object transform.</para><para>Unless specialized for a type <computeroutput>T</computeroutput>, <computeroutput>is_callable<T>::value</computeroutput> is computed as follows:</para><para><itemizedlist>
<listitem><para>If <computeroutput>T</computeroutput> is a template type <computeroutput>X<Y0,Y1,...YN></computeroutput>, where all <computeroutput>Yx</computeroutput> are types for <computeroutput>x</computeroutput> in <computeroutput>[0,N]</computeroutput>, <computeroutput>is_callable<T>::value</computeroutput> is <computeroutput>is_same<YN, proto::callable>::value</computeroutput>. </para></listitem>
@@ -1607,7 +1973,12 @@
       <template-type-parameter name="Tag"/>
       <template-type-parameter name="Args"/>
       <template-nontype-parameter name="N"><type>long</type></template-nontype-parameter>
- </template><specialization><template-arg>proto::expr< Tag</template-arg><template-arg>Args</template-arg><template-arg>N ></template-arg></specialization><inherit access="public">boost::mpl::true_</inherit><purpose>Specialization of <computeroutput>is_aggregate<></computeroutput> that indicates that objects of <computeroutput>expr<></computeroutput> type require aggregate initialization. </purpose></struct-specialization><namespace name="functor"><struct name="as_expr"><template>
+ </template><specialization><template-arg>proto::expr< Tag</template-arg><template-arg>Args</template-arg><template-arg>N ></template-arg></specialization><inherit access="public">boost::mpl::true_</inherit><purpose>Specialization of <computeroutput>is_aggregate<></computeroutput> that indicates that objects of <computeroutput>expr<></computeroutput> type require aggregate initialization. </purpose></struct-specialization><struct name="is_transform"><template>
+ <template-type-parameter name="T"/>
+ <template-type-parameter name="Void"><default>void</default></template-type-parameter>
+ </template><inherit access="public">boost::mpl::false_</inherit><purpose>TODO document me! </purpose></struct><struct-specialization name="is_transform"><template>
+ <template-type-parameter name="T"/>
+ </template><specialization><template-arg>T</template-arg><template-arg>typename T::proto_is_transform_</template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><namespace name="functional"><struct name="as_expr"><template>
       <template-type-parameter name="Domain"><default>default_domain</default></template-type-parameter>
     </template><purpose>A callable PolymorphicFunctionObject that is equivalent to the <computeroutput>as_expr()</computeroutput> function. </purpose><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
@@ -1634,743 +2005,463 @@
     </template><purpose>A callable PolymorphicFunctionObject that is equivalent to the <computeroutput>child_c()</computeroutput> function. </purpose><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
- </template><specialization><template-arg>This(Expr)</template-arg></specialization><typedef name="uncvref_type"><type>boost::remove_const< typename boost::remove_reference< Expr >::type >::type</type></typedef><typedef name="type"><type>result_of::child_c< uncvref_type, N >::type</type></typedef></struct-specialization><typedef name="proto_is_callable_"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_of::child_c< Expr, N >::reference</type><template>
+ </template><specialization><template-arg>This(Expr)</template-arg></specialization><typedef name="type"><type>result_of::child_c< Expr, N >::type</type></typedef></struct-specialization><typedef name="proto_is_callable_"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_of::child_c< Expr &, N >::type</type><template>
           <template-type-parameter name="Expr"/>
         </template><parameter name="expr"><paramtype>Expr &</paramtype><description><para>The expression node. </para></description></parameter><purpose>Return the Nth child of the given expression. </purpose><description><para>

-</para></description><requires><para><computeroutput>is_expr<Expr>::value</computeroutput> is <computeroutput>true</computeroutput> </para><para><computeroutput>N == 0 || N < Expr::proto_arity::value</computeroutput> </para></requires><returns><para><computeroutput>proto::child_c<N>(expr)</computeroutput> </para></returns><throws><simpara>Will not throw.</simpara></throws></method><method name="operator()" cv="const"><type>result_of::child_c< Expr, N >::const_reference</type><template>
+</para></description><requires><para><computeroutput>is_expr<Expr>::value</computeroutput> is <computeroutput>true</computeroutput> </para><para><computeroutput>N == 0 || N < Expr::proto_arity::value</computeroutput> </para></requires><returns><para><computeroutput>proto::child_c<N>(expr)</computeroutput> </para></returns><throws><simpara>Will not throw.</simpara></throws></method><method name="operator()" cv="const"><type>result_of::child_c< Expr const &, N >::type</type><template>
           <template-type-parameter name="Expr"/>
         </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method></method-group></struct><struct name="child"><template>
       <template-type-parameter name="N"><default>mpl::long_<0></default></template-type-parameter>
     </template><purpose>A callable PolymorphicFunctionObject that is equivalent to the <computeroutput>child()</computeroutput> function. </purpose><description><para>A callable PolymorphicFunctionObject that is equivalent to the <computeroutput>child()</computeroutput> function. <computeroutput>N</computeroutput> is required to be an MPL Integral Constant. </para></description><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
- </template><specialization><template-arg>This(Expr)</template-arg></specialization><typedef name="uncvref_type"><type>boost::remove_const< typename boost::remove_reference< Expr >::type >::type</type></typedef><typedef name="type"><type><classname>result_of::child</classname>< uncvref_type, N >::type</type></typedef></struct-specialization><typedef name="proto_is_callable_"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result_of::child</classname>< Expr, N >::reference</type><template>
+ </template><specialization><template-arg>This(Expr)</template-arg></specialization><typedef name="type"><type><classname>result_of::child</classname>< Expr, N >::type</type></typedef></struct-specialization><typedef name="proto_is_callable_"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result_of::child</classname>< Expr &, N >::type</type><template>
           <template-type-parameter name="Expr"/>
         </template><parameter name="expr"><paramtype>Expr &</paramtype><description><para>The expression node. </para></description></parameter><purpose>Return the Nth child of the given expression. </purpose><description><para>

-</para></description><requires><para><computeroutput>is_expr<Expr>::value</computeroutput> is <computeroutput>true</computeroutput> </para><para><computeroutput>N::value == 0 || N::value < Expr::proto_arity::value</computeroutput> </para></requires><returns><para><computeroutput>proto::child<N>(expr)</computeroutput> </para></returns><throws><simpara>Will not throw.</simpara></throws></method><method name="operator()" cv="const"><type><classname>result_of::child</classname>< Expr, N >::const_reference</type><template>
+</para></description><requires><para><computeroutput>is_expr<Expr>::value</computeroutput> is <computeroutput>true</computeroutput> </para><para><computeroutput>N::value == 0 || N::value < Expr::proto_arity::value</computeroutput> </para></requires><returns><para><computeroutput>proto::child<N>(expr)</computeroutput> </para></returns><throws><simpara>Will not throw.</simpara></throws></method><method name="operator()" cv="const"><type><classname>result_of::child</classname>< Expr const &, N >::type</type><template>
           <template-type-parameter name="Expr"/>
         </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method></method-group></struct><struct name="value"><purpose>A callable PolymorphicFunctionObject that is equivalent to the <computeroutput>value()</computeroutput> function. </purpose><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
- </template><specialization><template-arg>This(Expr)</template-arg></specialization><typedef name="uncvref_type"><type>boost::remove_const< typename boost::remove_reference< Expr >::type >::type</type></typedef><typedef name="type"><type><classname>result_of::value</classname>< uncvref_type >::type</type></typedef></struct-specialization><typedef name="proto_is_callable_"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result_of::value</classname>< Expr >::reference</type><template>
+ </template><specialization><template-arg>This(Expr)</template-arg></specialization><typedef name="type"><type><classname>result_of::value</classname>< Expr >::type</type></typedef></struct-specialization><typedef name="proto_is_callable_"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result_of::value</classname>< Expr & >::type</type><template>
           <template-type-parameter name="Expr"/>
         </template><parameter name="expr"><paramtype>Expr &</paramtype><description><para>The terminal expression node. </para></description></parameter><purpose>Return the value of the given terminal expression. </purpose><description><para>

-</para></description><requires><para><computeroutput>is_expr<Expr>::value</computeroutput> is <computeroutput>true</computeroutput> </para><para><computeroutput>0 == Expr::proto_arity::value</computeroutput> </para><para><computeroutput>Expr::proto_tag</computeroutput> is <computeroutput>tag::terminal</computeroutput> </para></requires><returns><para><computeroutput>proto::value(expr)</computeroutput> </para></returns><throws><simpara>Will not throw.</simpara></throws></method><method name="operator()" cv="const"><type><classname>result_of::value</classname>< Expr >::const_reference</type><template>
+</para></description><requires><para><computeroutput>is_expr<Expr>::value</computeroutput> is <computeroutput>true</computeroutput> </para><para><computeroutput>0 == Expr::proto_arity::value</computeroutput> </para><para><computeroutput>Expr::proto_tag</computeroutput> is <computeroutput>tag::terminal</computeroutput> </para></requires><returns><para><computeroutput>proto::value(expr)</computeroutput> </para></returns><throws><simpara>Will not throw.</simpara></throws></method><method name="operator()" cv="const"><type><classname>result_of::value</classname>< Expr const & >::type</type><template>
           <template-type-parameter name="Expr"/>
         </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method></method-group></struct><struct name="left"><purpose>A callable PolymorphicFunctionObject that is equivalent to the <computeroutput>left()</computeroutput> function. </purpose><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
- </template><specialization><template-arg>This(Expr)</template-arg></specialization><typedef name="uncvref_type"><type>boost::remove_const< typename boost::remove_reference< Expr >::type >::type</type></typedef><typedef name="type"><type><classname>result_of::left</classname>< uncvref_type >::type</type></typedef></struct-specialization><typedef name="proto_is_callable_"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result_of::left</classname>< Expr >::reference</type><template>
+ </template><specialization><template-arg>This(Expr)</template-arg></specialization><typedef name="type"><type><classname>result_of::left</classname>< Expr >::type</type></typedef></struct-specialization><typedef name="proto_is_callable_"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result_of::left</classname>< Expr & >::type</type><template>
           <template-type-parameter name="Expr"/>
         </template><parameter name="expr"><paramtype>Expr &</paramtype><description><para>The expression node. </para></description></parameter><purpose>Return the left child of the given binary expression. </purpose><description><para>

-</para></description><requires><para><computeroutput>is_expr<Expr>::value</computeroutput> is <computeroutput>true</computeroutput> </para><para><computeroutput>2 == Expr::proto_arity::value</computeroutput> </para></requires><returns><para><computeroutput>proto::left(expr)</computeroutput> </para></returns><throws><simpara>Will not throw.</simpara></throws></method><method name="operator()" cv="const"><type><classname>result_of::left</classname>< Expr >::const_reference</type><template>
+</para></description><requires><para><computeroutput>is_expr<Expr>::value</computeroutput> is <computeroutput>true</computeroutput> </para><para><computeroutput>2 == Expr::proto_arity::value</computeroutput> </para></requires><returns><para><computeroutput>proto::left(expr)</computeroutput> </para></returns><throws><simpara>Will not throw.</simpara></throws></method><method name="operator()" cv="const"><type><classname>result_of::left</classname>< Expr const & >::type</type><template>
           <template-type-parameter name="Expr"/>
         </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method></method-group></struct><struct name="right"><purpose>A callable PolymorphicFunctionObject that is equivalent to the <computeroutput>right()</computeroutput> function. </purpose><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
- </template><specialization><template-arg>This(Expr)</template-arg></specialization><typedef name="uncvref_type"><type>boost::remove_const< typename boost::remove_reference< Expr >::type >::type</type></typedef><typedef name="type"><type><classname>result_of::right</classname>< uncvref_type >::type</type></typedef></struct-specialization><typedef name="proto_is_callable_"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result_of::right</classname>< Expr >::reference</type><template>
+ </template><specialization><template-arg>This(Expr)</template-arg></specialization><typedef name="type"><type><classname>result_of::right</classname>< Expr >::type</type></typedef></struct-specialization><typedef name="proto_is_callable_"><type>void</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result_of::right</classname>< Expr & >::type</type><template>
           <template-type-parameter name="Expr"/>
         </template><parameter name="expr"><paramtype>Expr &</paramtype><description><para>The expression node. </para></description></parameter><purpose>Return the right child of the given binary expression. </purpose><description><para>

-</para></description><requires><para><computeroutput>is_expr<Expr>::value</computeroutput> is <computeroutput>true</computeroutput> </para><para><computeroutput>2 == Expr::proto_arity::value</computeroutput> </para></requires><returns><para><computeroutput>proto::right(expr)</computeroutput> </para></returns><throws><simpara>Will not throw.</simpara></throws></method><method name="operator()" cv="const"><type><classname>result_of::right</classname>< Expr >::const_reference</type><template>
+</para></description><requires><para><computeroutput>is_expr<Expr>::value</computeroutput> is <computeroutput>true</computeroutput> </para><para><computeroutput>2 == Expr::proto_arity::value</computeroutput> </para></requires><returns><para><computeroutput>proto::right(expr)</computeroutput> </para></returns><throws><simpara>Will not throw.</simpara></throws></method><method name="operator()" cv="const"><type><classname>result_of::right</classname>< Expr const & >::type</type><template>
           <template-type-parameter name="Expr"/>
         </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></method></method-group></struct></namespace><namespace name="op"><struct name="terminal"><template>
       <template-type-parameter name="T"/>
- </template><purpose>A metafunction for generating terminal expression types, a grammar element for matching terminal expressions, and a PrimitiveTransform that returns the current expression unchanged. </purpose><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+ </template><purpose>A metafunction for generating terminal expression types, a grammar element for matching terminal expressions, and a PrimitiveTransform that returns the current expression unchanged. </purpose><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Data"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Data)</template-arg></specialization><typedef name="type"><type>Expr</type></typedef></struct-specialization><typedef name="type"><type>proto::expr< <classname>proto::tag::terminal</classname>, <classname>term</classname>< T > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>Expr const &</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name=""><paramtype>State const &</paramtype></parameter><parameter name=""><paramtype>Data &</paramtype></parameter><description><para>
+ </template><typedef name="result_type"><type>Expr</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>impl::expr_param</type><parameter name="expr"><paramtype>typename impl::expr_param</paramtype><description><para>The current expression </para></description></parameter><parameter name=""><paramtype>typename impl::state_param</paramtype></parameter><parameter name=""><paramtype>typename impl::data_param</paramtype></parameter><description><para>

-</para></description><requires><para><computeroutput>matches<Expr, terminal<T> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>expr</computeroutput> </para></returns><throws><simpara>Will not throw.</simpara></throws></method></method-group></struct><struct name="if_else_"><template>
+</para></description><requires><para><computeroutput>matches<Expr, terminal<T> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>expr</computeroutput> </para></returns><throws><simpara>Will not throw.</simpara></throws></method></method-group></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::terminal</classname>, <classname>term</classname>< T > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="if_else_"><template>
       <template-type-parameter name="T"/>
       <template-type-parameter name="U"/>
       <template-type-parameter name="V"/>
- </template><purpose>A metafunction for generating ternary conditional expression types, a grammar element for matching ternary conditional expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>if_else_</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::if_else_</classname>, <classname>list3</classname>< T, U, V > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, if_else_<T,U,V> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<if_else_<T,U,V> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="unary_expr"><template>
+ </template><purpose>A metafunction for generating ternary conditional expression types, a grammar element for matching ternary conditional expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::if_else_</classname>, <classname>list3</classname>< T, U, V > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="unary_expr"><template>
       <template-type-parameter name="Tag"/>
       <template-type-parameter name="T"/>
- </template><purpose>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 <computeroutput>pass_through<></computeroutput> transform. </purpose><description><para>Use <computeroutput>unary_expr<_, _></computeroutput> as a grammar element to match any unary expression. </para></description><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>unary_expr</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< Tag, <classname>list1</classname>< T > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, unary_expr<Tag, T> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<unary_expr<Tag, T> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="binary_expr"><template>
+ </template><purpose>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 <computeroutput>pass_through<></computeroutput> transform. </purpose><description><para>Use <computeroutput>unary_expr<_, _></computeroutput> as a grammar element to match any unary expression. </para></description><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< Tag, <classname>list1</classname>< T > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="binary_expr"><template>
       <template-type-parameter name="Tag"/>
       <template-type-parameter name="T"/>
       <template-type-parameter name="U"/>
- </template><purpose>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 <computeroutput>pass_through<></computeroutput> transform. </purpose><description><para>Use <computeroutput>binary_expr<_, _, _></computeroutput> as a grammar element to match any binary expression. </para></description><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>binary_expr</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< Tag, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, binary_expr<Tag,T,U> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<binary_expr<Tag,T,U> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="unary_plus"><template>
- <template-type-parameter name="T"/>
- </template><purpose>A metafunction for generating unary plus expression types, a grammar element for matching unary plus expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>unary_plus</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::unary_plus</classname>, <classname>list1</classname>< T > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, unary_plus<T> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<unary_plus<T> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="negate"><template>
+ </template><purpose>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 <computeroutput>pass_through<></computeroutput> transform. </purpose><description><para>Use <computeroutput>binary_expr<_, _, _></computeroutput> as a grammar element to match any binary expression. </para></description><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< Tag, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="unary_plus"><template>
       <template-type-parameter name="T"/>
- </template><purpose>A metafunction for generating unary minus expression types, a grammar element for matching unary minus expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>negate</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::negate</classname>, <classname>list1</classname>< T > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, negate<T> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<negate<T> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="dereference"><template>
+ </template><purpose>A metafunction for generating unary plus expression types, a grammar element for matching unary plus expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::unary_plus</classname>, <classname>list1</classname>< T > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="negate"><template>
       <template-type-parameter name="T"/>
- </template><purpose>A metafunction for generating defereference expression types, a grammar element for matching dereference expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>dereference</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::dereference</classname>, <classname>list1</classname>< T > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, dereference<T> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<dereference<T> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="complement"><template>
+ </template><purpose>A metafunction for generating unary minus expression types, a grammar element for matching unary minus expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::negate</classname>, <classname>list1</classname>< T > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="dereference"><template>
       <template-type-parameter name="T"/>
- </template><purpose>A metafunction for generating complement expression types, a grammar element for matching complement expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>complement</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::complement</classname>, <classname>list1</classname>< T > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, complement<T> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<complement<T> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="address_of"><template>
+ </template><purpose>A metafunction for generating defereference expression types, a grammar element for matching dereference expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::dereference</classname>, <classname>list1</classname>< T > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="complement"><template>
       <template-type-parameter name="T"/>
- </template><purpose>A metafunction for generating address_of expression types, a grammar element for matching address_of expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>address_of</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::address_of</classname>, <classname>list1</classname>< T > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, address_of<T> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<address_of<T> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="logical_not"><template>
+ </template><purpose>A metafunction for generating complement expression types, a grammar element for matching complement expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::complement</classname>, <classname>list1</classname>< T > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="address_of"><template>
       <template-type-parameter name="T"/>
- </template><purpose>A metafunction for generating logical_not expression types, a grammar element for matching logical_not expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>logical_not</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::logical_not</classname>, <classname>list1</classname>< T > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, logical_not<T> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<logical_not<T> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="pre_inc"><template>
+ </template><purpose>A metafunction for generating address_of expression types, a grammar element for matching address_of expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::address_of</classname>, <classname>list1</classname>< T > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="logical_not"><template>
       <template-type-parameter name="T"/>
- </template><purpose>A metafunction for generating pre-increment expression types, a grammar element for matching pre-increment expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>pre_inc</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::pre_inc</classname>, <classname>list1</classname>< T > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, pre_inc<T> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<pre_inc<T> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="pre_dec"><template>
+ </template><purpose>A metafunction for generating logical_not expression types, a grammar element for matching logical_not expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::logical_not</classname>, <classname>list1</classname>< T > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="pre_inc"><template>
       <template-type-parameter name="T"/>
- </template><purpose>A metafunction for generating pre-decrement expression types, a grammar element for matching pre-decrement expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>pre_dec</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::pre_dec</classname>, <classname>list1</classname>< T > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, pre_dec<T> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<pre_dec<T> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="post_inc"><template>
+ </template><purpose>A metafunction for generating pre-increment expression types, a grammar element for matching pre-increment expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::pre_inc</classname>, <classname>list1</classname>< T > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="pre_dec"><template>
       <template-type-parameter name="T"/>
- </template><purpose>A metafunction for generating post-increment expression types, a grammar element for matching post-increment expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>post_inc</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::post_inc</classname>, <classname>list1</classname>< T > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, post_inc<T> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<post_inc<T> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="post_dec"><template>
+ </template><purpose>A metafunction for generating pre-decrement expression types, a grammar element for matching pre-decrement expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::pre_dec</classname>, <classname>list1</classname>< T > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="post_inc"><template>
       <template-type-parameter name="T"/>
- </template><purpose>A metafunction for generating post-decrement expression types, a grammar element for matching post-decrement expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>post_dec</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::post_dec</classname>, <classname>list1</classname>< T > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, post_dec<T> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<post_dec<T> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="shift_left"><template>
+ </template><purpose>A metafunction for generating post-increment expression types, a grammar element for matching post-increment expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::post_inc</classname>, <classname>list1</classname>< T > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="post_dec"><template>
       <template-type-parameter name="T"/>
- <template-type-parameter name="U"/>
- </template><purpose>A metafunction for generating left-shift expression types, a grammar element for matching left-shift expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>shift_left</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::shift_left</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, shift_left<T,U> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<shift_left<T,U> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="shift_right"><template>
+ </template><purpose>A metafunction for generating post-decrement expression types, a grammar element for matching post-decrement expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::post_dec</classname>, <classname>list1</classname>< T > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="shift_left"><template>
       <template-type-parameter name="T"/>
       <template-type-parameter name="U"/>
- </template><purpose>A metafunction for generating right-shift expression types, a grammar element for matching right-shift expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>shift_right</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::shift_right</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, shift_right<T,U> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<shift_right<T,U> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="multiplies"><template>
+ </template><purpose>A metafunction for generating left-shift expression types, a grammar element for matching left-shift expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::shift_left</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="shift_right"><template>
       <template-type-parameter name="T"/>
       <template-type-parameter name="U"/>
- </template><purpose>A metafunction for generating multiplies expression types, a grammar element for matching multiplies expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>multiplies</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::multiplies</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, multiplies<T,U> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<multiplies<T,U> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="divides"><template>
+ </template><purpose>A metafunction for generating right-shift expression types, a grammar element for matching right-shift expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::shift_right</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="multiplies"><template>
       <template-type-parameter name="T"/>
       <template-type-parameter name="U"/>
- </template><purpose>A metafunction for generating divides expression types, a grammar element for matching divides expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>divides</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::divides</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, divides<T,U> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<divides<T,U> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="modulus"><template>
+ </template><purpose>A metafunction for generating multiplies expression types, a grammar element for matching multiplies expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::multiplies</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="divides"><template>
       <template-type-parameter name="T"/>
       <template-type-parameter name="U"/>
- </template><purpose>A metafunction for generating modulus expression types, a grammar element for matching modulus expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>modulus</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::modulus</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, modulus<T,U> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<modulus<T,U> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="plus"><template>
+ </template><purpose>A metafunction for generating divides expression types, a grammar element for matching divides expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::divides</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="modulus"><template>
       <template-type-parameter name="T"/>
       <template-type-parameter name="U"/>
- </template><purpose>A metafunction for generating binary plus expression types, a grammar element for matching binary plus expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>plus</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::plus</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, plus<T,U> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<plus<T,U> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="minus"><template>
+ </template><purpose>A metafunction for generating modulus expression types, a grammar element for matching modulus expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::modulus</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="plus"><template>
       <template-type-parameter name="T"/>
       <template-type-parameter name="U"/>
- </template><purpose>A metafunction for generating binary minus expression types, a grammar element for matching binary minus expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>minus</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::minus</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, minus<T,U> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<minus<T,U> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="less"><template>
+ </template><purpose>A metafunction for generating binary plus expression types, a grammar element for matching binary plus expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::plus</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="minus"><template>
       <template-type-parameter name="T"/>
       <template-type-parameter name="U"/>
- </template><purpose>A metafunction for generating less expression types, a grammar element for matching less expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>less</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::less</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, less<T,U> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<less<T,U> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="greater"><template>
+ </template><purpose>A metafunction for generating binary minus expression types, a grammar element for matching binary minus expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::minus</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="less"><template>
       <template-type-parameter name="T"/>
       <template-type-parameter name="U"/>
- </template><purpose>A metafunction for generating greater expression types, a grammar element for matching greater expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>greater</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::greater</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, greater<T,U> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<greater<T,U> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="less_equal"><template>
+ </template><purpose>A metafunction for generating less expression types, a grammar element for matching less expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::less</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="greater"><template>
       <template-type-parameter name="T"/>
       <template-type-parameter name="U"/>
- </template><purpose>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 <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>less_equal</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::less_equal</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, less_equal<T,U> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<less_equal<T,U> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="greater_equal"><template>
+ </template><purpose>A metafunction for generating greater expression types, a grammar element for matching greater expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::greater</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="less_equal"><template>
       <template-type-parameter name="T"/>
       <template-type-parameter name="U"/>
- </template><purpose>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 <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>greater_equal</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::greater_equal</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, greater_equal<T,U> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<greater_equal<T,U> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="equal_to"><template>
+ </template><purpose>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 <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::less_equal</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="greater_equal"><template>
       <template-type-parameter name="T"/>
       <template-type-parameter name="U"/>
- </template><purpose>A metafunction for generating equal-to expression types, a grammar element for matching equal-to expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>equal_to</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::equal_to</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, equal_to<T,U> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<equal_to<T,U> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="not_equal_to"><template>
+ </template><purpose>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 <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::greater_equal</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="equal_to"><template>
       <template-type-parameter name="T"/>
       <template-type-parameter name="U"/>
- </template><purpose>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 <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>not_equal_to</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::not_equal_to</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, not_equal_to<T,U> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<not_equal_to<T,U> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="logical_or"><template>
+ </template><purpose>A metafunction for generating equal-to expression types, a grammar element for matching equal-to expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::equal_to</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="not_equal_to"><template>
       <template-type-parameter name="T"/>
       <template-type-parameter name="U"/>
- </template><purpose>A metafunction for generating logical-or expression types, a grammar element for matching logical-or expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>logical_or</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::logical_or</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, logical_or<T,U> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<logical_or<T,U> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="logical_and"><template>
+ </template><purpose>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 <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::not_equal_to</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="logical_or"><template>
       <template-type-parameter name="T"/>
       <template-type-parameter name="U"/>
- </template><purpose>A metafunction for generating logical-and expression types, a grammar element for matching logical-and expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>logical_and</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::logical_and</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, logical_and<T,U> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<logical_and<T,U> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="bitwise_and"><template>
+ </template><purpose>A metafunction for generating logical-or expression types, a grammar element for matching logical-or expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::logical_or</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="logical_and"><template>
       <template-type-parameter name="T"/>
       <template-type-parameter name="U"/>
- </template><purpose>A metafunction for generating bitwise-and expression types, a grammar element for matching bitwise-and expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>bitwise_and</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::bitwise_and</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, bitwise_and<T,U> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<bitwise_and<T,U> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="bitwise_or"><template>
+ </template><purpose>A metafunction for generating logical-and expression types, a grammar element for matching logical-and expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::logical_and</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="bitwise_and"><template>
       <template-type-parameter name="T"/>
       <template-type-parameter name="U"/>
- </template><purpose>A metafunction for generating bitwise-or expression types, a grammar element for matching bitwise-or expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>bitwise_or</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::bitwise_or</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, bitwise_or<T,U> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<bitwise_or<T,U> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="bitwise_xor"><template>
+ </template><purpose>A metafunction for generating bitwise-and expression types, a grammar element for matching bitwise-and expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::bitwise_and</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="bitwise_or"><template>
       <template-type-parameter name="T"/>
       <template-type-parameter name="U"/>
- </template><purpose>A metafunction for generating bitwise-xor expression types, a grammar element for matching bitwise-xor expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>bitwise_xor</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::bitwise_xor</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, bitwise_xor<T,U> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<bitwise_xor<T,U> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="comma"><template>
+ </template><purpose>A metafunction for generating bitwise-or expression types, a grammar element for matching bitwise-or expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::bitwise_or</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="bitwise_xor"><template>
       <template-type-parameter name="T"/>
       <template-type-parameter name="U"/>
- </template><purpose>A metafunction for generating comma expression types, a grammar element for matching comma expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>comma</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::comma</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, comma<T,U> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<comma<T,U> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="mem_ptr"><template>
+ </template><purpose>A metafunction for generating bitwise-xor expression types, a grammar element for matching bitwise-xor expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::bitwise_xor</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="comma"><template>
       <template-type-parameter name="T"/>
       <template-type-parameter name="U"/>
- </template><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>mem_ptr</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::mem_ptr</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, mem_ptr<T,U> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<mem_ptr<T,U> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="assign"><template>
+ </template><purpose>A metafunction for generating comma expression types, a grammar element for matching comma expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::comma</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="mem_ptr"><template>
       <template-type-parameter name="T"/>
       <template-type-parameter name="U"/>
- </template><purpose>A metafunction for generating assignment expression types, a grammar element for matching assignment expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>assign</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::assign</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, assign<T,U> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<assign<T,U> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="shift_left_assign"><template>
+ </template><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::mem_ptr</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="assign"><template>
       <template-type-parameter name="T"/>
       <template-type-parameter name="U"/>
- </template><purpose>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 <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>shift_left_assign</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::shift_left_assign</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, shift_left_assign<T,U> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<shift_left_assign<T,U> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="shift_right_assign"><template>
+ </template><purpose>A metafunction for generating assignment expression types, a grammar element for matching assignment expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::assign</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="shift_left_assign"><template>
       <template-type-parameter name="T"/>
       <template-type-parameter name="U"/>
- </template><purpose>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 <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>shift_right_assign</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::shift_right_assign</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, shift_right_assign<T,U> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<shift_right_assign<T,U> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="multiplies_assign"><template>
+ </template><purpose>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 <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::shift_left_assign</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="shift_right_assign"><template>
       <template-type-parameter name="T"/>
       <template-type-parameter name="U"/>
- </template><purpose>A metafunction for generating multiplies-assign expression types, a grammar element for matching multiplies-assign expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>multiplies_assign</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::multiplies_assign</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, multiplies_assign<T,U> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<multiplies_assign<T,U> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="divides_assign"><template>
+ </template><purpose>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 <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::shift_right_assign</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="multiplies_assign"><template>
       <template-type-parameter name="T"/>
       <template-type-parameter name="U"/>
- </template><purpose>A metafunction for generating divides-assign expression types, a grammar element for matching divides-assign expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>divides_assign</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::divides_assign</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, divides_assign<T,U> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<divides_assign<T,U> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="modulus_assign"><template>
+ </template><purpose>A metafunction for generating multiplies-assign expression types, a grammar element for matching multiplies-assign expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::multiplies_assign</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="divides_assign"><template>
       <template-type-parameter name="T"/>
       <template-type-parameter name="U"/>
- </template><purpose>A metafunction for generating modulus-assign expression types, a grammar element for matching modulus-assign expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>modulus_assign</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::modulus_assign</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, modulus_assign<T,U> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<modulus_assign<T,U> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="plus_assign"><template>
+ </template><purpose>A metafunction for generating divides-assign expression types, a grammar element for matching divides-assign expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::divides_assign</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="modulus_assign"><template>
       <template-type-parameter name="T"/>
       <template-type-parameter name="U"/>
- </template><purpose>A metafunction for generating plus-assign expression types, a grammar element for matching plus-assign expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>plus_assign</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::plus_assign</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, plus_assign<T,U> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<plus_assign<T,U> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="minus_assign"><template>
+ </template><purpose>A metafunction for generating modulus-assign expression types, a grammar element for matching modulus-assign expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::modulus_assign</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="plus_assign"><template>
       <template-type-parameter name="T"/>
       <template-type-parameter name="U"/>
- </template><purpose>A metafunction for generating minus-assign expression types, a grammar element for matching minus-assign expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>minus_assign</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::minus_assign</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, minus_assign<T,U> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<minus_assign<T,U> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="bitwise_and_assign"><template>
+ </template><purpose>A metafunction for generating plus-assign expression types, a grammar element for matching plus-assign expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::plus_assign</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="minus_assign"><template>
       <template-type-parameter name="T"/>
       <template-type-parameter name="U"/>
- </template><purpose>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 <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>bitwise_and_assign</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::bitwise_and_assign</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, bitwise_and_assign<T,U> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<bitwise_and_assign<T,U> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="bitwise_or_assign"><template>
+ </template><purpose>A metafunction for generating minus-assign expression types, a grammar element for matching minus-assign expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::minus_assign</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="bitwise_and_assign"><template>
       <template-type-parameter name="T"/>
       <template-type-parameter name="U"/>
- </template><purpose>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 <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>bitwise_or_assign</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::bitwise_or_assign</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, bitwise_or_assign<T,U> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<bitwise_or_assign<T,U> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="bitwise_xor_assign"><template>
+ </template><purpose>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 <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::bitwise_and_assign</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="bitwise_or_assign"><template>
       <template-type-parameter name="T"/>
       <template-type-parameter name="U"/>
- </template><purpose>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 <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>bitwise_xor_assign</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::bitwise_xor_assign</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, bitwise_xor_assign<T,U> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<bitwise_xor_assign<T,U> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct name="subscript"><template>
+ </template><purpose>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 <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::bitwise_or_assign</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="bitwise_xor_assign"><template>
       <template-type-parameter name="T"/>
       <template-type-parameter name="U"/>
- </template><purpose>A metafunction for generating subscript expression types, a grammar element for matching subscript expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< <classname>subscript</classname> >::template <classname>result</classname>< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result</classname>< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, subscript<T,U> >::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<subscript<T,U> >()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct-specialization name="function"><template>
+ </template><purpose>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 <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::bitwise_xor_assign</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct name="subscript"><template>
+ <template-type-parameter name="T"/>
+ <template-type-parameter name="U"/>
+ </template><purpose>A metafunction for generating subscript expression types, a grammar element for matching subscript expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::subscript</classname>, <classname>list2</classname>< T, U > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef></struct><struct-specialization name="function"><template>
       <template-type-parameter name="A0"/>
- </template><specialization><template-arg>A0</template-arg><template-arg>void</template-arg><template-arg>void</template-arg><template-arg>void</template-arg><template-arg>void</template-arg><template-arg>void</template-arg></specialization><purpose>A metafunction for generating function-call expression types, a grammar element for matching function-call expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< function >::template result< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::function</classname>, <classname>list1</classname>< A0 > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><typedef name="proto_child0"><type>A0</type></typedef><typedef name="proto_child1"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="proto_child2"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="proto_child3"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="proto_child4"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, function>::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<function>()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct-specialization><struct-specialization name="nary_expr"><template>
+ </template><specialization><template-arg>A0</template-arg><template-arg>void</template-arg><template-arg>void</template-arg><template-arg>void</template-arg><template-arg>void</template-arg><template-arg>void</template-arg></specialization><purpose>A metafunction for generating function-call expression types, a grammar element for matching function-call expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::function</classname>, <classname>list1</classname>< A0 > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><typedef name="proto_child0"><type>A0</type></typedef><typedef name="proto_child1"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="proto_child2"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="proto_child3"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="proto_child4"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><struct-specialization name="nary_expr"><template>
       <template-type-parameter name="Tag"/>
       <template-type-parameter name="A0"/>
- </template><specialization><template-arg>Tag</template-arg><template-arg>A0</template-arg><template-arg>void</template-arg><template-arg>void</template-arg><template-arg>void</template-arg><template-arg>void</template-arg><template-arg>void</template-arg></specialization><purpose>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 <computeroutput>pass_through<></computeroutput> transform. </purpose><description><para>Use <computeroutput>nary_expr<_, vararg<_> ></computeroutput> as a grammar element to match any n-ary expression; that is, any non-terminal. </para></description><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< nary_expr >::template result< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< Tag, <classname>list1</classname>< A0 > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><typedef name="proto_child0"><type>A0</type></typedef><typedef name="proto_child1"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="proto_child2"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="proto_child3"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="proto_child4"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, nary_expr>::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<nary_expr>()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct-specialization><struct-specialization name="function"><template>
+ </template><specialization><template-arg>Tag</template-arg><template-arg>A0</template-arg><template-arg>void</template-arg><template-arg>void</template-arg><template-arg>void</template-arg><template-arg>void</template-arg><template-arg>void</template-arg></specialization><purpose>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 <computeroutput>pass_through<></computeroutput> transform. </purpose><description><para>Use <computeroutput>nary_expr<_, vararg<_> ></computeroutput> as a grammar element to match any n-ary expression; that is, any non-terminal. </para></description><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< Tag, <classname>list1</classname>< A0 > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><typedef name="proto_child0"><type>A0</type></typedef><typedef name="proto_child1"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="proto_child2"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="proto_child3"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="proto_child4"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><struct-specialization name="function"><template>
       <template-type-parameter name="A0"/>
       <template-type-parameter name="A1"/>
- </template><specialization><template-arg>A0</template-arg><template-arg>A1</template-arg><template-arg>void</template-arg><template-arg>void</template-arg><template-arg>void</template-arg><template-arg>void</template-arg></specialization><purpose>A metafunction for generating function-call expression types, a grammar element for matching function-call expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< function >::template result< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::function</classname>, <classname>list2</classname>< A0, A1 > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><typedef name="proto_child0"><type>A0</type></typedef><typedef name="proto_child1"><type>A1</type></typedef><typedef name="proto_child2"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="proto_child3"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="proto_child4"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, function>::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<function>()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct-specialization><struct-specialization name="nary_expr"><template>
+ </template><specialization><template-arg>A0</template-arg><template-arg>A1</template-arg><template-arg>void</template-arg><template-arg>void</template-arg><template-arg>void</template-arg><template-arg>void</template-arg></specialization><purpose>A metafunction for generating function-call expression types, a grammar element for matching function-call expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::function</classname>, <classname>list2</classname>< A0, A1 > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><typedef name="proto_child0"><type>A0</type></typedef><typedef name="proto_child1"><type>A1</type></typedef><typedef name="proto_child2"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="proto_child3"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="proto_child4"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><struct-specialization name="nary_expr"><template>
       <template-type-parameter name="Tag"/>
       <template-type-parameter name="A0"/>
       <template-type-parameter name="A1"/>
- </template><specialization><template-arg>Tag</template-arg><template-arg>A0</template-arg><template-arg>A1</template-arg><template-arg>void</template-arg><template-arg>void</template-arg><template-arg>void</template-arg><template-arg>void</template-arg></specialization><purpose>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 <computeroutput>pass_through<></computeroutput> transform. </purpose><description><para>Use <computeroutput>nary_expr<_, vararg<_> ></computeroutput> as a grammar element to match any n-ary expression; that is, any non-terminal. </para></description><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< nary_expr >::template result< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< Tag, <classname>list2</classname>< A0, A1 > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><typedef name="proto_child0"><type>A0</type></typedef><typedef name="proto_child1"><type>A1</type></typedef><typedef name="proto_child2"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="proto_child3"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="proto_child4"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, nary_expr>::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<nary_expr>()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct-specialization><struct-specialization name="function"><template>
+ </template><specialization><template-arg>Tag</template-arg><template-arg>A0</template-arg><template-arg>A1</template-arg><template-arg>void</template-arg><template-arg>void</template-arg><template-arg>void</template-arg><template-arg>void</template-arg></specialization><purpose>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 <computeroutput>pass_through<></computeroutput> transform. </purpose><description><para>Use <computeroutput>nary_expr<_, vararg<_> ></computeroutput> as a grammar element to match any n-ary expression; that is, any non-terminal. </para></description><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< Tag, <classname>list2</classname>< A0, A1 > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><typedef name="proto_child0"><type>A0</type></typedef><typedef name="proto_child1"><type>A1</type></typedef><typedef name="proto_child2"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="proto_child3"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="proto_child4"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><struct-specialization name="function"><template>
       <template-type-parameter name="A0"/>
       <template-type-parameter name="A1"/>
       <template-type-parameter name="A2"/>
- </template><specialization><template-arg>A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>void</template-arg><template-arg>void</template-arg><template-arg>void</template-arg></specialization><purpose>A metafunction for generating function-call expression types, a grammar element for matching function-call expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< function >::template result< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::function</classname>, <classname>list3</classname>< A0, A1, A2 > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><typedef name="proto_child0"><type>A0</type></typedef><typedef name="proto_child1"><type>A1</type></typedef><typedef name="proto_child2"><type>A2</type></typedef><typedef name="proto_child3"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="proto_child4"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, function>::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<function>()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct-specialization><struct-specialization name="nary_expr"><template>
+ </template><specialization><template-arg>A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>void</template-arg><template-arg>void</template-arg><template-arg>void</template-arg></specialization><purpose>A metafunction for generating function-call expression types, a grammar element for matching function-call expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::function</classname>, <classname>list3</classname>< A0, A1, A2 > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><typedef name="proto_child0"><type>A0</type></typedef><typedef name="proto_child1"><type>A1</type></typedef><typedef name="proto_child2"><type>A2</type></typedef><typedef name="proto_child3"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="proto_child4"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><struct-specialization name="nary_expr"><template>
       <template-type-parameter name="Tag"/>
       <template-type-parameter name="A0"/>
       <template-type-parameter name="A1"/>
       <template-type-parameter name="A2"/>
- </template><specialization><template-arg>Tag</template-arg><template-arg>A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>void</template-arg><template-arg>void</template-arg><template-arg>void</template-arg></specialization><purpose>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 <computeroutput>pass_through<></computeroutput> transform. </purpose><description><para>Use <computeroutput>nary_expr<_, vararg<_> ></computeroutput> as a grammar element to match any n-ary expression; that is, any non-terminal. </para></description><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< nary_expr >::template result< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< Tag, <classname>list3</classname>< A0, A1, A2 > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><typedef name="proto_child0"><type>A0</type></typedef><typedef name="proto_child1"><type>A1</type></typedef><typedef name="proto_child2"><type>A2</type></typedef><typedef name="proto_child3"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="proto_child4"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, nary_expr>::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<nary_expr>()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct-specialization><struct-specialization name="function"><template>
+ </template><specialization><template-arg>Tag</template-arg><template-arg>A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>void</template-arg><template-arg>void</template-arg><template-arg>void</template-arg></specialization><purpose>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 <computeroutput>pass_through<></computeroutput> transform. </purpose><description><para>Use <computeroutput>nary_expr<_, vararg<_> ></computeroutput> as a grammar element to match any n-ary expression; that is, any non-terminal. </para></description><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< Tag, <classname>list3</classname>< A0, A1, A2 > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><typedef name="proto_child0"><type>A0</type></typedef><typedef name="proto_child1"><type>A1</type></typedef><typedef name="proto_child2"><type>A2</type></typedef><typedef name="proto_child3"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="proto_child4"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><struct-specialization name="function"><template>
       <template-type-parameter name="A0"/>
       <template-type-parameter name="A1"/>
       <template-type-parameter name="A2"/>
       <template-type-parameter name="A3"/>
- </template><specialization><template-arg>A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3</template-arg><template-arg>void</template-arg><template-arg>void</template-arg></specialization><purpose>A metafunction for generating function-call expression types, a grammar element for matching function-call expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< function >::template result< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::function</classname>, <classname>list4</classname>< A0, A1, A2, A3 > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><typedef name="proto_child0"><type>A0</type></typedef><typedef name="proto_child1"><type>A1</type></typedef><typedef name="proto_child2"><type>A2</type></typedef><typedef name="proto_child3"><type>A3</type></typedef><typedef name="proto_child4"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, function>::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<function>()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct-specialization><struct-specialization name="nary_expr"><template>
+ </template><specialization><template-arg>A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3</template-arg><template-arg>void</template-arg><template-arg>void</template-arg></specialization><purpose>A metafunction for generating function-call expression types, a grammar element for matching function-call expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::function</classname>, <classname>list4</classname>< A0, A1, A2, A3 > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><typedef name="proto_child0"><type>A0</type></typedef><typedef name="proto_child1"><type>A1</type></typedef><typedef name="proto_child2"><type>A2</type></typedef><typedef name="proto_child3"><type>A3</type></typedef><typedef name="proto_child4"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><struct-specialization name="nary_expr"><template>
       <template-type-parameter name="Tag"/>
       <template-type-parameter name="A0"/>
       <template-type-parameter name="A1"/>
       <template-type-parameter name="A2"/>
       <template-type-parameter name="A3"/>
- </template><specialization><template-arg>Tag</template-arg><template-arg>A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3</template-arg><template-arg>void</template-arg><template-arg>void</template-arg></specialization><purpose>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 <computeroutput>pass_through<></computeroutput> transform. </purpose><description><para>Use <computeroutput>nary_expr<_, vararg<_> ></computeroutput> as a grammar element to match any n-ary expression; that is, any non-terminal. </para></description><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< nary_expr >::template result< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< Tag, <classname>list4</classname>< A0, A1, A2, A3 > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><typedef name="proto_child0"><type>A0</type></typedef><typedef name="proto_child1"><type>A1</type></typedef><typedef name="proto_child2"><type>A2</type></typedef><typedef name="proto_child3"><type>A3</type></typedef><typedef name="proto_child4"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, nary_expr>::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<nary_expr>()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct-specialization><struct-specialization name="function"><template>
+ </template><specialization><template-arg>Tag</template-arg><template-arg>A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3</template-arg><template-arg>void</template-arg><template-arg>void</template-arg></specialization><purpose>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 <computeroutput>pass_through<></computeroutput> transform. </purpose><description><para>Use <computeroutput>nary_expr<_, vararg<_> ></computeroutput> as a grammar element to match any n-ary expression; that is, any non-terminal. </para></description><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< Tag, <classname>list4</classname>< A0, A1, A2, A3 > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><typedef name="proto_child0"><type>A0</type></typedef><typedef name="proto_child1"><type>A1</type></typedef><typedef name="proto_child2"><type>A2</type></typedef><typedef name="proto_child3"><type>A3</type></typedef><typedef name="proto_child4"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><struct-specialization name="function"><template>
       <template-type-parameter name="A0"/>
       <template-type-parameter name="A1"/>
       <template-type-parameter name="A2"/>
       <template-type-parameter name="A3"/>
       <template-type-parameter name="A4"/>
- </template><specialization><template-arg>A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3</template-arg><template-arg>A4</template-arg><template-arg>void</template-arg></specialization><purpose>A metafunction for generating function-call expression types, a grammar element for matching function-call expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< function >::template result< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::function</classname>, <classname>list5</classname>< A0, A1, A2, A3, A4 > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><typedef name="proto_child0"><type>A0</type></typedef><typedef name="proto_child1"><type>A1</type></typedef><typedef name="proto_child2"><type>A2</type></typedef><typedef name="proto_child3"><type>A3</type></typedef><typedef name="proto_child4"><type>A4</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, function>::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<function>()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct-specialization><struct-specialization name="nary_expr"><template>
+ </template><specialization><template-arg>A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3</template-arg><template-arg>A4</template-arg><template-arg>void</template-arg></specialization><purpose>A metafunction for generating function-call expression types, a grammar element for matching function-call expressions, and a PrimitiveTransform that dispatches to the <computeroutput>pass_through<></computeroutput> transform. </purpose><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< <classname>proto::tag::function</classname>, <classname>list5</classname>< A0, A1, A2, A3, A4 > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><typedef name="proto_child0"><type>A0</type></typedef><typedef name="proto_child1"><type>A1</type></typedef><typedef name="proto_child2"><type>A2</type></typedef><typedef name="proto_child3"><type>A3</type></typedef><typedef name="proto_child4"><type>A4</type></typedef></struct-specialization><struct-specialization name="nary_expr"><template>
       <template-type-parameter name="Tag"/>
       <template-type-parameter name="A0"/>
       <template-type-parameter name="A1"/>
       <template-type-parameter name="A2"/>
       <template-type-parameter name="A3"/>
       <template-type-parameter name="A4"/>
- </template><specialization><template-arg>Tag</template-arg><template-arg>A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3</template-arg><template-arg>A4</template-arg><template-arg>void</template-arg></specialization><purpose>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 <computeroutput>pass_through<></computeroutput> transform. </purpose><description><para>Use <computeroutput>nary_expr<_, vararg<_> ></computeroutput> as a grammar element to match any n-ary expression; that is, any non-terminal. </para></description><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template><typedef name="type"><type><classname>pass_through</classname>< nary_expr >::template result< Sig >::type</type></typedef></struct><typedef name="type"><type>proto::expr< Tag, <classname>list5</classname>< A0, A1, A2, A3, A4 > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><typedef name="proto_child0"><type>A0</type></typedef><typedef name="proto_child1"><type>A1</type></typedef><typedef name="proto_child2"><type>A2</type></typedef><typedef name="proto_child3"><type>A3</type></typedef><typedef name="proto_child4"><type>A4</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-
-</para></description><requires><para><computeroutput>matches<Expr, nary_expr>::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires><returns><para><computeroutput>pass_through<nary_expr>()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct-specialization></namespace><namespace name="result_of"><struct name="is_expr"><template>
+ </template><specialization><template-arg>Tag</template-arg><template-arg>A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3</template-arg><template-arg>A4</template-arg><template-arg>void</template-arg></specialization><purpose>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 <computeroutput>pass_through<></computeroutput> transform. </purpose><description><para>Use <computeroutput>nary_expr<_, vararg<_> ></computeroutput> as a grammar element to match any n-ary expression; that is, any non-terminal. </para></description><struct name="impl"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template></struct><typedef name="type"><type>proto::expr< Tag, <classname>list5</classname>< A0, A1, A2, A3, A4 > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><typedef name="proto_child0"><type>A0</type></typedef><typedef name="proto_child1"><type>A1</type></typedef><typedef name="proto_child2"><type>A2</type></typedef><typedef name="proto_child3"><type>A3</type></typedef><typedef name="proto_child4"><type>A4</type></typedef></struct-specialization></namespace><namespace name="result_of"><struct name="is_expr"><template>
       <template-type-parameter name="T"/>
       <template-type-parameter name="Void"><default>void</default></template-type-parameter>
     </template><inherit access="public">boost::mpl::false_</inherit><purpose>A Boolean metafunction that indicates whether a given type <computeroutput>T</computeroutput> is a Proto expression type. </purpose><description><para>If <computeroutput>T</computeroutput> has a nested type <computeroutput>proto_is_expr_</computeroutput> that is a typedef for <computeroutput>void</computeroutput>, <computeroutput>is_expr<T>::value</computeroutput> is <computeroutput>true</computeroutput>. (Note, this is the case for <computeroutput>proto::expr<></computeroutput>, any type that is derived from <computeroutput>proto::extends<></computeroutput> or that uses the <computeroutput>BOOST_PROTO_BASIC_EXTENDS()</computeroutput> macro.) Otherwise, <computeroutput>is_expr<T>::value</computeroutput> is <computeroutput>false</computeroutput>. </para></description></struct><struct-specialization name="is_expr"><template>
@@ -2390,213 +2481,219 @@
       <template-type-parameter name="T"/>
       <template-type-parameter name="Domain"><default>default_domain</default></template-type-parameter>
       <template-type-parameter name="Void"><default>void</default></template-type-parameter>
- </template><purpose>A metafunction that computes the return type of the <computeroutput>as_child()</computeroutput> function. </purpose><description><para>The <computeroutput>as_child<></computeroutput> metafunction turns types into Proto types, if they are not already, by making them Proto terminals held by reference. Types which are already Proto types are wrapped in <computeroutput>proto::ref_<></computeroutput>.</para><para>This specialization is selected when the type is not yet a Proto type. The result type <computeroutput>as_child<T, Domain>::type</computeroutput> is <computeroutput>boost::result_of<Domain(expr< tag::terminal, term<T &> >)>::type</computeroutput>. </para></description><typedef name="expr_"><type>proto::expr< <classname>proto::tag::terminal</classname>, <classname>term</classname>< T & > ></type></typedef><typedef name="type"><type>Domain::template result< void(expr_)>::type</type></typedef><method-group name="public st
atic functions"/></struct><struct-specialization name="as_child"><template>
+ </template><purpose>A metafunction that computes the return type of the <computeroutput>as_child()</computeroutput> function. </purpose><description><para>The <computeroutput>as_child<></computeroutput> metafunction turns types into Proto types, if they are not already, by making them Proto terminals held by reference. Types which are already Proto types are returned by reference.</para><para>This specialization is selected when the type is not yet a Proto type. The result type <computeroutput>as_child<T, Domain>::type</computeroutput> is <computeroutput>boost::result_of<Domain(expr< tag::terminal, term<T &> >)>::type</computeroutput>. </para></description><typedef name="expr_"><type>proto::expr< <classname>proto::tag::terminal</classname>, <classname>term</classname>< T & > ></type></typedef><typedef name="type"><type>Domain::template result< void(expr_)>::type</type></typedef><method-group name="public static functions"/></struct><struct-speciali
zation name="as_child"><template>
       <template-type-parameter name="T"/>
       <template-type-parameter name="Domain"/>
- </template><specialization><template-arg>T</template-arg><template-arg>Domain</template-arg><template-arg>typename T::proto_is_expr_</template-arg></specialization><purpose>A metafunction that computes the return type of the <computeroutput>as_child()</computeroutput> function. </purpose><description><para>The <computeroutput>as_child<></computeroutput> metafunction turns types into Proto types, if they are not already, by making them Proto terminals held by reference. Types which are already Proto types are wrapped in <computeroutput>proto::ref_<></computeroutput>.</para><para>This specialization is selected when the type is already a Proto type. The result type <computeroutput>as_child<T, Domain>::type</computeroutput> is <computeroutput>proto::ref_<T></computeroutput>. </para></description><typedef name="expr_"><type><classname>ref_</classname>< T ></type></typedef><typedef name="type"><type>Domain::template result< void(<classname>expr_</classname>)>::type</type><
/typedef><method-group name="public static functions"/></struct-specialization><struct-specialization name="as_child"><template>
+ </template><specialization><template-arg>T</template-arg><template-arg>Domain</template-arg><template-arg>typename T::proto_is_expr_</template-arg></specialization><purpose>A metafunction that computes the return type of the <computeroutput>as_child()</computeroutput> function. </purpose><description><para>The <computeroutput>as_child<></computeroutput> metafunction turns types into Proto types, if they are not already, by making them Proto terminals held by reference. Types which are already Proto types are returned by reference.</para><para>This specialization is selected when the type is already a Proto type. The result type <computeroutput>as_child<T, Domain>::type</computeroutput> is <computeroutput>T &</computeroutput>. </para></description><typedef name="type"><type>Domain::template result< void(T)>::type</type></typedef><method-group name="public static functions"/></struct-specialization><struct-specialization name="as_child"><template>
       <template-type-parameter name="T"/>
- </template><specialization><template-arg>T</template-arg><template-arg>typename T::proto_domain</template-arg><template-arg>typename T::proto_is_expr_</template-arg></specialization><purpose>A metafunction that computes the return type of the <computeroutput>as_child()</computeroutput> function. </purpose><description><para>The <computeroutput>as_child<></computeroutput> metafunction turns types into Proto types, if they are not already, by making them Proto terminals held by reference. Types which are already Proto types are wrapped in <computeroutput>proto::ref_<></computeroutput>.</para><para>This specialization is selected when the type is already a Proto type. The result type <computeroutput>as_child<T, Domain>::type</computeroutput> is <computeroutput>proto::ref_<T></computeroutput>. </para></description><typedef name="type"><type><classname>ref_</classname>< T ></type></typedef><method-group name="public static functions"/></struct-specialization><struct name="child"
><template>
+ </template><specialization><template-arg>T</template-arg><template-arg>typename T::proto_domain</template-arg><template-arg>typename T::proto_is_expr_</template-arg></specialization><purpose>A metafunction that computes the return type of the <computeroutput>as_child()</computeroutput> function. </purpose><description><para>The <computeroutput>as_child<></computeroutput> metafunction turns types into Proto types, if they are not already, by making them Proto terminals held by reference. Types which are already Proto types are returned by reference.</para><para>This specialization is selected when the type is already a Proto type. The result type <computeroutput>as_child<T, Domain>::type</computeroutput> is <computeroutput>T &</computeroutput>. </para></description><typedef name="type"><type>T &</type></typedef><method-group name="public static functions"/></struct-specialization><struct name="child"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="N"><default>mpl::long_<0></default></template-type-parameter>
     </template><purpose>A metafunction that returns the type of the Nth child of a Proto expression, where N is an MPL Integral Constant. </purpose><description><para><computeroutput>result_of::child<Expr, N></computeroutput> is equivalent to <computeroutput>result_of::child_c<Expr, N::value></computeroutput>. </para></description></struct><struct name="value"><template>
       <template-type-parameter name="Expr"/>
- </template><purpose>A metafunction that returns the type of the value of a terminal Proto expression. </purpose><typedef name="wrapped_type"><type>Expr::proto_child0</type></typedef><typedef name="type"><type><classname>unref</classname>< wrapped_type >::type</type></typedef><typedef name="reference"><type><classname>unref</classname>< wrapped_type >::reference</type></typedef><typedef name="const_reference"><type><classname>unref</classname>< wrapped_type >::const_reference</type></typedef></struct><struct name="left"><template>
+ </template><inherit access="public">boost::proto::result_of::child_c< Expr, 0 ></inherit><purpose>A metafunction that returns the type of the value of a terminal Proto expression. </purpose></struct><struct name="left"><template>
       <template-type-parameter name="Expr"/>
- </template><purpose>A metafunction that returns the type of the left child of a binary Proto expression. </purpose><description><para><computeroutput>result_of::left<Expr></computeroutput> is equivalent to <computeroutput>result_of::child_c<Expr, 0></computeroutput>. </para></description><typedef name="wrapped_type"><type>Expr::proto_child0</type></typedef><typedef name="type"><type><classname>unref</classname>< wrapped_type >::type</type></typedef><typedef name="reference"><type><classname>unref</classname>< wrapped_type >::reference</type></typedef><typedef name="const_reference"><type><classname>unref</classname>< wrapped_type >::const_reference</type></typedef></struct><struct name="right"><template>
+ </template><inherit access="public">boost::proto::result_of::child_c< Expr, 0 ></inherit><purpose>A metafunction that returns the type of the left child of a binary Proto expression. </purpose><description><para><computeroutput>result_of::left<Expr></computeroutput> is equivalent to <computeroutput>result_of::child_c<Expr, 0></computeroutput>. </para></description></struct><struct name="right"><template>
       <template-type-parameter name="Expr"/>
- </template><purpose>A metafunction that returns the type of the right child of a binary Proto expression. </purpose><description><para><computeroutput>result_of::right<Expr></computeroutput> is equivalent to <computeroutput>result_of::child_c<Expr, 1></computeroutput>. </para></description><typedef name="wrapped_type"><type>Expr::proto_child1</type></typedef><typedef name="type"><type><classname>unref</classname>< wrapped_type >::type</type></typedef><typedef name="reference"><type><classname>unref</classname>< wrapped_type >::reference</type></typedef><typedef name="const_reference"><type><classname>unref</classname>< wrapped_type >::const_reference</type></typedef></struct><struct-specialization name="child_c"><template>
+ </template><inherit access="public">boost::proto::result_of::child_c< Expr, 1 ></inherit><purpose>A metafunction that returns the type of the right child of a binary Proto expression. </purpose><description><para><computeroutput>result_of::right<Expr></computeroutput> is equivalent to <computeroutput>result_of::child_c<Expr, 1></computeroutput>. </para></description></struct><struct-specialization name="child_c"><template>
       <template-type-parameter name="Expr"/>
- </template><specialization><template-arg>Expr</template-arg><template-arg>0</template-arg></specialization><purpose>A metafunction that returns the type of the Nth child of a Proto expression. </purpose><description><para>A metafunction that returns the type of the Nth child of a Proto expression. <computeroutput>N</computeroutput> must be 0 or less than <computeroutput>Expr::proto_arity::value</computeroutput>. </para></description><typedef name="wrapped_type"><description><para>The raw type of the Nth child as it is stored within <computeroutput>Expr</computeroutput>. This may be a value, a reference, or a Proto <computeroutput>ref_<></computeroutput> wrapper. </para></description><type>Expr::proto_child0</type></typedef><typedef name="type"><description><para>The "value" type of the child, suitable for return by value, computed as follows: <itemizedlist>
-<listitem><para><computeroutput>ref_<T const></computeroutput> becomes <computeroutput>T</computeroutput> </para></listitem>
-<listitem><para><computeroutput>ref_<T></computeroutput> becomes <computeroutput>T</computeroutput> </para></listitem>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>0</template-arg></specialization><purpose>A metafunction that returns the type of the Nth child of a Proto expression. </purpose><description><para>A metafunction that returns the type of the Nth child of a Proto expression. <computeroutput>N</computeroutput> must be 0 or less than <computeroutput>Expr::proto_arity::value</computeroutput>. </para></description><typedef name="value_type"><description><para>The raw type of the Nth child as it is stored within <computeroutput>Expr</computeroutput>. This may be a value or a reference </para></description><type>Expr::proto_child0</type></typedef><typedef name="type"><description><para>The "value" type of the child, suitable for return by value, computed as follows: <itemizedlist>
<listitem><para><computeroutput>T const(&)[N]</computeroutput> becomes <computeroutput>T const(&)[N]</computeroutput> </para></listitem>
+<listitem><para><computeroutput>T[N]</computeroutput> becomes <computeroutput>T(&)[N]</computeroutput> </para></listitem>
<listitem><para><computeroutput>T(&)[N]</computeroutput> becomes <computeroutput>T(&)[N]</computeroutput> </para></listitem>
<listitem><para><computeroutput>R(&)(A0,...)</computeroutput> becomes <computeroutput>R(&)(A0,...)</computeroutput> </para></listitem>
<listitem><para><computeroutput>T const &</computeroutput> becomes <computeroutput>T</computeroutput> </para></listitem>
<listitem><para><computeroutput>T &</computeroutput> becomes <computeroutput>T</computeroutput> </para></listitem>
<listitem><para><computeroutput>T</computeroutput> becomes <computeroutput>T</computeroutput> </para></listitem>
</itemizedlist>
-</para></description><type><classname>unref</classname>< wrapped_type >::type</type></typedef><typedef name="reference"><description><para>The "reference" type of the child, suitable for return by reference, computed as follows: <itemizedlist>
-<listitem><para><computeroutput>ref_<T const></computeroutput> becomes <computeroutput>T const &</computeroutput> </para></listitem>
-<listitem><para><computeroutput>ref_<T></computeroutput> becomes <computeroutput>T &</computeroutput> </para></listitem>
+</para></description><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><struct-specialization name="child_c"><template>
+ <template-type-parameter name="Expr"/>
+ </template><specialization><template-arg>Expr &</template-arg><template-arg>0</template-arg></specialization><typedef name="value_type"><description><para>The raw type of the Nth child as it is stored within <computeroutput>Expr</computeroutput>. This may be a value or a reference </para></description><type>Expr::proto_child0</type></typedef><typedef name="type"><description><para>The "reference" type of the child, suitable for return by reference, computed as follows: <itemizedlist>
<listitem><para><computeroutput>T const(&)[N]</computeroutput> becomes <computeroutput>T const(&)[N]</computeroutput> </para></listitem>
+<listitem><para><computeroutput>T[N]</computeroutput> becomes <computeroutput>T(&)[N]</computeroutput> </para></listitem>
<listitem><para><computeroutput>T(&)[N]</computeroutput> becomes <computeroutput>T(&)[N]</computeroutput> </para></listitem>
<listitem><para><computeroutput>R(&)(A0,...)</computeroutput> becomes <computeroutput>R(&)(A0,...)</computeroutput> </para></listitem>
<listitem><para><computeroutput>T const &</computeroutput> becomes <computeroutput>T const &</computeroutput> </para></listitem>
<listitem><para><computeroutput>T &</computeroutput> becomes <computeroutput>T &</computeroutput> </para></listitem>
<listitem><para><computeroutput>T</computeroutput> becomes <computeroutput>T &</computeroutput> </para></listitem>
</itemizedlist>
-</para></description><type><classname>unref</classname>< wrapped_type >::reference</type></typedef><typedef name="const_reference"><description><para>The "const reference" type of the child, suitable for return by const reference, computed as follows: <itemizedlist>
-<listitem><para><computeroutput>ref_<T const></computeroutput> becomes <computeroutput>T const &</computeroutput> </para></listitem>
-<listitem><para><computeroutput>ref_<T></computeroutput> becomes <computeroutput>T &</computeroutput> </para></listitem>
+</para></description><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public static functions"/></struct-specialization><struct-specialization name="child_c"><template>
+ <template-type-parameter name="Expr"/>
+ </template><specialization><template-arg>Expr const &</template-arg><template-arg>0</template-arg></specialization><typedef name="value_type"><description><para>The raw type of the Nth child as it is stored within <computeroutput>Expr</computeroutput>. This may be a value or a reference </para></description><type>Expr::proto_child0</type></typedef><typedef name="type"><description><para>The "const reference" type of the child, suitable for return by const reference, computed as follows: <itemizedlist>
<listitem><para><computeroutput>T const(&)[N]</computeroutput> becomes <computeroutput>T const(&)[N]</computeroutput> </para></listitem>
+<listitem><para><computeroutput>T[N]</computeroutput> becomes <computeroutput>T const(&)[N]</computeroutput> </para></listitem>
<listitem><para><computeroutput>T(&)[N]</computeroutput> becomes <computeroutput>T(&)[N]</computeroutput> </para></listitem>
<listitem><para><computeroutput>R(&)(A0,...)</computeroutput> becomes <computeroutput>R(&)(A0,...)</computeroutput> </para></listitem>
<listitem><para><computeroutput>T const &</computeroutput> becomes <computeroutput>T const &</computeroutput> </para></listitem>
<listitem><para><computeroutput>T &</computeroutput> becomes <computeroutput>T &</computeroutput> </para></listitem>
<listitem><para><computeroutput>T</computeroutput> becomes <computeroutput>T const &</computeroutput> </para></listitem>
</itemizedlist>
-</para></description><type><classname>unref</classname>< wrapped_type >::const_reference</type></typedef><method-group name="public static functions"/></struct-specialization><struct-specialization name="child_c"><template>
+</para></description><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public static functions"/></struct-specialization><struct-specialization name="child_c"><template>
       <template-type-parameter name="Expr"/>
- </template><specialization><template-arg>Expr</template-arg><template-arg>1</template-arg></specialization><purpose>A metafunction that returns the type of the Nth child of a Proto expression. </purpose><description><para>A metafunction that returns the type of the Nth child of a Proto expression. <computeroutput>N</computeroutput> must be 0 or less than <computeroutput>Expr::proto_arity::value</computeroutput>. </para></description><typedef name="wrapped_type"><description><para>The raw type of the Nth child as it is stored within <computeroutput>Expr</computeroutput>. This may be a value, a reference, or a Proto <computeroutput>ref_<></computeroutput> wrapper. </para></description><type>Expr::proto_child1</type></typedef><typedef name="type"><description><para>The "value" type of the child, suitable for return by value, computed as follows: <itemizedlist>
-<listitem><para><computeroutput>ref_<T const></computeroutput> becomes <computeroutput>T</computeroutput> </para></listitem>
-<listitem><para><computeroutput>ref_<T></computeroutput> becomes <computeroutput>T</computeroutput> </para></listitem>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>1</template-arg></specialization><purpose>A metafunction that returns the type of the Nth child of a Proto expression. </purpose><description><para>A metafunction that returns the type of the Nth child of a Proto expression. <computeroutput>N</computeroutput> must be 0 or less than <computeroutput>Expr::proto_arity::value</computeroutput>. </para></description><typedef name="value_type"><description><para>The raw type of the Nth child as it is stored within <computeroutput>Expr</computeroutput>. This may be a value or a reference </para></description><type>Expr::proto_child1</type></typedef><typedef name="type"><description><para>The "value" type of the child, suitable for return by value, computed as follows: <itemizedlist>
<listitem><para><computeroutput>T const(&)[N]</computeroutput> becomes <computeroutput>T const(&)[N]</computeroutput> </para></listitem>
+<listitem><para><computeroutput>T[N]</computeroutput> becomes <computeroutput>T(&)[N]</computeroutput> </para></listitem>
<listitem><para><computeroutput>T(&)[N]</computeroutput> becomes <computeroutput>T(&)[N]</computeroutput> </para></listitem>
<listitem><para><computeroutput>R(&)(A0,...)</computeroutput> becomes <computeroutput>R(&)(A0,...)</computeroutput> </para></listitem>
<listitem><para><computeroutput>T const &</computeroutput> becomes <computeroutput>T</computeroutput> </para></listitem>
<listitem><para><computeroutput>T &</computeroutput> becomes <computeroutput>T</computeroutput> </para></listitem>
<listitem><para><computeroutput>T</computeroutput> becomes <computeroutput>T</computeroutput> </para></listitem>
</itemizedlist>
-</para></description><type><classname>unref</classname>< wrapped_type >::type</type></typedef><typedef name="reference"><description><para>The "reference" type of the child, suitable for return by reference, computed as follows: <itemizedlist>
-<listitem><para><computeroutput>ref_<T const></computeroutput> becomes <computeroutput>T const &</computeroutput> </para></listitem>
-<listitem><para><computeroutput>ref_<T></computeroutput> becomes <computeroutput>T &</computeroutput> </para></listitem>
+</para></description><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><struct-specialization name="child_c"><template>
+ <template-type-parameter name="Expr"/>
+ </template><specialization><template-arg>Expr &</template-arg><template-arg>1</template-arg></specialization><typedef name="value_type"><description><para>The raw type of the Nth child as it is stored within <computeroutput>Expr</computeroutput>. This may be a value or a reference </para></description><type>Expr::proto_child1</type></typedef><typedef name="type"><description><para>The "reference" type of the child, suitable for return by reference, computed as follows: <itemizedlist>
<listitem><para><computeroutput>T const(&)[N]</computeroutput> becomes <computeroutput>T const(&)[N]</computeroutput> </para></listitem>
+<listitem><para><computeroutput>T[N]</computeroutput> becomes <computeroutput>T(&)[N]</computeroutput> </para></listitem>
<listitem><para><computeroutput>T(&)[N]</computeroutput> becomes <computeroutput>T(&)[N]</computeroutput> </para></listitem>
<listitem><para><computeroutput>R(&)(A0,...)</computeroutput> becomes <computeroutput>R(&)(A0,...)</computeroutput> </para></listitem>
<listitem><para><computeroutput>T const &</computeroutput> becomes <computeroutput>T const &</computeroutput> </para></listitem>
<listitem><para><computeroutput>T &</computeroutput> becomes <computeroutput>T &</computeroutput> </para></listitem>
<listitem><para><computeroutput>T</computeroutput> becomes <computeroutput>T &</computeroutput> </para></listitem>
</itemizedlist>
-</para></description><type><classname>unref</classname>< wrapped_type >::reference</type></typedef><typedef name="const_reference"><description><para>The "const reference" type of the child, suitable for return by const reference, computed as follows: <itemizedlist>
-<listitem><para><computeroutput>ref_<T const></computeroutput> becomes <computeroutput>T const &</computeroutput> </para></listitem>
-<listitem><para><computeroutput>ref_<T></computeroutput> becomes <computeroutput>T &</computeroutput> </para></listitem>
+</para></description><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public static functions"/></struct-specialization><struct-specialization name="child_c"><template>
+ <template-type-parameter name="Expr"/>
+ </template><specialization><template-arg>Expr const &</template-arg><template-arg>1</template-arg></specialization><typedef name="value_type"><description><para>The raw type of the Nth child as it is stored within <computeroutput>Expr</computeroutput>. This may be a value or a reference </para></description><type>Expr::proto_child1</type></typedef><typedef name="type"><description><para>The "const reference" type of the child, suitable for return by const reference, computed as follows: <itemizedlist>
<listitem><para><computeroutput>T const(&)[N]</computeroutput> becomes <computeroutput>T const(&)[N]</computeroutput> </para></listitem>
+<listitem><para><computeroutput>T[N]</computeroutput> becomes <computeroutput>T const(&)[N]</computeroutput> </para></listitem>
<listitem><para><computeroutput>T(&)[N]</computeroutput> becomes <computeroutput>T(&)[N]</computeroutput> </para></listitem>
<listitem><para><computeroutput>R(&)(A0,...)</computeroutput> becomes <computeroutput>R(&)(A0,...)</computeroutput> </para></listitem>
<listitem><para><computeroutput>T const &</computeroutput> becomes <computeroutput>T const &</computeroutput> </para></listitem>
<listitem><para><computeroutput>T &</computeroutput> becomes <computeroutput>T &</computeroutput> </para></listitem>
<listitem><para><computeroutput>T</computeroutput> becomes <computeroutput>T const &</computeroutput> </para></listitem>
</itemizedlist>
-</para></description><type><classname>unref</classname>< wrapped_type >::const_reference</type></typedef><method-group name="public static functions"/></struct-specialization><struct-specialization name="child_c"><template>
+</para></description><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public static functions"/></struct-specialization><struct-specialization name="child_c"><template>
       <template-type-parameter name="Expr"/>
- </template><specialization><template-arg>Expr</template-arg><template-arg>2</template-arg></specialization><purpose>A metafunction that returns the type of the Nth child of a Proto expression. </purpose><description><para>A metafunction that returns the type of the Nth child of a Proto expression. <computeroutput>N</computeroutput> must be 0 or less than <computeroutput>Expr::proto_arity::value</computeroutput>. </para></description><typedef name="wrapped_type"><description><para>The raw type of the Nth child as it is stored within <computeroutput>Expr</computeroutput>. This may be a value, a reference, or a Proto <computeroutput>ref_<></computeroutput> wrapper. </para></description><type>Expr::proto_child2</type></typedef><typedef name="type"><description><para>The "value" type of the child, suitable for return by value, computed as follows: <itemizedlist>
-<listitem><para><computeroutput>ref_<T const></computeroutput> becomes <computeroutput>T</computeroutput> </para></listitem>
-<listitem><para><computeroutput>ref_<T></computeroutput> becomes <computeroutput>T</computeroutput> </para></listitem>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>2</template-arg></specialization><purpose>A metafunction that returns the type of the Nth child of a Proto expression. </purpose><description><para>A metafunction that returns the type of the Nth child of a Proto expression. <computeroutput>N</computeroutput> must be 0 or less than <computeroutput>Expr::proto_arity::value</computeroutput>. </para></description><typedef name="value_type"><description><para>The raw type of the Nth child as it is stored within <computeroutput>Expr</computeroutput>. This may be a value or a reference </para></description><type>Expr::proto_child2</type></typedef><typedef name="type"><description><para>The "value" type of the child, suitable for return by value, computed as follows: <itemizedlist>
<listitem><para><computeroutput>T const(&)[N]</computeroutput> becomes <computeroutput>T const(&)[N]</computeroutput> </para></listitem>
+<listitem><para><computeroutput>T[N]</computeroutput> becomes <computeroutput>T(&)[N]</computeroutput> </para></listitem>
<listitem><para><computeroutput>T(&)[N]</computeroutput> becomes <computeroutput>T(&)[N]</computeroutput> </para></listitem>
<listitem><para><computeroutput>R(&)(A0,...)</computeroutput> becomes <computeroutput>R(&)(A0,...)</computeroutput> </para></listitem>
<listitem><para><computeroutput>T const &</computeroutput> becomes <computeroutput>T</computeroutput> </para></listitem>
<listitem><para><computeroutput>T &</computeroutput> becomes <computeroutput>T</computeroutput> </para></listitem>
<listitem><para><computeroutput>T</computeroutput> becomes <computeroutput>T</computeroutput> </para></listitem>
</itemizedlist>
-</para></description><type><classname>unref</classname>< wrapped_type >::type</type></typedef><typedef name="reference"><description><para>The "reference" type of the child, suitable for return by reference, computed as follows: <itemizedlist>
-<listitem><para><computeroutput>ref_<T const></computeroutput> becomes <computeroutput>T const &</computeroutput> </para></listitem>
-<listitem><para><computeroutput>ref_<T></computeroutput> becomes <computeroutput>T &</computeroutput> </para></listitem>
+</para></description><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><struct-specialization name="child_c"><template>
+ <template-type-parameter name="Expr"/>
+ </template><specialization><template-arg>Expr &</template-arg><template-arg>2</template-arg></specialization><typedef name="value_type"><description><para>The raw type of the Nth child as it is stored within <computeroutput>Expr</computeroutput>. This may be a value or a reference </para></description><type>Expr::proto_child2</type></typedef><typedef name="type"><description><para>The "reference" type of the child, suitable for return by reference, computed as follows: <itemizedlist>
<listitem><para><computeroutput>T const(&)[N]</computeroutput> becomes <computeroutput>T const(&)[N]</computeroutput> </para></listitem>
+<listitem><para><computeroutput>T[N]</computeroutput> becomes <computeroutput>T(&)[N]</computeroutput> </para></listitem>
<listitem><para><computeroutput>T(&)[N]</computeroutput> becomes <computeroutput>T(&)[N]</computeroutput> </para></listitem>
<listitem><para><computeroutput>R(&)(A0,...)</computeroutput> becomes <computeroutput>R(&)(A0,...)</computeroutput> </para></listitem>
<listitem><para><computeroutput>T const &</computeroutput> becomes <computeroutput>T const &</computeroutput> </para></listitem>
<listitem><para><computeroutput>T &</computeroutput> becomes <computeroutput>T &</computeroutput> </para></listitem>
<listitem><para><computeroutput>T</computeroutput> becomes <computeroutput>T &</computeroutput> </para></listitem>
</itemizedlist>
-</para></description><type><classname>unref</classname>< wrapped_type >::reference</type></typedef><typedef name="const_reference"><description><para>The "const reference" type of the child, suitable for return by const reference, computed as follows: <itemizedlist>
-<listitem><para><computeroutput>ref_<T const></computeroutput> becomes <computeroutput>T const &</computeroutput> </para></listitem>
-<listitem><para><computeroutput>ref_<T></computeroutput> becomes <computeroutput>T &</computeroutput> </para></listitem>
+</para></description><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public static functions"/></struct-specialization><struct-specialization name="child_c"><template>
+ <template-type-parameter name="Expr"/>
+ </template><specialization><template-arg>Expr const &</template-arg><template-arg>2</template-arg></specialization><typedef name="value_type"><description><para>The raw type of the Nth child as it is stored within <computeroutput>Expr</computeroutput>. This may be a value or a reference </para></description><type>Expr::proto_child2</type></typedef><typedef name="type"><description><para>The "const reference" type of the child, suitable for return by const reference, computed as follows: <itemizedlist>
<listitem><para><computeroutput>T const(&)[N]</computeroutput> becomes <computeroutput>T const(&)[N]</computeroutput> </para></listitem>
+<listitem><para><computeroutput>T[N]</computeroutput> becomes <computeroutput>T const(&)[N]</computeroutput> </para></listitem>
<listitem><para><computeroutput>T(&)[N]</computeroutput> becomes <computeroutput>T(&)[N]</computeroutput> </para></listitem>
<listitem><para><computeroutput>R(&)(A0,...)</computeroutput> becomes <computeroutput>R(&)(A0,...)</computeroutput> </para></listitem>
<listitem><para><computeroutput>T const &</computeroutput> becomes <computeroutput>T const &</computeroutput> </para></listitem>
<listitem><para><computeroutput>T &</computeroutput> becomes <computeroutput>T &</computeroutput> </para></listitem>
<listitem><para><computeroutput>T</computeroutput> becomes <computeroutput>T const &</computeroutput> </para></listitem>
</itemizedlist>
-</para></description><type><classname>unref</classname>< wrapped_type >::const_reference</type></typedef><method-group name="public static functions"/></struct-specialization><struct-specialization name="child_c"><template>
+</para></description><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public static functions"/></struct-specialization><struct-specialization name="child_c"><template>
       <template-type-parameter name="Expr"/>
- </template><specialization><template-arg>Expr</template-arg><template-arg>3</template-arg></specialization><purpose>A metafunction that returns the type of the Nth child of a Proto expression. </purpose><description><para>A metafunction that returns the type of the Nth child of a Proto expression. <computeroutput>N</computeroutput> must be 0 or less than <computeroutput>Expr::proto_arity::value</computeroutput>. </para></description><typedef name="wrapped_type"><description><para>The raw type of the Nth child as it is stored within <computeroutput>Expr</computeroutput>. This may be a value, a reference, or a Proto <computeroutput>ref_<></computeroutput> wrapper. </para></description><type>Expr::proto_child3</type></typedef><typedef name="type"><description><para>The "value" type of the child, suitable for return by value, computed as follows: <itemizedlist>
-<listitem><para><computeroutput>ref_<T const></computeroutput> becomes <computeroutput>T</computeroutput> </para></listitem>
-<listitem><para><computeroutput>ref_<T></computeroutput> becomes <computeroutput>T</computeroutput> </para></listitem>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>3</template-arg></specialization><purpose>A metafunction that returns the type of the Nth child of a Proto expression. </purpose><description><para>A metafunction that returns the type of the Nth child of a Proto expression. <computeroutput>N</computeroutput> must be 0 or less than <computeroutput>Expr::proto_arity::value</computeroutput>. </para></description><typedef name="value_type"><description><para>The raw type of the Nth child as it is stored within <computeroutput>Expr</computeroutput>. This may be a value or a reference </para></description><type>Expr::proto_child3</type></typedef><typedef name="type"><description><para>The "value" type of the child, suitable for return by value, computed as follows: <itemizedlist>
<listitem><para><computeroutput>T const(&)[N]</computeroutput> becomes <computeroutput>T const(&)[N]</computeroutput> </para></listitem>
+<listitem><para><computeroutput>T[N]</computeroutput> becomes <computeroutput>T(&)[N]</computeroutput> </para></listitem>
<listitem><para><computeroutput>T(&)[N]</computeroutput> becomes <computeroutput>T(&)[N]</computeroutput> </para></listitem>
<listitem><para><computeroutput>R(&)(A0,...)</computeroutput> becomes <computeroutput>R(&)(A0,...)</computeroutput> </para></listitem>
<listitem><para><computeroutput>T const &</computeroutput> becomes <computeroutput>T</computeroutput> </para></listitem>
<listitem><para><computeroutput>T &</computeroutput> becomes <computeroutput>T</computeroutput> </para></listitem>
<listitem><para><computeroutput>T</computeroutput> becomes <computeroutput>T</computeroutput> </para></listitem>
</itemizedlist>
-</para></description><type><classname>unref</classname>< wrapped_type >::type</type></typedef><typedef name="reference"><description><para>The "reference" type of the child, suitable for return by reference, computed as follows: <itemizedlist>
-<listitem><para><computeroutput>ref_<T const></computeroutput> becomes <computeroutput>T const &</computeroutput> </para></listitem>
-<listitem><para><computeroutput>ref_<T></computeroutput> becomes <computeroutput>T &</computeroutput> </para></listitem>
+</para></description><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><struct-specialization name="child_c"><template>
+ <template-type-parameter name="Expr"/>
+ </template><specialization><template-arg>Expr &</template-arg><template-arg>3</template-arg></specialization><typedef name="value_type"><description><para>The raw type of the Nth child as it is stored within <computeroutput>Expr</computeroutput>. This may be a value or a reference </para></description><type>Expr::proto_child3</type></typedef><typedef name="type"><description><para>The "reference" type of the child, suitable for return by reference, computed as follows: <itemizedlist>
<listitem><para><computeroutput>T const(&)[N]</computeroutput> becomes <computeroutput>T const(&)[N]</computeroutput> </para></listitem>
+<listitem><para><computeroutput>T[N]</computeroutput> becomes <computeroutput>T(&)[N]</computeroutput> </para></listitem>
<listitem><para><computeroutput>T(&)[N]</computeroutput> becomes <computeroutput>T(&)[N]</computeroutput> </para></listitem>
<listitem><para><computeroutput>R(&)(A0,...)</computeroutput> becomes <computeroutput>R(&)(A0,...)</computeroutput> </para></listitem>
<listitem><para><computeroutput>T const &</computeroutput> becomes <computeroutput>T const &</computeroutput> </para></listitem>
<listitem><para><computeroutput>T &</computeroutput> becomes <computeroutput>T &</computeroutput> </para></listitem>
<listitem><para><computeroutput>T</computeroutput> becomes <computeroutput>T &</computeroutput> </para></listitem>
</itemizedlist>
-</para></description><type><classname>unref</classname>< wrapped_type >::reference</type></typedef><typedef name="const_reference"><description><para>The "const reference" type of the child, suitable for return by const reference, computed as follows: <itemizedlist>
-<listitem><para><computeroutput>ref_<T const></computeroutput> becomes <computeroutput>T const &</computeroutput> </para></listitem>
-<listitem><para><computeroutput>ref_<T></computeroutput> becomes <computeroutput>T &</computeroutput> </para></listitem>
+</para></description><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public static functions"/></struct-specialization><struct-specialization name="child_c"><template>
+ <template-type-parameter name="Expr"/>
+ </template><specialization><template-arg>Expr const &</template-arg><template-arg>3</template-arg></specialization><typedef name="value_type"><description><para>The raw type of the Nth child as it is stored within <computeroutput>Expr</computeroutput>. This may be a value or a reference </para></description><type>Expr::proto_child3</type></typedef><typedef name="type"><description><para>The "const reference" type of the child, suitable for return by const reference, computed as follows: <itemizedlist>
<listitem><para><computeroutput>T const(&)[N]</computeroutput> becomes <computeroutput>T const(&)[N]</computeroutput> </para></listitem>
+<listitem><para><computeroutput>T[N]</computeroutput> becomes <computeroutput>T const(&)[N]</computeroutput> </para></listitem>
<listitem><para><computeroutput>T(&)[N]</computeroutput> becomes <computeroutput>T(&)[N]</computeroutput> </para></listitem>
<listitem><para><computeroutput>R(&)(A0,...)</computeroutput> becomes <computeroutput>R(&)(A0,...)</computeroutput> </para></listitem>
<listitem><para><computeroutput>T const &</computeroutput> becomes <computeroutput>T const &</computeroutput> </para></listitem>
<listitem><para><computeroutput>T &</computeroutput> becomes <computeroutput>T &</computeroutput> </para></listitem>
<listitem><para><computeroutput>T</computeroutput> becomes <computeroutput>T const &</computeroutput> </para></listitem>
</itemizedlist>
-</para></description><type><classname>unref</classname>< wrapped_type >::const_reference</type></typedef><method-group name="public static functions"/></struct-specialization><struct-specialization name="child_c"><template>
+</para></description><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public static functions"/></struct-specialization><struct-specialization name="child_c"><template>
       <template-type-parameter name="Expr"/>
- </template><specialization><template-arg>Expr</template-arg><template-arg>4</template-arg></specialization><purpose>A metafunction that returns the type of the Nth child of a Proto expression. </purpose><description><para>A metafunction that returns the type of the Nth child of a Proto expression. <computeroutput>N</computeroutput> must be 0 or less than <computeroutput>Expr::proto_arity::value</computeroutput>. </para></description><typedef name="wrapped_type"><description><para>The raw type of the Nth child as it is stored within <computeroutput>Expr</computeroutput>. This may be a value, a reference, or a Proto <computeroutput>ref_<></computeroutput> wrapper. </para></description><type>Expr::proto_child4</type></typedef><typedef name="type"><description><para>The "value" type of the child, suitable for return by value, computed as follows: <itemizedlist>
-<listitem><para><computeroutput>ref_<T const></computeroutput> becomes <computeroutput>T</computeroutput> </para></listitem>
-<listitem><para><computeroutput>ref_<T></computeroutput> becomes <computeroutput>T</computeroutput> </para></listitem>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>4</template-arg></specialization><purpose>A metafunction that returns the type of the Nth child of a Proto expression. </purpose><description><para>A metafunction that returns the type of the Nth child of a Proto expression. <computeroutput>N</computeroutput> must be 0 or less than <computeroutput>Expr::proto_arity::value</computeroutput>. </para></description><typedef name="value_type"><description><para>The raw type of the Nth child as it is stored within <computeroutput>Expr</computeroutput>. This may be a value or a reference </para></description><type>Expr::proto_child4</type></typedef><typedef name="type"><description><para>The "value" type of the child, suitable for return by value, computed as follows: <itemizedlist>
<listitem><para><computeroutput>T const(&)[N]</computeroutput> becomes <computeroutput>T const(&)[N]</computeroutput> </para></listitem>
+<listitem><para><computeroutput>T[N]</computeroutput> becomes <computeroutput>T(&)[N]</computeroutput> </para></listitem>
<listitem><para><computeroutput>T(&)[N]</computeroutput> becomes <computeroutput>T(&)[N]</computeroutput> </para></listitem>
<listitem><para><computeroutput>R(&)(A0,...)</computeroutput> becomes <computeroutput>R(&)(A0,...)</computeroutput> </para></listitem>
<listitem><para><computeroutput>T const &</computeroutput> becomes <computeroutput>T</computeroutput> </para></listitem>
<listitem><para><computeroutput>T &</computeroutput> becomes <computeroutput>T</computeroutput> </para></listitem>
<listitem><para><computeroutput>T</computeroutput> becomes <computeroutput>T</computeroutput> </para></listitem>
</itemizedlist>
-</para></description><type><classname>unref</classname>< wrapped_type >::type</type></typedef><typedef name="reference"><description><para>The "reference" type of the child, suitable for return by reference, computed as follows: <itemizedlist>
-<listitem><para><computeroutput>ref_<T const></computeroutput> becomes <computeroutput>T const &</computeroutput> </para></listitem>
-<listitem><para><computeroutput>ref_<T></computeroutput> becomes <computeroutput>T &</computeroutput> </para></listitem>
+</para></description><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><struct-specialization name="child_c"><template>
+ <template-type-parameter name="Expr"/>
+ </template><specialization><template-arg>Expr &</template-arg><template-arg>4</template-arg></specialization><typedef name="value_type"><description><para>The raw type of the Nth child as it is stored within <computeroutput>Expr</computeroutput>. This may be a value or a reference </para></description><type>Expr::proto_child4</type></typedef><typedef name="type"><description><para>The "reference" type of the child, suitable for return by reference, computed as follows: <itemizedlist>
<listitem><para><computeroutput>T const(&)[N]</computeroutput> becomes <computeroutput>T const(&)[N]</computeroutput> </para></listitem>
+<listitem><para><computeroutput>T[N]</computeroutput> becomes <computeroutput>T(&)[N]</computeroutput> </para></listitem>
<listitem><para><computeroutput>T(&)[N]</computeroutput> becomes <computeroutput>T(&)[N]</computeroutput> </para></listitem>
<listitem><para><computeroutput>R(&)(A0,...)</computeroutput> becomes <computeroutput>R(&)(A0,...)</computeroutput> </para></listitem>
<listitem><para><computeroutput>T const &</computeroutput> becomes <computeroutput>T const &</computeroutput> </para></listitem>
<listitem><para><computeroutput>T &</computeroutput> becomes <computeroutput>T &</computeroutput> </para></listitem>
<listitem><para><computeroutput>T</computeroutput> becomes <computeroutput>T &</computeroutput> </para></listitem>
</itemizedlist>
-</para></description><type><classname>unref</classname>< wrapped_type >::reference</type></typedef><typedef name="const_reference"><description><para>The "const reference" type of the child, suitable for return by const reference, computed as follows: <itemizedlist>
-<listitem><para><computeroutput>ref_<T const></computeroutput> becomes <computeroutput>T const &</computeroutput> </para></listitem>
-<listitem><para><computeroutput>ref_<T></computeroutput> becomes <computeroutput>T &</computeroutput> </para></listitem>
+</para></description><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public static functions"/></struct-specialization><struct-specialization name="child_c"><template>
+ <template-type-parameter name="Expr"/>
+ </template><specialization><template-arg>Expr const &</template-arg><template-arg>4</template-arg></specialization><typedef name="value_type"><description><para>The raw type of the Nth child as it is stored within <computeroutput>Expr</computeroutput>. This may be a value or a reference </para></description><type>Expr::proto_child4</type></typedef><typedef name="type"><description><para>The "const reference" type of the child, suitable for return by const reference, computed as follows: <itemizedlist>
<listitem><para><computeroutput>T const(&)[N]</computeroutput> becomes <computeroutput>T const(&)[N]</computeroutput> </para></listitem>
+<listitem><para><computeroutput>T[N]</computeroutput> becomes <computeroutput>T const(&)[N]</computeroutput> </para></listitem>
<listitem><para><computeroutput>T(&)[N]</computeroutput> becomes <computeroutput>T(&)[N]</computeroutput> </para></listitem>
<listitem><para><computeroutput>R(&)(A0,...)</computeroutput> becomes <computeroutput>R(&)(A0,...)</computeroutput> </para></listitem>
<listitem><para><computeroutput>T const &</computeroutput> becomes <computeroutput>T const &</computeroutput> </para></listitem>
<listitem><para><computeroutput>T &</computeroutput> becomes <computeroutput>T &</computeroutput> </para></listitem>
<listitem><para><computeroutput>T</computeroutput> becomes <computeroutput>T const &</computeroutput> </para></listitem>
</itemizedlist>
-</para></description><type><classname>unref</classname>< wrapped_type >::const_reference</type></typedef><method-group name="public static functions"/></struct-specialization><struct-specialization name="child_c"><template>
+</para></description><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public static functions"/></struct-specialization><struct-specialization name="child_c"><template>
       <template-type-parameter name="Expr"/>
- </template><specialization><template-arg>Expr</template-arg><template-arg>5</template-arg></specialization><purpose>A metafunction that returns the type of the Nth child of a Proto expression. </purpose><description><para>A metafunction that returns the type of the Nth child of a Proto expression. <computeroutput>N</computeroutput> must be 0 or less than <computeroutput>Expr::proto_arity::value</computeroutput>. </para></description><typedef name="wrapped_type"><description><para>The raw type of the Nth child as it is stored within <computeroutput>Expr</computeroutput>. This may be a value, a reference, or a Proto <computeroutput>ref_<></computeroutput> wrapper. </para></description><type>Expr::proto_child5</type></typedef><typedef name="type"><description><para>The "value" type of the child, suitable for return by value, computed as follows: <itemizedlist>
-<listitem><para><computeroutput>ref_<T const></computeroutput> becomes <computeroutput>T</computeroutput> </para></listitem>
-<listitem><para><computeroutput>ref_<T></computeroutput> becomes <computeroutput>T</computeroutput> </para></listitem>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>5</template-arg></specialization><purpose>A metafunction that returns the type of the Nth child of a Proto expression. </purpose><description><para>A metafunction that returns the type of the Nth child of a Proto expression. <computeroutput>N</computeroutput> must be 0 or less than <computeroutput>Expr::proto_arity::value</computeroutput>. </para></description><typedef name="value_type"><description><para>The raw type of the Nth child as it is stored within <computeroutput>Expr</computeroutput>. This may be a value or a reference </para></description><type>Expr::proto_child5</type></typedef><typedef name="type"><description><para>The "value" type of the child, suitable for return by value, computed as follows: <itemizedlist>
<listitem><para><computeroutput>T const(&)[N]</computeroutput> becomes <computeroutput>T const(&)[N]</computeroutput> </para></listitem>
+<listitem><para><computeroutput>T[N]</computeroutput> becomes <computeroutput>T(&)[N]</computeroutput> </para></listitem>
<listitem><para><computeroutput>T(&)[N]</computeroutput> becomes <computeroutput>T(&)[N]</computeroutput> </para></listitem>
<listitem><para><computeroutput>R(&)(A0,...)</computeroutput> becomes <computeroutput>R(&)(A0,...)</computeroutput> </para></listitem>
<listitem><para><computeroutput>T const &</computeroutput> becomes <computeroutput>T</computeroutput> </para></listitem>
<listitem><para><computeroutput>T &</computeroutput> becomes <computeroutput>T</computeroutput> </para></listitem>
<listitem><para><computeroutput>T</computeroutput> becomes <computeroutput>T</computeroutput> </para></listitem>
</itemizedlist>
-</para></description><type><classname>unref</classname>< wrapped_type >::type</type></typedef><typedef name="reference"><description><para>The "reference" type of the child, suitable for return by reference, computed as follows: <itemizedlist>
-<listitem><para><computeroutput>ref_<T const></computeroutput> becomes <computeroutput>T const &</computeroutput> </para></listitem>
-<listitem><para><computeroutput>ref_<T></computeroutput> becomes <computeroutput>T &</computeroutput> </para></listitem>
+</para></description><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><struct-specialization name="child_c"><template>
+ <template-type-parameter name="Expr"/>
+ </template><specialization><template-arg>Expr &</template-arg><template-arg>5</template-arg></specialization><typedef name="value_type"><description><para>The raw type of the Nth child as it is stored within <computeroutput>Expr</computeroutput>. This may be a value or a reference </para></description><type>Expr::proto_child5</type></typedef><typedef name="type"><description><para>The "reference" type of the child, suitable for return by reference, computed as follows: <itemizedlist>
<listitem><para><computeroutput>T const(&)[N]</computeroutput> becomes <computeroutput>T const(&)[N]</computeroutput> </para></listitem>
+<listitem><para><computeroutput>T[N]</computeroutput> becomes <computeroutput>T(&)[N]</computeroutput> </para></listitem>
<listitem><para><computeroutput>T(&)[N]</computeroutput> becomes <computeroutput>T(&)[N]</computeroutput> </para></listitem>
<listitem><para><computeroutput>R(&)(A0,...)</computeroutput> becomes <computeroutput>R(&)(A0,...)</computeroutput> </para></listitem>
<listitem><para><computeroutput>T const &</computeroutput> becomes <computeroutput>T const &</computeroutput> </para></listitem>
<listitem><para><computeroutput>T &</computeroutput> becomes <computeroutput>T &</computeroutput> </para></listitem>
<listitem><para><computeroutput>T</computeroutput> becomes <computeroutput>T &</computeroutput> </para></listitem>
</itemizedlist>
-</para></description><type><classname>unref</classname>< wrapped_type >::reference</type></typedef><typedef name="const_reference"><description><para>The "const reference" type of the child, suitable for return by const reference, computed as follows: <itemizedlist>
-<listitem><para><computeroutput>ref_<T const></computeroutput> becomes <computeroutput>T const &</computeroutput> </para></listitem>
-<listitem><para><computeroutput>ref_<T></computeroutput> becomes <computeroutput>T &</computeroutput> </para></listitem>
+</para></description><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public static functions"/></struct-specialization><struct-specialization name="child_c"><template>
+ <template-type-parameter name="Expr"/>
+ </template><specialization><template-arg>Expr const &</template-arg><template-arg>5</template-arg></specialization><typedef name="value_type"><description><para>The raw type of the Nth child as it is stored within <computeroutput>Expr</computeroutput>. This may be a value or a reference </para></description><type>Expr::proto_child5</type></typedef><typedef name="type"><description><para>The "const reference" type of the child, suitable for return by const reference, computed as follows: <itemizedlist>
<listitem><para><computeroutput>T const(&)[N]</computeroutput> becomes <computeroutput>T const(&)[N]</computeroutput> </para></listitem>
+<listitem><para><computeroutput>T[N]</computeroutput> becomes <computeroutput>T const(&)[N]</computeroutput> </para></listitem>
<listitem><para><computeroutput>T(&)[N]</computeroutput> becomes <computeroutput>T(&)[N]</computeroutput> </para></listitem>
<listitem><para><computeroutput>R(&)(A0,...)</computeroutput> becomes <computeroutput>R(&)(A0,...)</computeroutput> </para></listitem>
<listitem><para><computeroutput>T const &</computeroutput> becomes <computeroutput>T const &</computeroutput> </para></listitem>
<listitem><para><computeroutput>T &</computeroutput> becomes <computeroutput>T &</computeroutput> </para></listitem>
<listitem><para><computeroutput>T</computeroutput> becomes <computeroutput>T const &</computeroutput> </para></listitem>
</itemizedlist>
-</para></description><type><classname>unref</classname>< wrapped_type >::const_reference</type></typedef><method-group name="public static functions"/></struct-specialization></namespace><overloaded-function name="as_expr"><signature><type><classname>result_of::as_expr</classname>< T >::reference</type><template>
+</para></description><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public static functions"/></struct-specialization></namespace><overloaded-function name="as_expr"><signature><type><classname>result_of::as_expr</classname>< T >::reference</type><template>
           <template-type-parameter name="T"/>
         </template><parameter name="t"><paramtype>T &</paramtype><description><para>The object to wrap.</para></description></parameter></signature><signature><type><classname>result_of::as_expr</classname>< T const >::reference</type><template>
           <template-type-parameter name="T"/>
@@ -2605,119 +2702,115 @@
           <template-type-parameter name="T"/>
         </template><parameter name="t"><paramtype>T &</paramtype><description><para>The object to wrap.</para></description></parameter></signature><signature><type><classname>result_of::as_child</classname>< T const >::type</type><template>
           <template-type-parameter name="T"/>
- </template><parameter name="t"><paramtype>T const &</paramtype></parameter></signature><purpose>A function that wraps non-Proto expression types in Proto terminals (by reference) and wraps Proto expression types in <computeroutput>ref_<></computeroutput>. </purpose><description><para>The <computeroutput>as_child()</computeroutput> function turns objects into Proto terminals if they are not Proto expression types already. Non-Proto types are held by reference. Types which are already Proto types are wrapped in <computeroutput>ref_<></computeroutput>.</para><para>This function can be called either with an explicitly specified <computeroutput>Domain</computeroutput> parameter (i.e., <computeroutput>as_child<Domain>(t)</computeroutput>), or without (i.e., <computeroutput>as_child(t)</computeroutput>). If no domain is specified, <computeroutput>default_domain</computeroutput> is assumed.</para><para>If <computeroutput>is_expr<T>::value</computeroutput> is <computeroutput>true<
/computeroutput>, then the argument is wrapped in <computeroutput>ref_<></computeroutput>, which holds the argument by reference. Otherwise, <computeroutput>as_child()</computeroutput> returns <computeroutput>Domain()(terminal<T &>::type::make(t))</computeroutput>.</para><para>
-This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></overloaded-function><overloaded-function name="child"><signature><type><classname>result_of::child</classname>< Expr, N >::reference</type><template>
+ </template><parameter name="t"><paramtype>T const &</paramtype></parameter></signature><purpose>A function that wraps non-Proto expression types in Proto terminals (by reference) and returns Proto expression types by reference. </purpose><description><para>The <computeroutput>as_child()</computeroutput> function turns objects into Proto terminals if they are not Proto expression types already. Non-Proto types are held by reference. Types which are already Proto types are simply returned as-is.</para><para>This function can be called either with an explicitly specified <computeroutput>Domain</computeroutput> parameter (i.e., <computeroutput>as_child<Domain>(t)</computeroutput>), or without (i.e., <computeroutput>as_child(t)</computeroutput>). If no domain is specified, <computeroutput>default_domain</computeroutput> is assumed.</para><para>If <computeroutput>is_expr<T>::value</computeroutput> is <computeroutput>true</computeroutput>, then the argument is returned as-is. Otherwise, <co
mputeroutput>as_child()</computeroutput> returns <computeroutput>Domain()(terminal<T &>::type::make(t))</computeroutput>.</para><para>
+This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></overloaded-function><overloaded-function name="child"><signature><type><classname>result_of::child</classname>< Expr &, N >::type</type><template>
           <template-type-parameter name="N"/>
           <template-type-parameter name="Expr"/>
- </template><parameter name="expr"><paramtype>Expr &</paramtype><description><para>The Proto expression. </para></description></parameter></signature><signature><type><classname>result_of::child</classname>< Expr, N >::const_reference</type><template>
+ </template><parameter name="expr"><paramtype>Expr &</paramtype><description><para>The Proto expression. </para></description></parameter></signature><signature><type><classname>result_of::child</classname>< Expr const &, N >::type</type><template>
           <template-type-parameter name="N"/>
           <template-type-parameter name="Expr"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></signature><signature><type><classname>result_of::unref</classname>< typename Expr2::proto_base_expr::proto_child0 >::reference</type><template>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></signature><signature><type><emphasis>unspecified</emphasis></type><template>
           <template-type-parameter name="Expr2"/>
- </template><parameter name="expr2"><paramtype>Expr2 &</paramtype></parameter></signature><signature><type><classname>result_of::unref</classname>< typename Expr2::proto_base_expr::proto_child0 >::const_reference</type><template>
+ </template><parameter name="expr2"><paramtype>Expr2 &</paramtype></parameter></signature><signature><type><emphasis>unspecified</emphasis></type><template>
           <template-type-parameter name="Expr2"/>
         </template><parameter name="expr2"><paramtype>Expr2 const &</paramtype></parameter></signature><purpose>Return the Nth child of the specified Proto expression. </purpose><description><para>Return the Nth child of the specified Proto expression. If <computeroutput>N</computeroutput> is not specified, as in <computeroutput>child(expr)</computeroutput>, then <computeroutput>N</computeroutput> is assumed to be <computeroutput>mpl::long_<0></computeroutput>. The child is returned by reference. If the expression is holding the child in a <computeroutput>ref_<></computeroutput> wrapper, it is unwrapped before it is returned.</para><para>

-</para></description><requires><para><computeroutput>is_expr<Expr>::value</computeroutput> is <computeroutput>true</computeroutput>. </para><para><computeroutput>N</computeroutput> is an MPL Integral Constant. </para><para><computeroutput>N::value == 0 || N::value < Expr::proto_arity::value</computeroutput> </para></requires><returns><para>A reference to the Nth child </para></returns><throws><simpara>Will not throw.</simpara></throws></overloaded-function><overloaded-function name="child_c"><signature><type>result_of::child_c< Expr, N >::reference</type><template>
+</para></description><requires><para><computeroutput>is_expr<Expr>::value</computeroutput> is <computeroutput>true</computeroutput>. </para><para><computeroutput>N</computeroutput> is an MPL Integral Constant. </para><para><computeroutput>N::value == 0 || N::value < Expr::proto_arity::value</computeroutput> </para></requires><returns><para>A reference to the Nth child </para></returns><throws><simpara>Will not throw.</simpara></throws></overloaded-function><overloaded-function name="child_c"><signature><type>result_of::child_c< Expr &, N >::type</type><template>
           <template-nontype-parameter name="N"><type>long</type></template-nontype-parameter>
           <template-type-parameter name="Expr"/>
- </template><parameter name="expr"><paramtype>Expr &</paramtype><description><para>The Proto expression. </para></description></parameter></signature><signature><type>result_of::child_c< Expr, N >::const_reference</type><template>
+ </template><parameter name="expr"><paramtype>Expr &</paramtype><description><para>The Proto expression. </para></description></parameter></signature><signature><type>result_of::child_c< Expr const &, N >::type</type><template>
           <template-nontype-parameter name="N"><type>long</type></template-nontype-parameter>
           <template-type-parameter name="Expr"/>
         </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></signature><purpose>Return the Nth child of the specified Proto expression. </purpose><description><para>Return the Nth child of the specified Proto expression. The child is returned by reference. If the expression is holding the child in a <computeroutput>ref_<></computeroutput> wrapper, it is unwrapped before it is returned.</para><para>

-</para></description><requires><para><computeroutput>is_expr<Expr>::value</computeroutput> is <computeroutput>true</computeroutput>. </para><para><computeroutput>N == 0 || N < Expr::proto_arity::value</computeroutput> </para></requires><returns><para>A reference to the Nth child </para></returns><throws><simpara>Will not throw.</simpara></throws></overloaded-function><overloaded-function name="value"><signature><type><classname>result_of::value</classname>< Expr >::reference</type><template>
+</para></description><requires><para><computeroutput>is_expr<Expr>::value</computeroutput> is <computeroutput>true</computeroutput>. </para><para><computeroutput>N == 0 || N < Expr::proto_arity::value</computeroutput> </para></requires><returns><para>A reference to the Nth child </para></returns><throws><simpara>Will not throw.</simpara></throws></overloaded-function><overloaded-function name="value"><signature><type><classname>result_of::value</classname>< Expr & >::type</type><template>
           <template-type-parameter name="Expr"/>
- </template><parameter name="expr"><paramtype>Expr &</paramtype><description><para>The Proto terminal expression. </para></description></parameter></signature><signature><type><classname>result_of::value</classname>< Expr >::const_reference</type><template>
+ </template><parameter name="expr"><paramtype>Expr &</paramtype><description><para>The Proto terminal expression. </para></description></parameter></signature><signature><type><classname>result_of::value</classname>< Expr const & >::type</type><template>
           <template-type-parameter name="Expr"/>
         </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></signature><purpose>Return the value stored within the specified Proto terminal expression. </purpose><description><para>Return the the value stored within the specified Proto terminal expression. The value is returned by reference.</para><para>

-</para></description><requires><para><computeroutput>Expr::proto_tag</computeroutput> is <computeroutput>tag::terminal</computeroutput>. </para><para><computeroutput>N::value == 0</computeroutput> </para></requires><returns><para>A reference to the terminal's value </para></returns><throws><simpara>Will not throw.</simpara></throws></overloaded-function><overloaded-function name="left"><signature><type><classname>result_of::left</classname>< Expr >::reference</type><template>
+</para></description><requires><para><computeroutput>Expr::proto_tag</computeroutput> is <computeroutput>tag::terminal</computeroutput>. </para><para><computeroutput>N::value == 0</computeroutput> </para></requires><returns><para>A reference to the terminal's value </para></returns><throws><simpara>Will not throw.</simpara></throws></overloaded-function><overloaded-function name="left"><signature><type><classname>result_of::left</classname>< Expr & >::type</type><template>
           <template-type-parameter name="Expr"/>
- </template><parameter name="expr"><paramtype>Expr &</paramtype><description><para>The Proto expression. </para></description></parameter></signature><signature><type><classname>result_of::left</classname>< Expr >::const_reference</type><template>
+ </template><parameter name="expr"><paramtype>Expr &</paramtype><description><para>The Proto expression. </para></description></parameter></signature><signature><type><classname>result_of::left</classname>< Expr const & >::type</type><template>
           <template-type-parameter name="Expr"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></signature><purpose>Return the left child of the specified binary Proto expression. </purpose><description><para>Return the left child of the specified binary Proto expression. The child is returned by reference. If the expression is holding the child in a <computeroutput>ref_<></computeroutput> wrapper, it is unwrapped before it is returned.</para><para>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></signature><purpose>Return the left child of the specified binary Proto expression. </purpose><description><para>Return the left child of the specified binary Proto expression. The child is returned by reference.</para><para>

-</para></description><requires><para><computeroutput>is_expr<Expr>::value</computeroutput> is <computeroutput>true</computeroutput>. </para><para><computeroutput>2 == Expr::proto_arity::value</computeroutput> </para></requires><returns><para>A reference to the left child </para></returns><throws><simpara>Will not throw.</simpara></throws></overloaded-function><overloaded-function name="right"><signature><type><classname>result_of::right</classname>< Expr >::reference</type><template>
+</para></description><requires><para><computeroutput>is_expr<Expr>::value</computeroutput> is <computeroutput>true</computeroutput>. </para><para><computeroutput>2 == Expr::proto_arity::value</computeroutput> </para></requires><returns><para>A reference to the left child </para></returns><throws><simpara>Will not throw.</simpara></throws></overloaded-function><overloaded-function name="right"><signature><type><classname>result_of::right</classname>< Expr & >::type</type><template>
           <template-type-parameter name="Expr"/>
- </template><parameter name="expr"><paramtype>Expr &</paramtype><description><para>The Proto expression. </para></description></parameter></signature><signature><type><classname>result_of::right</classname>< Expr >::const_reference</type><template>
+ </template><parameter name="expr"><paramtype>Expr &</paramtype><description><para>The Proto expression. </para></description></parameter></signature><signature><type><classname>result_of::right</classname>< Expr const & >::type</type><template>
           <template-type-parameter name="Expr"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></signature><purpose>Return the right child of the specified binary Proto expression. </purpose><description><para>Return the right child of the specified binary Proto expression. The child is returned by reference. If the expression is holding the child in a <computeroutput>ref_<></computeroutput> wrapper, it is unwrapped before it is returned.</para><para>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></signature><purpose>Return the right child of the specified binary Proto expression. </purpose><description><para>Return the right child of the specified binary Proto expression. The child is returned by reference.</para><para>

-</para></description><requires><para><computeroutput>is_expr<Expr>::value</computeroutput> is <computeroutput>true</computeroutput>. </para><para><computeroutput>2 == Expr::proto_arity::value</computeroutput> </para></requires><returns><para>A reference to the right child </para></returns><throws><simpara>Will not throw.</simpara></throws></overloaded-function></namespace></namespace></header><header name="boost/proto/transform.hpp"><para>Includes all the transforms in the transform/ sub-directory. </para></header><header name="boost/proto/transform/arg.hpp"><para>Contains definition of the argN transforms. </para><namespace name="boost"><namespace name="proto"><struct name="_expr"><inherit access="public">boost::proto::callable</inherit><purpose>A PrimitiveTransform that returns the current expression unmodified. </purpose><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+</para></description><requires><para><computeroutput>is_expr<Expr>::value</computeroutput> is <computeroutput>true</computeroutput>. </para><para><computeroutput>2 == Expr::proto_arity::value</computeroutput> </para></requires><returns><para>A reference to the right child </para></returns><throws><simpara>Will not throw.</simpara></throws></overloaded-function></namespace></namespace></header><header name="boost/proto/transform.hpp"><para>Includes all the transforms in the transform/ sub-directory. </para></header><header name="boost/proto/transform/arg.hpp"><para>Contains definition of the argN transforms. </para><namespace name="boost"><namespace name="proto"><struct name="_expr"><inherit access="public">transform< boost::proto::_expr ></inherit><purpose>A PrimitiveTransform that returns the current expression unmodified. </purpose><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Data"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Data)</template-arg></specialization><typedef name="type"><type>Expr</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>Expr const &</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression. </para></description></parameter><parameter name=""><paramtype>State const &</paramtype></parameter><parameter name=""><paramtype>Data &</paramtype></parameter><description><para>
+ </template><typedef name="result_type"><type>Expr</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>impl::expr_param</type><parameter name="expr"><paramtype>typename impl::expr_param</paramtype><description><para>An expression </para></description></parameter><parameter name=""><paramtype>typename impl::state_param</paramtype></parameter><parameter name=""><paramtype>typename impl::data_param</paramtype></parameter><description><para>

-</para></description><returns><para><computeroutput>expr</computeroutput> </para></returns><throws><simpara>Will not throw.</simpara></throws></method></method-group></struct><struct name="_state"><inherit access="public">boost::proto::callable</inherit><purpose>A PrimitiveTransform that returns the current state unmodified. </purpose><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+</para></description><returns><para><computeroutput>expr</computeroutput> </para></returns><throws><simpara>Will not throw.</simpara></throws></method></method-group></struct></struct><struct name="_state"><inherit access="public">transform< boost::proto::_state ></inherit><purpose>A PrimitiveTransform that returns the current state unmodified. </purpose><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Data"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Data)</template-arg></specialization><typedef name="type"><type>State</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>State const &</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name=""><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state. </para></description></parameter><parameter name=""><paramtype>Data &</paramtype></parameter><description><para>
+ </template><typedef name="result_type"><type>State</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>impl::state_param</type><parameter name=""><paramtype>typename impl::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl::state_param</paramtype><description><para>The current state. </para></description></parameter><parameter name=""><paramtype>typename impl::data_param</paramtype></parameter><description><para>

-</para></description><returns><para><computeroutput>state</computeroutput> </para></returns><throws><simpara>Will not throw.</simpara></throws></method></method-group></struct><struct name="_data"><inherit access="public">boost::proto::callable</inherit><purpose>A PrimitiveTransform that returns the current data unmodified. </purpose><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+</para></description><returns><para><computeroutput>state</computeroutput> </para></returns><throws><simpara>Will not throw.</simpara></throws></method></method-group></struct></struct><struct name="_data"><inherit access="public">transform< boost::proto::_data ></inherit><purpose>A PrimitiveTransform that returns the current data unmodified. </purpose><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Data"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Data)</template-arg></specialization><typedef name="type"><type>Data</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>Data &</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name=""><paramtype>Expr const &</paramtype></parameter><parameter name=""><paramtype>State const &</paramtype></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>The current data </para></description></parameter><description><para>
+ </template><typedef name="result_type"><type>Data</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>impl::data_param</type><parameter name=""><paramtype>typename impl::expr_param</paramtype></parameter><parameter name=""><paramtype>typename impl::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl::data_param</paramtype></parameter><description><para>

-</para></description><returns><para><computeroutput>data</computeroutput> </para></returns><throws><simpara>Will not throw.</simpara></throws></method></method-group></struct><struct name="_child_c"><template>
+</para></description><returns><para><computeroutput>data</computeroutput> </para></returns><throws><simpara>Will not throw.</simpara></throws></method></method-group></struct></struct><struct name="_child_c"><template>
       <template-nontype-parameter name="I"><type>int</type></template-nontype-parameter>
- </template><inherit access="public">boost::proto::callable</inherit><purpose>A PrimitiveTransform that returns I-th child of the current expression. </purpose><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+ </template><inherit access="public">transform< boost::proto::_child_c< I > ></inherit><purpose>A PrimitiveTransform that returns I-th child of the current expression. </purpose><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Data"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Data)</template-arg></specialization><typedef name="type"><type>proto::result_of::child_c< Expr, I >::type</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>proto::result_of::child_c< Expr, I >::const_reference</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression. </para></description></parameter><parameter name=""><paramtype>State const &</paramtype></parameter><parameter name=""><paramtype>Data &</paramtype></parameter><description><para>
+ </template><typedef name="result_type"><type>result_of::child_c< Expr, I >::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_of::child_c< typename impl::expr_param, I >::type</type><parameter name="expr"><paramtype>typename impl::expr_param</paramtype><description><para>The current expression. </para></description></parameter><parameter name=""><paramtype>typename impl::state_param</paramtype></parameter><parameter name=""><paramtype>typename impl::data_param</paramtype></parameter><description><para>

-</para></description><returns><para><computeroutput>proto::child_c<I>(expr)</computeroutput> </para></returns><throws><simpara>Will not throw.</simpara></throws></method></method-group></struct><struct name="_ref"><inherit access="public">boost::proto::callable</inherit><purpose>A unary CallableTransform that wraps its argument in a <computeroutput>boost::reference_wrapper<></computeroutput>. </purpose><struct-specialization name="result"><template>
+</para></description><returns><para><computeroutput>proto::child_c<I>(expr)</computeroutput> </para></returns><throws><simpara>Will not throw.</simpara></throws></method></method-group></struct></struct><struct name="_byref"><inherit access="public">boost::proto::callable</inherit><purpose>A unary CallableTransform that wraps its argument in a <computeroutput>boost::reference_wrapper<></computeroutput>. </purpose><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="T"/>
- </template><specialization><template-arg>This(T &)</template-arg></specialization><typedef name="type"><type>boost::reference_wrapper< T ></type></typedef></struct-specialization><struct-specialization name="result"><template>
+ </template><specialization><template-arg>This(T &)</template-arg></specialization><typedef name="type"><type>boost::reference_wrapper< T > const</type></typedef></struct-specialization><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="T"/>
- </template><specialization><template-arg>This(T)</template-arg></specialization><typedef name="type"><type>boost::reference_wrapper< T const ></type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>boost::reference_wrapper< T ></type><template>
+ </template><specialization><template-arg>This(T)</template-arg></specialization><typedef name="type"><type>boost::reference_wrapper< T const > const</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>boost::reference_wrapper< T > const</type><template>
           <template-type-parameter name="T"/>
         </template><parameter name="t"><paramtype>T &</paramtype><description><para>The object to wrap </para></description></parameter><description><para>

-</para></description><returns><para><computeroutput>boost::ref(t)</computeroutput> </para></returns><throws><simpara>Will not throw.</simpara></throws></method><method name="operator()" cv="const"><type>boost::reference_wrapper< T const ></type><template>
+</para></description><returns><para><computeroutput>boost::ref(t)</computeroutput> </para></returns><throws><simpara>Will not throw.</simpara></throws></method><method name="operator()" cv="const"><type>boost::reference_wrapper< T const > const</type><template>
+ <template-type-parameter name="T"/>
+ </template><parameter name="t"><paramtype>T const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method></method-group></struct><struct name="_byval"><inherit access="public">boost::proto::callable</inherit><purpose>A unary CallableTransform that strips references from its argument. </purpose><struct-specialization name="result"><template>
+ <template-type-parameter name="This"/>
+ <template-type-parameter name="T"/>
+ </template><specialization><template-arg>This(boost::reference_wrapper< T >)</template-arg></specialization><inherit access="public">boost::proto::_byval::result< This(T)></inherit></struct-specialization><struct-specialization name="result"><template>
+ <template-type-parameter name="This"/>
+ <template-type-parameter name="T"/>
+ </template><specialization><template-arg>This(T &)</template-arg></specialization><inherit access="public">boost::proto::_byval::result< This(T)></inherit></struct-specialization><struct-specialization name="result"><template>
+ <template-type-parameter name="This"/>
+ <template-type-parameter name="T"/>
+ </template><specialization><template-arg>This(T)</template-arg></specialization><typedef name="type"><type>T</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>T const &</type><template>
+ <template-type-parameter name="T"/>
+ </template><parameter name="t"><paramtype>T const &</paramtype><description><para>The object to unref </para></description></parameter><description><para>
+
+
+</para></description><returns><para><computeroutput>t</computeroutput> </para></returns><throws><simpara>Will not throw.</simpara></throws></method><method name="operator()" cv="const"><type>T &</type><template>
           <template-type-parameter name="T"/>
- </template><parameter name="t"><paramtype>T const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method></method-group></struct></namespace></namespace></header><header name="boost/proto/transform/call.hpp"><para>Contains definition of the call<> transform. </para><namespace name="boost"><namespace name="proto"><struct name="call"><template>
+ </template><parameter name="t"><paramtype>boost::reference_wrapper< T > const &</paramtype></parameter><description><para>This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. </para></description></method></method-group></struct></namespace></namespace></header><header name="boost/proto/transform/call.hpp"><para>Contains definition of the call<> transform. </para><namespace name="boost"><namespace name="proto"><struct name="call"><template>
       <template-type-parameter name="PrimitiveTransform"/>
     </template><purpose>Wrap <computeroutput>PrimitiveTransform</computeroutput> so that <computeroutput>when<></computeroutput> knows it is callable. Requires that the parameter is actually a PrimitiveTransform. </purpose><description><para>This form of <computeroutput>call<></computeroutput> is useful for annotating an arbitrary PrimitiveTransform as callable when using it with <computeroutput>when<></computeroutput>. Consider the following transform, which is parameterized with another transform.</para><para><programlisting> template<typename Grammar>
  struct Foo
@@ -2726,7 +2819,7 @@
        , Grammar(_child) // May or may not work.
      >
  {};
-</programlisting></para><para>The problem with the above is that <computeroutput>when<></computeroutput> may or may not recognize <computeroutput>Grammar</computeroutput> as callable, depending on how <computeroutput>Grammar</computeroutput> is implemented. (See <computeroutput>is_callable<></computeroutput> for a discussion of this issue.) The above code can guard against the issue by wrapping <computeroutput>Grammar</computeroutput> in <computeroutput>call<></computeroutput>, such as:</para><para><programlisting> template<typename Grammar>
+</programlisting></para><para>The problem with the above is that <computeroutput>when<></computeroutput> may or may not recognize <computeroutput>Grammar</computeroutput> as callable, depending on how <computeroutput>Grammar</computeroutput> is implemented. (See <computeroutput>is_callable<></computeroutput> for a discussion of this issue.) You can guard against the issue by wrapping <computeroutput>Grammar</computeroutput> in <computeroutput>call<></computeroutput>, such as:</para><para><programlisting> template<typename Grammar>
  struct Foo
    : when<
          unary_plus<Grammar>
@@ -2740,108 +2833,100 @@
        , call<Grammar(_child)> // OK, this works, too
      >
  {};
-</programlisting> </para></description><typedef name="proto_is_callable_"><type>void</type></typedef></struct><struct-specialization name="call"><template>
+</programlisting> </para></description></struct><struct-specialization name="call"><template>
       <template-type-parameter name="Fun"/>
- </template><specialization><template-arg>Fun()</template-arg></specialization><inherit access="public">boost::proto::callable</inherit><purpose>Either call the PolymorphicFunctionObject with 0 arguments, or invoke the PrimitiveTransform with 3 arguments. </purpose><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+ </template><specialization><template-arg>Fun()</template-arg></specialization><inherit access="public">transform< boost::proto::call< Fun()> ></inherit><purpose>Either call the PolymorphicFunctionObject with 0 arguments, or invoke the PrimitiveTransform with 3 arguments. </purpose><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Data"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Data)</template-arg></specialization><typedef name="type"><description><para>If <computeroutput>Fun</computeroutput> is a nullary PolymorphicFunctionObject, <computeroutput>type</computeroutput> is a typedef for <computeroutput>boost::result_of<Fun()>::type</computeroutput>. Otherwise, it is a typedef for <computeroutput>boost::result_of<Fun(Expr, State, Data)>::type</computeroutput>. </para></description><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>Either call the PolymorphicFunctionObject <computeroutput>Fun</computeroutput> with 0 arguments; or invoke the PrimitiveTransform <computeroutput>Fun</computeroutput> with 3 arguments: the current expression, state, and data.</para><para>If <computeroutput>Fun</computeroutput> is a nullary PolymorphicFunctionObject, return <computeroutput>Fun()()</computeroutput>. Otherwise, return <computeroutput>Fun()(expr, state, data)</computeroutput>.</para><para>
-</para></description></method></method-group></struct-specialization><struct-specialization name="call"><template>
+ </template><description><para>Either call the PolymorphicFunctionObject <computeroutput>Fun</computeroutput> with 0 arguments; or invoke the PrimitiveTransform <computeroutput>Fun</computeroutput> with 3 arguments: the current expression, state, and data.</para><para>If <computeroutput>Fun</computeroutput> is a nullary PolymorphicFunctionObject, return <computeroutput>Fun()()</computeroutput>. Otherwise, return <computeroutput>Fun()(expr, state, data)</computeroutput>.</para><para>
+</para></description></struct></struct-specialization><struct-specialization name="call"><template>
       <template-type-parameter name="Fun"/>
       <template-type-parameter name="A0"/>
- </template><specialization><template-arg>Fun(A0)</template-arg></specialization><inherit access="public">boost::proto::callable</inherit><purpose>Either call the PolymorphicFunctionObject with 1 argument, or invoke the PrimitiveTransform with 3 arguments. </purpose><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+ </template><specialization><template-arg>Fun(A0)</template-arg></specialization><inherit access="public">transform< boost::proto::call< Fun(A0)> ></inherit><purpose>Either call the PolymorphicFunctionObject with 1 argument, or invoke the PrimitiveTransform with 3 arguments. </purpose><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Data"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Data)</template-arg></specialization><typedef name="type"><description><para>Let <computeroutput>x</computeroutput> be <computeroutput>when<_, A0>()(expr, state, data)</computeroutput> and <computeroutput>X</computeroutput> be the type of <computeroutput>x</computeroutput>. If <computeroutput>Fun</computeroutput> is a unary PolymorphicFunctionObject that accepts <computeroutput>x</computeroutput>, then <computeroutput>type</computeroutput> is a typedef for <computeroutput>boost::result_of<Fun(X)>::type</computeroutput>. Otherwise, it is a typedef for <computeroutput>boost::result_of<Fun(X, State, Data)>::type</computeroutput>. </para></description><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>Either call the PolymorphicFunctionObject with 1 argument: the result of applying the <computeroutput>A0</computeroutput> transform; or invoke the PrimitiveTransform with 3 arguments: result of applying the <computeroutput>A0</computeroutput> transform, the state, and the data.</para><para>Let <computeroutput>x</computeroutput> be <computeroutput>when<_, A0>()(expr, state, data)</computeroutput>. If <computeroutput>Fun</computeroutput> is a unary PolymorphicFunctionObject that accepts <computeroutput>x</computeroutput>, then return <computeroutput>Fun()(x)</computeroutput>.
Otherwise, return <computeroutput>Fun()(x, state, data)</computeroutput>.</para><para>
-</para></description></method></method-group></struct-specialization><struct-specialization name="call"><template>
+ </template><description><para>Let <computeroutput>x</computeroutput> be <computeroutput>when<_, A0>()(expr, state, data)</computeroutput> and <computeroutput>X</computeroutput> be the type of <computeroutput>x</computeroutput>. If <computeroutput>Fun</computeroutput> is a unary PolymorphicFunctionObject that accepts <computeroutput>x</computeroutput>, then <computeroutput>type</computeroutput> is a typedef for <computeroutput>boost::result_of<Fun(X)>::type</computeroutput>. Otherwise, it is a typedef for <computeroutput>boost::result_of<Fun(X, State, Data)>::type</computeroutput>. Either call the PolymorphicFunctionObject with 1 argument: the result of applying the <computeroutput>A0</computeroutput> transform; or invoke the PrimitiveTransform with 3 arguments: result of applying the <computeroutput>A0</computeroutput> transform, the state, and the data.</para><para>Let <computeroutput>x</computeroutput> be <computeroutput>when<_, A0>()(expr, state, data)</computeroutput>. If <co
mputeroutput>Fun</computeroutput> is a unary PolymorphicFunctionObject that accepts <computeroutput>x</computeroutput>, then return <computeroutput>Fun()(x)</computeroutput>. Otherwise, return <computeroutput>Fun()(x, state, data)</computeroutput>.</para><para>
+</para></description></struct><struct name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ <template-nontype-parameter name="B"><type>bool</type></template-nontype-parameter>
+ </template><typedef name="a0"><type><classname>when</classname>< _, A0 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="result_type"><type>boost::result_of< <classname>Fun</classname>(a0)>::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>true</template-arg></specialization><typedef name="a0"><type><classname>when</classname>< _, A0 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="result_type"><type>Fun::template impl< a0, State, Data >::result_type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization></struct-specialization><struct-specialization name="call"><template>
       <template-type-parameter name="Fun"/>
       <template-type-parameter name="A0"/>
       <template-type-parameter name="A1"/>
- </template><specialization><template-arg>Fun(A0</template-arg><template-arg>A1)</template-arg></specialization><inherit access="public">boost::proto::callable</inherit><purpose>Either call the PolymorphicFunctionObject with 2 arguments, or invoke the PrimitiveTransform with 3 arguments. </purpose><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+ </template><specialization><template-arg>Fun(A0</template-arg><template-arg>A1)</template-arg></specialization><inherit access="public">transform< boost::proto::call< Fun(A0, A1)> ></inherit><purpose>Either call the PolymorphicFunctionObject with 2 arguments, or invoke the PrimitiveTransform with 3 arguments. </purpose><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Data"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Data)</template-arg></specialization><typedef name="type"><description><para>Let <computeroutput>x</computeroutput> be <computeroutput>when<_, A0>()(expr, state, data)</computeroutput> and <computeroutput>X</computeroutput> be the type of <computeroutput>x</computeroutput>. Let <computeroutput>y</computeroutput> be <computeroutput>when<_, A1>()(expr, state, data)</computeroutput> and <computeroutput>Y</computeroutput> be the type of <computeroutput>y</computeroutput>. If <computeroutput>Fun</computeroutput> is a binary PolymorphicFunction object that accepts <computeroutput>x</computeroutput> and <computeroutput>y</computeroutput>, then <computeroutput>type</computeroutput> is a typedef for <computeroutput>boost::result_of<Fun(X, Y)>::type</computeroutput>. Otherwise, it is a typedef for <computeroutput>boost::result_of<Fun(X, Y, Data)>::type</computeroutput>. </para><
/description><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>Either call the PolymorphicFunctionObject with 2 arguments: the result of applying the <computeroutput>A0</computeroutput> transform, and the result of applying the <computeroutput>A1</computeroutput> transform; or invoke the PrimitiveTransform with 3 arguments: the result of applying the <computeroutput>A0</computeroutput> transform, the result of applying the <computeroutput>A1</computeroutput> transform, and the data.</para><para>Let <computeroutput>x</computeroutput> be <computeroutput>when<_, A0>()(expr, state, data)</computeroutput>. Let <computeroutput>y</computeroutp
ut> be <computeroutput>when<_, A1>()(expr, state, data)</computeroutput>. If <computeroutput>Fun</computeroutput> is a binary PolymorphicFunction object that accepts <computeroutput>x</computeroutput> and <computeroutput>y</computeroutput>, return <computeroutput>Fun()(x, y)</computeroutput>. Otherwise, return <computeroutput>Fun()(x, y, data)</computeroutput>.</para><para>
-</para></description></method></method-group></struct-specialization><struct-specialization name="call"><template>
+ </template><description><para>Let <computeroutput>x</computeroutput> be <computeroutput>when<_, A0>()(expr, state, data)</computeroutput> and <computeroutput>X</computeroutput> be the type of <computeroutput>x</computeroutput>. Let <computeroutput>y</computeroutput> be <computeroutput>when<_, A1>()(expr, state, data)</computeroutput> and <computeroutput>Y</computeroutput> be the type of <computeroutput>y</computeroutput>. If <computeroutput>Fun</computeroutput> is a binary PolymorphicFunction object that accepts <computeroutput>x</computeroutput> and <computeroutput>y</computeroutput>, then <computeroutput>type</computeroutput> is a typedef for <computeroutput>boost::result_of<Fun(X, Y)>::type</computeroutput>. Otherwise, it is a typedef for <computeroutput>boost::result_of<Fun(X, Y, Data)>::type</computeroutput>. Either call the PolymorphicFunctionObject with 2 arguments: the result of applying the <computeroutput>A0</computeroutput> transform, and the result of applying the <co
mputeroutput>A1</computeroutput> transform; or invoke the PrimitiveTransform with 3 arguments: the result of applying the <computeroutput>A0</computeroutput> transform, the result of applying the <computeroutput>A1</computeroutput> transform, and the data.</para><para>Let <computeroutput>x</computeroutput> be <computeroutput>when<_, A0>()(expr, state, data)</computeroutput>. Let <computeroutput>y</computeroutput> be <computeroutput>when<_, A1>()(expr, state, data)</computeroutput>. If <computeroutput>Fun</computeroutput> is a binary PolymorphicFunction object that accepts <computeroutput>x</computeroutput> and <computeroutput>y</computeroutput>, return <computeroutput>Fun()(x, y)</computeroutput>. Otherwise, return <computeroutput>Fun()(x, y, data)</computeroutput>.</para><para>
+</para></description></struct><struct name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ <template-nontype-parameter name="B"><type>bool</type></template-nontype-parameter>
+ </template><typedef name="a0"><type><classname>when</classname>< _, A0 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="a1"><type><classname>when</classname>< _, A1 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="result_type"><type>boost::result_of< <classname>Fun</classname>(a0, a1)>::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>true</template-arg></specialization><typedef name="a0"><type><classname>when</classname>< _, A0 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="a1"><type><classname>when</classname>< _, A1 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="result_type"><type>Fun::template impl< a0, a1, Data >::result_type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct-specialization></struct-specialization><struct-specialization name
="call"><template>
       <template-type-parameter name="Fun"/>
       <template-type-parameter name="A0"/>
       <template-type-parameter name="A1"/>
       <template-type-parameter name="A2"/>
- </template><specialization><template-arg>Fun(A0</template-arg><template-arg>A1</template-arg><template-arg>A2)</template-arg></specialization><inherit access="public">boost::proto::callable</inherit><purpose>Call the PolymorphicFunctionObject or the PrimitiveTransform with the current expression, state and data, transformed according to <computeroutput>A0</computeroutput>, <computeroutput>A1</computeroutput>, and <computeroutput>A2</computeroutput>, respectively. </purpose><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+ </template><specialization><template-arg>Fun(A0</template-arg><template-arg>A1</template-arg><template-arg>A2)</template-arg></specialization><inherit access="public">transform< boost::proto::call< Fun(A0, A1, A2)> ></inherit><purpose>Call the PolymorphicFunctionObject or the PrimitiveTransform with the current expression, state and data, transformed according to <computeroutput>A0</computeroutput>, <computeroutput>A1</computeroutput>, and <computeroutput>A2</computeroutput>, respectively. </purpose><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Data"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Data)</template-arg></specialization><typedef name="a0"><type><classname>when</classname>< _, A0 >::template result< void(Expr, State, Data)>::type</type></typedef><typedef name="a1"><type><classname>when</classname>< _, A1 >::template result< void(Expr, State, Data)>::type</type></typedef><typedef name="a2"><type><classname>when</classname>< _, A2 >::template result< void(Expr, State, Data)>::type</type></typedef><typedef name="type"><type>boost::result_of< <classname>Fun</classname>(a0, a1, a2)>::type</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>Let <computeroutput>x</computeroutput> be <computeroutput>when<_, A0>()(expr, state, data)</computeroutput>. Let <computeroutput>y</computeroutput> be <computeroutput>when<_, A1>()(expr, state, data)</computeroutput>. Let <computeroutput>z</computeroutput> be <computeroutput>when<_, A2>()(expr, state, data)</computeroutput>. Return <computeroutput>Fun()(x, y, z)</computeroutput>.</para><para>
-</para></description></method></method-group></struct-specialization><struct-specialization name="call"><template>
+ </template><description><para>Let <computeroutput>x</computeroutput> be <computeroutput>when<_, A0>()(expr, state, data)</computeroutput>. Let <computeroutput>y</computeroutput> be <computeroutput>when<_, A1>()(expr, state, data)</computeroutput>. Let <computeroutput>z</computeroutput> be <computeroutput>when<_, A2>()(expr, state, data)</computeroutput>. Return <computeroutput>Fun()(x, y, z)</computeroutput>.</para><para>
+</para></description></struct><struct name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ <template-nontype-parameter name="B"><type>bool</type></template-nontype-parameter>
+ </template><typedef name="a0"><type><classname>when</classname>< _, A0 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="a1"><type><classname>when</classname>< _, A1 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="a2"><type><classname>when</classname>< _, A2 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="result_type"><type>boost::result_of< <classname>Fun</classname>(a0, a1, a2)>::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename impl2::data_param</paramtype></parameter></method></method-group></struct><struct-specialization name="impl2"><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Data"/>
+ </template><specialization><template-arg>Expr</template-arg><template-arg>State</template-arg><template-arg>Data</template-arg><template-arg>true</template-arg></specialization><typedef name="a0"><type><classname>when</classname>< _, A0 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="a1"><type><classname>when</classname>< _, A1 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="a2"><type><classname>when</classname>< _, A2 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="result_type"><type>Fun::template impl< a0, a1, a2 >::result_type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl2::expr_param</paramtype></parameter><parameter name="state"><paramtype>typename impl2::state_param</paramtype></parameter><parameter name="data"><paramtype>typename imp
l2::data_param</paramtype></parameter></method></method-group></struct-specialization></struct-specialization><struct-specialization name="call"><template>
       <template-type-parameter name="Fun"/>
       <template-type-parameter name="A0"/>
       <template-type-parameter name="A1"/>
       <template-type-parameter name="A2"/>
       <template-type-parameter name="A3"/>
- </template><specialization><template-arg>Fun(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3)</template-arg></specialization><inherit access="public">boost::proto::callable</inherit><purpose>Call the PolymorphicFunctionObject <computeroutput>Fun</computeroutput> with the current expression, state and data, transformed according to <computeroutput>A0</computeroutput> through <computeroutput>AN</computeroutput>. </purpose><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+ </template><specialization><template-arg>Fun(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3)</template-arg></specialization><inherit access="public">transform< boost::proto::call< Fun(A0, A1, A2, A3)> ></inherit><purpose>Call the PolymorphicFunctionObject <computeroutput>Fun</computeroutput> with the current expression, state and data, transformed according to <computeroutput>A0</computeroutput> through <computeroutput>AN</computeroutput>. </purpose><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Data"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Data)</template-arg></specialization><typedef name="a0"><type><classname>when</classname>< _, A0 >::template result< void(Expr, State, Data)>::type</type></typedef><typedef name="a1"><type><classname>when</classname>< _, A1 >::template result< void(Expr, State, Data)>::type</type></typedef><typedef name="a2"><type><classname>when</classname>< _, A2 >::template result< void(Expr, State, Data)>::type</type></typedef><typedef name="a3"><type><classname>when</classname>< _, A3 >::template result< void(Expr, State, Data)>::type</type></typedef><typedef name="type"><type>boost::result_of< <classname>Fun</classname>(a0, a1, a2, a3)>::type</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>Let <computeroutput>ax</computeroutput> be <computeroutput>when<_, Ax>()(expr, state, data)</computeroutput> for each <computeroutput>x</computeroutput> in <computeroutput>[0,N]</computeroutput>. Return <computeroutput>Fun()(a0, a1,... aN)</computeroutput>.</para><para>
-</para></description></method></method-group></struct-specialization><struct-specialization name="call"><template>
+ </template><typedef name="a0"><type><classname>when</classname>< _, A0 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="a1"><type><classname>when</classname>< _, A1 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="a2"><type><classname>when</classname>< _, A2 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="a3"><type><classname>when</classname>< _, A3 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="result_type"><type>boost::result_of< <classname>Fun</classname>(a0, a1, a2, a3)>::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl::expr_param</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>typename impl::state_param</paramtype><d
escription><para>The current state </para></description></parameter><parameter name="data"><paramtype>typename impl::data_param</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>Let <computeroutput>ax</computeroutput> be <computeroutput>when<_, Ax>()(expr, state, data)</computeroutput> for each <computeroutput>x</computeroutput> in <computeroutput>[0,N]</computeroutput>. Return <computeroutput>Fun()(a0, a1,... aN)</computeroutput>.</para><para>
+</para></description></method></method-group></struct></struct-specialization><struct-specialization name="call"><template>
       <template-type-parameter name="Fun"/>
       <template-type-parameter name="A0"/>
       <template-type-parameter name="A1"/>
       <template-type-parameter name="A2"/>
       <template-type-parameter name="A3"/>
       <template-type-parameter name="A4"/>
- </template><specialization><template-arg>Fun(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3</template-arg><template-arg>A4)</template-arg></specialization><inherit access="public">boost::proto::callable</inherit><purpose>Call the PolymorphicFunctionObject <computeroutput>Fun</computeroutput> with the current expression, state and data, transformed according to <computeroutput>A0</computeroutput> through <computeroutput>AN</computeroutput>. </purpose><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+ </template><specialization><template-arg>Fun(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3</template-arg><template-arg>A4)</template-arg></specialization><inherit access="public">transform< boost::proto::call< Fun(A0, A1, A2, A3, A4)> ></inherit><purpose>Call the PolymorphicFunctionObject <computeroutput>Fun</computeroutput> with the current expression, state and data, transformed according to <computeroutput>A0</computeroutput> through <computeroutput>AN</computeroutput>. </purpose><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Data"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Data)</template-arg></specialization><typedef name="a0"><type><classname>when</classname>< _, A0 >::template result< void(Expr, State, Data)>::type</type></typedef><typedef name="a1"><type><classname>when</classname>< _, A1 >::template result< void(Expr, State, Data)>::type</type></typedef><typedef name="a2"><type><classname>when</classname>< _, A2 >::template result< void(Expr, State, Data)>::type</type></typedef><typedef name="a3"><type><classname>when</classname>< _, A3 >::template result< void(Expr, State, Data)>::type</type></typedef><typedef name="a4"><type><classname>when</classname>< _, A4 >::template result< void(Expr, State, Data)>::type</type></typedef><typedef name="type"><type>boost::result_of< <classname>Fun</classname>(a0, a1, a2, a3, a4)>::type</type></typedef></struct-specialization><method-group name="public m
ember functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>Let <computeroutput>ax</computeroutput> be <computeroutput>when<_, Ax>()(expr, state, data)</computeroutput> for each <computeroutput>x</computeroutput> in <computeroutput>[0,N]</computeroutput>. Return <computeroutput>Fun()(a0, a1,... aN)</computeroutput>.</para><para>
-</para></description></method></method-group></struct-specialization></namespace></namespace></header><header name="boost/proto/transform/fold.hpp"><para>Contains definition of the fold<> and reverse_fold<> transforms. </para><namespace name="boost"><namespace name="proto"><struct name="fold"><template>
+ </template><typedef name="a0"><type><classname>when</classname>< _, A0 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="a1"><type><classname>when</classname>< _, A1 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="a2"><type><classname>when</classname>< _, A2 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="a3"><type><classname>when</classname>< _, A3 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="a4"><type><classname>when</classname>< _, A4 >::template impl< Expr, State, Data >::result_type</type></typedef><typedef name="result_type"><type>boost::result_of< <classname>Fun</classname>(a0, a1, a2, a3, a4)>::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl::expr_param</paramtype><descri
ption><para>The current expression </para></description></parameter><parameter name="state"><paramtype>typename impl::state_param</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>typename impl::data_param</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>Let <computeroutput>ax</computeroutput> be <computeroutput>when<_, Ax>()(expr, state, data)</computeroutput> for each <computeroutput>x</computeroutput> in <computeroutput>[0,N]</computeroutput>. Return <computeroutput>Fun()(a0, a1,... aN)</computeroutput>.</para><para>
+</para></description></method></method-group></struct></struct-specialization></namespace></namespace></header><header name="boost/proto/transform/fold.hpp"><para>Contains definition of the fold<> and reverse_fold<> transforms. </para><namespace name="boost"><namespace name="proto"><struct name="fold"><template>
       <template-type-parameter name="Sequence"/>
       <template-type-parameter name="State0"/>
       <template-type-parameter name="Fun"/>
- </template><inherit access="public">boost::proto::callable</inherit><purpose>A PrimitiveTransform that invokes the <computeroutput>fusion::fold<></computeroutput> algorithm to accumulate. </purpose><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+ </template><inherit access="public">transform< boost::proto::fold< Sequence, State0, Fun > ></inherit><purpose>A PrimitiveTransform that invokes the <computeroutput>fusion::fold<></computeroutput> algorithm to accumulate. </purpose><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Data"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Data)</template-arg></specialization><typedef name="sequence"><purpose>A Fusion sequence. </purpose><type><classname>when</classname>< _, Sequence >::template result< void(Expr, State, Data)>::type</type></typedef><typedef name="state0"><purpose>An initial state for the fold. </purpose><type><classname>when</classname>< _, State0 >::template result< void(Expr, State, Data)>::type</type></typedef><typedef name="fun"><purpose><computeroutput>fun(v)(e,s) == when<_,Fun>()(e,s,v)</computeroutput> </purpose><type><emphasis>unspecified</emphasis></type></typedef><typedef name="type"><type>fusion::result_of::fold< sequence, state0, <classname>fun</classname> >::type</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>Let <computeroutput>seq</computeroutput> be <computeroutput>when<_, Sequence>()(expr, state, data)</computeroutput>, let <computeroutput>state0</computeroutput> be <computeroutput>when<_, State0>()(expr, state, data)</computeroutput>, and let <computeroutput>fun(data)</computeroutput> be an object such that <computeroutput>fun(data)(expr, state)</computeroutput> is equivalent to <computeroutput>when<_, Fun>()(expr, state, data)</computeroutput>. Then, this function returns <computeroutput>fusion::fold(seq, state0, fun(data))</computeroutput>.</para><para>
-</para></description></method></method-group></struct><struct name="reverse_fold"><template>
+ </template><typedef name="sequence"><purpose>A Fusion sequence. </purpose><type>remove_reference< typename <classname>when</classname>< _, Sequence >::template <classname>impl</classname>< Expr, State, Data >::result_type >::type</type></typedef><typedef name="state0"><purpose>An initial state for the fold. </purpose><type>remove_reference< typename <classname>when</classname>< _, State0 >::template <classname>impl</classname>< Expr, State, Data >::result_type >::type</type></typedef><typedef name="fun"><purpose><computeroutput>fun(v)(e,s) == when<_,Fun>()(e,s,v)</computeroutput> </purpose><type><emphasis>unspecified</emphasis></type></typedef><typedef name="result_type"><type>fusion::result_of::fold< sequence, state0, <classname>fun</classname> >::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl::expr_param</paramtype><description>
<para>The current expression </para></description></parameter><parameter name="state"><paramtype>typename impl::state_param</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>typename impl::data_param</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>Let <computeroutput>seq</computeroutput> be <computeroutput>when<_, Sequence>()(expr, state, data)</computeroutput>, let <computeroutput>state0</computeroutput> be <computeroutput>when<_, State0>()(expr, state, data)</computeroutput>, and let <computeroutput>fun(data)</computeroutput> be an object such that <computeroutput>fun(data)(expr, state)</computeroutput> is equivalent to <computeroutput>when<_, Fun>()(expr, state, data)</computeroutput>. Then, this function returns <computeroutput>fusion::fold(seq, state0, fun(data))</computeroutput>.</para><para>
+</para></description></method></method-group></struct></struct><struct name="reverse_fold"><template>
       <template-type-parameter name="Sequence"/>
       <template-type-parameter name="State0"/>
       <template-type-parameter name="Fun"/>
@@ -2849,7 +2934,7 @@
       <template-type-parameter name="Sequence"/>
       <template-type-parameter name="State0"/>
       <template-type-parameter name="Fun"/>
- </template><inherit access="public">boost::proto::callable</inherit><purpose>A PrimitiveTransform that recursively applies the <computeroutput>fold<></computeroutput> transform to sub-trees that all share a common tag type. </purpose><description><para><computeroutput>fold_tree<></computeroutput> is useful for flattening trees into lists; for example, you might use <computeroutput>fold_tree<></computeroutput> to flatten an expression tree like <computeroutput>a | b | c</computeroutput> into a Fusion list like <computeroutput>cons(c, cons(b, cons(a)))</computeroutput>.</para><para><computeroutput>fold_tree<></computeroutput> is easily understood in terms of a <computeroutput>recurse_if_<></computeroutput> helper, defined as follows:</para><para><programlisting> template<typename Tag, typename Fun>
+ </template><inherit access="public">transform< boost::proto::fold_tree< Sequence, State0, Fun > ></inherit><purpose>A PrimitiveTransform that recursively applies the <computeroutput>fold<></computeroutput> transform to sub-trees that all share a common tag type. </purpose><description><para><computeroutput>fold_tree<></computeroutput> is useful for flattening trees into lists; for example, you might use <computeroutput>fold_tree<></computeroutput> to flatten an expression tree like <computeroutput>a | b | c</computeroutput> into a Fusion list like <computeroutput>cons(c, cons(b, cons(a)))</computeroutput>.</para><para><computeroutput>fold_tree<></computeroutput> is easily understood in terms of a <computeroutput>recurse_if_<></computeroutput> helper, defined as follows:</para><para><programlisting> template<typename Tag, typename Fun>
  struct recurse_if_
    : if_<
          // If the current node has type type "Tag" ...
@@ -2860,21 +2945,15 @@
        , Fun
      >
  {};
-</programlisting></para><para>With <computeroutput>recurse_if_<></computeroutput> as defined above, <computeroutput>fold_tree<Sequence, State0, Fun>()(expr, state, data)</computeroutput> is equivalent to <computeroutput>fold<Sequence, State0, recurse_if_<Expr::proto_tag, Fun> >()(expr, state, data).</computeroutput> It has the effect of folding a tree front-to-back, recursing into child nodes that share a tag type with the parent node. </para></description><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+</programlisting></para><para>With <computeroutput>recurse_if_<></computeroutput> as defined above, <computeroutput>fold_tree<Sequence, State0, Fun>()(expr, state, data)</computeroutput> is equivalent to <computeroutput>fold<Sequence, State0, recurse_if_<Expr::proto_tag, Fun> >()(expr, state, data).</computeroutput> It has the effect of folding a tree front-to-back, recursing into child nodes that share a tag type with the parent node. </para></description><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Data"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Data)</template-arg></specialization><typedef name="recurse_if_"><purpose><computeroutput>recurse_if_<Expr::proto_tag, Fun></computeroutput>, as described below. </purpose><type><emphasis>unspecified</emphasis></type></typedef><typedef name="impl"><type><classname>fold</classname>< Sequence, State0, <classname>recurse_if_</classname> ></type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Data)>::type</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>Let <computeroutput>R</computeroutput> be <computeroutput>recurse_if_<Expr::proto_tag,Fun></computeroutput> as described below. This function returns <computeroutput>fold<Sequence, State0, R>()(expr, state, data)</computeroutput>.</para><para>
-</para></description></method></method-group></struct><struct name="reverse_fold_tree"><template>
+ </template></struct></struct><struct name="reverse_fold_tree"><template>
       <template-type-parameter name="Sequence"/>
       <template-type-parameter name="State0"/>
       <template-type-parameter name="Fun"/>
- </template><inherit access="public">boost::proto::callable</inherit><purpose>A PrimitiveTransform that recursively applies the <computeroutput>reverse_fold<></computeroutput> transform to sub-trees that all share a common tag type. </purpose><description><para><computeroutput>reverse_fold_tree<></computeroutput> is useful for flattening trees into lists; for example, you might use <computeroutput>reverse_fold_tree<></computeroutput> to flatten an expression tree like <computeroutput>a | b | c</computeroutput> into a Fusion list like <computeroutput>cons(a, cons(b, cons(c)))</computeroutput>.</para><para><computeroutput>reverse_fold_tree<></computeroutput> is easily understood in terms of a <computeroutput>recurse_if_<></computeroutput> helper, defined as follows:</para><para><programlisting> template<typename Tag, typename Fun>
+ </template><inherit access="public">transform< boost::proto::reverse_fold_tree< Sequence, State0, Fun > ></inherit><purpose>A PrimitiveTransform that recursively applies the <computeroutput>reverse_fold<></computeroutput> transform to sub-trees that all share a common tag type. </purpose><description><para><computeroutput>reverse_fold_tree<></computeroutput> is useful for flattening trees into lists; for example, you might use <computeroutput>reverse_fold_tree<></computeroutput> to flatten an expression tree like <computeroutput>a | b | c</computeroutput> into a Fusion list like <computeroutput>cons(a, cons(b, cons(c)))</computeroutput>.</para><para><computeroutput>reverse_fold_tree<></computeroutput> is easily understood in terms of a <computeroutput>recurse_if_<></computeroutput> helper, defined as follows:</para><para><programlisting> template<typename Tag, typename Fun>
  struct recurse_if_
    : if_<
          // If the current node has type type "Tag" ...
@@ -2885,125 +2964,70 @@
        , Fun
      >
  {};
-</programlisting></para><para>With <computeroutput>recurse_if_<></computeroutput> as defined above, <computeroutput>reverse_fold_tree<Sequence, State0, Fun>()(expr, state, data)</computeroutput> is equivalent to <computeroutput>reverse_fold<Sequence, State0, recurse_if_<Expr::proto_tag, Fun> >()(expr, state, data).</computeroutput> It has the effect of folding a tree back-to-front, recursing into child nodes that share a tag type with the parent node. </para></description><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+</programlisting></para><para>With <computeroutput>recurse_if_<></computeroutput> as defined above, <computeroutput>reverse_fold_tree<Sequence, State0, Fun>()(expr, state, data)</computeroutput> is equivalent to <computeroutput>reverse_fold<Sequence, State0, recurse_if_<Expr::proto_tag, Fun> >()(expr, state, data).</computeroutput> It has the effect of folding a tree back-to-front, recursing into child nodes that share a tag type with the parent node. </para></description><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Data"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Data)</template-arg></specialization><typedef name="recurse_if_"><purpose><computeroutput>recurse_if_<Expr::proto_tag, Fun></computeroutput>, as described below. </purpose><type><emphasis>unspecified</emphasis></type></typedef><typedef name="impl"><type><classname>reverse_fold</classname>< Sequence, State0, <classname>recurse_if_</classname> ></type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Data)>::type</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>Let <computeroutput>R</computeroutput> be <computeroutput>recurse_if_<Expr::proto_tag,Fun></computeroutput> as described below. This function returns <computeroutput>reverse_fold<Sequence, State0, R>()(expr, state, data)</computeroutput>.</para><para>
-</para></description></method></method-group></struct></namespace></namespace></header><header name="boost/proto/transform/lazy.hpp"><para>Contains definition of the lazy<> transform. </para><namespace name="boost"><namespace name="proto"><struct name="lazy"><template>
+ </template></struct></struct></namespace></namespace></header><header name="boost/proto/transform/lazy.hpp"><para>Contains definition of the lazy<> transform. </para><namespace name="boost"><namespace name="proto"><struct name="lazy"><template>
       <template-type-parameter name="Object"/>
- </template><inherit access="public">boost::proto::callable</inherit><purpose>A PrimitiveTransform that uses <computeroutput>make<></computeroutput> to build a CallableTransform, and then uses <computeroutput>call<></computeroutput> to apply it. </purpose><description><para><computeroutput>lazy<></computeroutput> is useful as a higher-order transform, when the transform to be applied depends on the current state of the transformation. The invocation of the <computeroutput>make<></computeroutput> transform evaluates any nested transforms, and the resulting type is treated as a CallableTransform, which is evaluated with <computeroutput>call<></computeroutput>. </para></description><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+ </template><inherit access="public">transform< boost::proto::lazy< Object > ></inherit><purpose>A PrimitiveTransform that uses <computeroutput>make<></computeroutput> to build a CallableTransform, and then uses <computeroutput>call<></computeroutput> to apply it. </purpose><description><para><computeroutput>lazy<></computeroutput> is useful as a higher-order transform, when the transform to be applied depends on the current state of the transformation. The invocation of the <computeroutput>make<></computeroutput> transform evaluates any nested transforms, and the resulting type is treated as a CallableTransform, which is evaluated with <computeroutput>call<></computeroutput>. </para></description><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Data"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Data)</template-arg></specialization><typedef name="fun"><type><classname>make</classname>< Object >::template result< void(Expr, State, Data)>::type</type></typedef><typedef name="impl"><type><classname>call</classname>< fun ></type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Data)>::type</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>Build a CallableTransform by applying <computeroutput>make<></computeroutput> and evaluate it with <computeroutput>call<></computeroutput></para><para>
-
-</para></description><returns><para><computeroutput>result<void(Expr, State, Data)>::impl()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><struct-specialization name="lazy"><template>
+ </template></struct></struct><struct-specialization name="lazy"><template>
       <template-type-parameter name="Object"/>
- </template><specialization><template-arg>Object()</template-arg></specialization><inherit access="public">boost::proto::callable</inherit><purpose>A PrimitiveTransform that uses <computeroutput>make<></computeroutput> to build a CallableTransform, and then uses <computeroutput>call<></computeroutput> to apply it. </purpose><description><para><computeroutput>lazy<></computeroutput> is useful as a higher-order transform, when the transform to be applied depends on the current state of the transformation. The invocation of the <computeroutput>make<></computeroutput> transform evaluates any nested transforms, and the resulting type is treated as a CallableTransform, which is evaluated with <computeroutput>call<></computeroutput>. </para></description><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+ </template><specialization><template-arg>Object()</template-arg></specialization><inherit access="public">transform< boost::proto::lazy< Object()> ></inherit><purpose>A PrimitiveTransform that uses <computeroutput>make<></computeroutput> to build a CallableTransform, and then uses <computeroutput>call<></computeroutput> to apply it. </purpose><description><para><computeroutput>lazy<></computeroutput> is useful as a higher-order transform, when the transform to be applied depends on the current state of the transformation. The invocation of the <computeroutput>make<></computeroutput> transform evaluates any nested transforms, and the resulting type is treated as a CallableTransform, which is evaluated with <computeroutput>call<></computeroutput>. </para></description><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Data"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Data)</template-arg></specialization><typedef name="fun"><type><classname>make</classname>< Object >::template result< void(Expr, State, Data)>::type</type></typedef><typedef name="impl"><type><classname>call</classname>< fun()></type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Data)>::type</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>Build a CallableTransform by applying <computeroutput>make<></computeroutput> and evaluate it with <computeroutput>call<></computeroutput></para><para>
-
-</para></description><returns><para><computeroutput>result<void(Expr, State, Data)>::impl()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct-specialization><struct-specialization name="lazy"><template>
+ </template></struct></struct-specialization><struct-specialization name="lazy"><template>
       <template-type-parameter name="Object"/>
       <template-type-parameter name="A0"/>
- </template><specialization><template-arg>Object(A0)</template-arg></specialization><inherit access="public">boost::proto::callable</inherit><purpose>A PrimitiveTransform that uses <computeroutput>make<></computeroutput> to build a CallableTransform, and then uses <computeroutput>call<></computeroutput> to apply it. </purpose><description><para><computeroutput>lazy<></computeroutput> is useful as a higher-order transform, when the transform to be applied depends on the current state of the transformation. The invocation of the <computeroutput>make<></computeroutput> transform evaluates any nested transforms, and the resulting type is treated as a CallableTransform, which is evaluated with <computeroutput>call<></computeroutput>. </para></description><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+ </template><specialization><template-arg>Object(A0)</template-arg></specialization><inherit access="public">transform< boost::proto::lazy< Object(A0)> ></inherit><purpose>A PrimitiveTransform that uses <computeroutput>make<></computeroutput> to build a CallableTransform, and then uses <computeroutput>call<></computeroutput> to apply it. </purpose><description><para><computeroutput>lazy<></computeroutput> is useful as a higher-order transform, when the transform to be applied depends on the current state of the transformation. The invocation of the <computeroutput>make<></computeroutput> transform evaluates any nested transforms, and the resulting type is treated as a CallableTransform, which is evaluated with <computeroutput>call<></computeroutput>. </para></description><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Data"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Data)</template-arg></specialization><typedef name="fun"><type><classname>make</classname>< Object >::template result< void(Expr, State, Data)>::type</type></typedef><typedef name="impl"><type><classname>call</classname>< fun(A0)></type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Data)>::type</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>Build a CallableTransform by applying <computeroutput>make<></computeroutput> and evaluate it with <computeroutput>call<></computeroutput></para><para>
-
-</para></description><returns><para><computeroutput>result<void(Expr, State, Data)>::impl()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct-specialization><struct-specialization name="lazy"><template>
+ </template></struct></struct-specialization><struct-specialization name="lazy"><template>
       <template-type-parameter name="Object"/>
       <template-type-parameter name="A0"/>
       <template-type-parameter name="A1"/>
- </template><specialization><template-arg>Object(A0</template-arg><template-arg>A1)</template-arg></specialization><inherit access="public">boost::proto::callable</inherit><purpose>A PrimitiveTransform that uses <computeroutput>make<></computeroutput> to build a CallableTransform, and then uses <computeroutput>call<></computeroutput> to apply it. </purpose><description><para><computeroutput>lazy<></computeroutput> is useful as a higher-order transform, when the transform to be applied depends on the current state of the transformation. The invocation of the <computeroutput>make<></computeroutput> transform evaluates any nested transforms, and the resulting type is treated as a CallableTransform, which is evaluated with <computeroutput>call<></computeroutput>. </para></description><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+ </template><specialization><template-arg>Object(A0</template-arg><template-arg>A1)</template-arg></specialization><inherit access="public">transform< boost::proto::lazy< Object(A0, A1)> ></inherit><purpose>A PrimitiveTransform that uses <computeroutput>make<></computeroutput> to build a CallableTransform, and then uses <computeroutput>call<></computeroutput> to apply it. </purpose><description><para><computeroutput>lazy<></computeroutput> is useful as a higher-order transform, when the transform to be applied depends on the current state of the transformation. The invocation of the <computeroutput>make<></computeroutput> transform evaluates any nested transforms, and the resulting type is treated as a CallableTransform, which is evaluated with <computeroutput>call<></computeroutput>. </para></description><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Data"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Data)</template-arg></specialization><typedef name="fun"><type><classname>make</classname>< Object >::template result< void(Expr, State, Data)>::type</type></typedef><typedef name="impl"><type><classname>call</classname>< fun(A0, A1)></type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Data)>::type</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>Build a CallableTransform by applying <computeroutput>make<></computeroutput> and evaluate it with <computeroutput>call<></computeroutput></para><para>
-
-</para></description><returns><para><computeroutput>result<void(Expr, State, Data)>::impl()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct-specialization><struct-specialization name="lazy"><template>
+ </template></struct></struct-specialization><struct-specialization name="lazy"><template>
       <template-type-parameter name="Object"/>
       <template-type-parameter name="A0"/>
       <template-type-parameter name="A1"/>
       <template-type-parameter name="A2"/>
- </template><specialization><template-arg>Object(A0</template-arg><template-arg>A1</template-arg><template-arg>A2)</template-arg></specialization><inherit access="public">boost::proto::callable</inherit><purpose>A PrimitiveTransform that uses <computeroutput>make<></computeroutput> to build a CallableTransform, and then uses <computeroutput>call<></computeroutput> to apply it. </purpose><description><para><computeroutput>lazy<></computeroutput> is useful as a higher-order transform, when the transform to be applied depends on the current state of the transformation. The invocation of the <computeroutput>make<></computeroutput> transform evaluates any nested transforms, and the resulting type is treated as a CallableTransform, which is evaluated with <computeroutput>call<></computeroutput>. </para></description><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+ </template><specialization><template-arg>Object(A0</template-arg><template-arg>A1</template-arg><template-arg>A2)</template-arg></specialization><inherit access="public">transform< boost::proto::lazy< Object(A0, A1, A2)> ></inherit><purpose>A PrimitiveTransform that uses <computeroutput>make<></computeroutput> to build a CallableTransform, and then uses <computeroutput>call<></computeroutput> to apply it. </purpose><description><para><computeroutput>lazy<></computeroutput> is useful as a higher-order transform, when the transform to be applied depends on the current state of the transformation. The invocation of the <computeroutput>make<></computeroutput> transform evaluates any nested transforms, and the resulting type is treated as a CallableTransform, which is evaluated with <computeroutput>call<></computeroutput>. </para></description><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Data"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Data)</template-arg></specialization><typedef name="fun"><type><classname>make</classname>< Object >::template result< void(Expr, State, Data)>::type</type></typedef><typedef name="impl"><type><classname>call</classname>< fun(A0, A1, A2)></type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Data)>::type</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>Build a CallableTransform by applying <computeroutput>make<></computeroutput> and evaluate it with <computeroutput>call<></computeroutput></para><para>
-
-</para></description><returns><para><computeroutput>result<void(Expr, State, Data)>::impl()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct-specialization><struct-specialization name="lazy"><template>
+ </template></struct></struct-specialization><struct-specialization name="lazy"><template>
       <template-type-parameter name="Object"/>
       <template-type-parameter name="A0"/>
       <template-type-parameter name="A1"/>
       <template-type-parameter name="A2"/>
       <template-type-parameter name="A3"/>
- </template><specialization><template-arg>Object(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3)</template-arg></specialization><inherit access="public">boost::proto::callable</inherit><purpose>A PrimitiveTransform that uses <computeroutput>make<></computeroutput> to build a CallableTransform, and then uses <computeroutput>call<></computeroutput> to apply it. </purpose><description><para><computeroutput>lazy<></computeroutput> is useful as a higher-order transform, when the transform to be applied depends on the current state of the transformation. The invocation of the <computeroutput>make<></computeroutput> transform evaluates any nested transforms, and the resulting type is treated as a CallableTransform, which is evaluated with <computeroutput>call<></computeroutput>. </para></description><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+ </template><specialization><template-arg>Object(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3)</template-arg></specialization><inherit access="public">transform< boost::proto::lazy< Object(A0, A1, A2, A3)> ></inherit><purpose>A PrimitiveTransform that uses <computeroutput>make<></computeroutput> to build a CallableTransform, and then uses <computeroutput>call<></computeroutput> to apply it. </purpose><description><para><computeroutput>lazy<></computeroutput> is useful as a higher-order transform, when the transform to be applied depends on the current state of the transformation. The invocation of the <computeroutput>make<></computeroutput> transform evaluates any nested transforms, and the resulting type is treated as a CallableTransform, which is evaluated with <computeroutput>call<></computeroutput>. </para></description><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Data"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Data)</template-arg></specialization><typedef name="fun"><type><classname>make</classname>< Object >::template result< void(Expr, State, Data)>::type</type></typedef><typedef name="impl"><type><classname>call</classname>< fun(A0, A1, A2, A3)></type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Data)>::type</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>Build a CallableTransform by applying <computeroutput>make<></computeroutput> and evaluate it with <computeroutput>call<></computeroutput></para><para>
-
-</para></description><returns><para><computeroutput>result<void(Expr, State, Data)>::impl()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct-specialization><struct-specialization name="lazy"><template>
+ </template></struct></struct-specialization><struct-specialization name="lazy"><template>
       <template-type-parameter name="Object"/>
       <template-type-parameter name="A0"/>
       <template-type-parameter name="A1"/>
       <template-type-parameter name="A2"/>
       <template-type-parameter name="A3"/>
       <template-type-parameter name="A4"/>
- </template><specialization><template-arg>Object(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3</template-arg><template-arg>A4)</template-arg></specialization><inherit access="public">boost::proto::callable</inherit><purpose>A PrimitiveTransform that uses <computeroutput>make<></computeroutput> to build a CallableTransform, and then uses <computeroutput>call<></computeroutput> to apply it. </purpose><description><para><computeroutput>lazy<></computeroutput> is useful as a higher-order transform, when the transform to be applied depends on the current state of the transformation. The invocation of the <computeroutput>make<></computeroutput> transform evaluates any nested transforms, and the resulting type is treated as a CallableTransform, which is evaluated with <computeroutput>call<></computeroutput>. </para></description><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+ </template><specialization><template-arg>Object(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3</template-arg><template-arg>A4)</template-arg></specialization><inherit access="public">transform< boost::proto::lazy< Object(A0, A1, A2, A3, A4)> ></inherit><purpose>A PrimitiveTransform that uses <computeroutput>make<></computeroutput> to build a CallableTransform, and then uses <computeroutput>call<></computeroutput> to apply it. </purpose><description><para><computeroutput>lazy<></computeroutput> is useful as a higher-order transform, when the transform to be applied depends on the current state of the transformation. The invocation of the <computeroutput>make<></computeroutput> transform evaluates any nested transforms, and the resulting type is treated as a CallableTransform, which is evaluated with <computeroutput>call<></computeroutput>. </para></description><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Data"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Data)</template-arg></specialization><typedef name="fun"><type><classname>make</classname>< Object >::template result< void(Expr, State, Data)>::type</type></typedef><typedef name="impl"><type><classname>call</classname>< fun(A0, A1, A2, A3, A4)></type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Data)>::type</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>Build a CallableTransform by applying <computeroutput>make<></computeroutput> and evaluate it with <computeroutput>call<></computeroutput></para><para>
-
-</para></description><returns><para><computeroutput>result<void(Expr, State, Data)>::impl()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct-specialization></namespace></namespace></header><header name="boost/proto/transform/make.hpp"><para>Contains definition of the make<> transform. </para><namespace name="boost"><namespace name="proto"><struct name="make"><template>
+ </template></struct></struct-specialization></namespace></namespace></header><header name="boost/proto/transform/make.hpp"><para>Contains definition of the make<> transform. </para><namespace name="boost"><namespace name="proto"><struct name="make"><template>
       <template-type-parameter name="Object"/>
- </template><inherit access="public">boost::proto::callable</inherit><purpose>A PrimitiveTransform which computes a type by evaluating any nested transforms and then constructs an object of that type. </purpose><description><para>The <computeroutput>make<></computeroutput> transform checks to see if <computeroutput>Object</computeroutput> is a template. If it is, the template type is disassembled to find nested transforms. Proto considers the following types to represent transforms:</para><para><itemizedlist>
+ </template><inherit access="public">transform< boost::proto::make< Object > ></inherit><purpose>A PrimitiveTransform which computes a type by evaluating any nested transforms and then constructs an object of that type. </purpose><description><para>The <computeroutput>make<></computeroutput> transform checks to see if <computeroutput>Object</computeroutput> is a template. If it is, the template type is disassembled to find nested transforms. Proto considers the following types to represent transforms:</para><para><itemizedlist>
<listitem><para>Function types </para></listitem>
<listitem><para>Function pointer types </para></listitem>
<listitem><para>Types for which <computeroutput>proto::is_callable< type >::value</computeroutput> is <computeroutput>true</computeroutput> </para></listitem>
@@ -3015,107 +3039,71 @@
<listitem><para>If any substitutions took place in any of the above steps and <computeroutput>T<X0',X1',...></computeroutput> has a nested <computeroutput>type</computeroutput> typedef, the result type is <computeroutput>T<X0',X1',...>::type</computeroutput>. </para></listitem>
<listitem><para>Otherwise, the result type is <computeroutput>T<X0',X1',...></computeroutput>.</para></listitem>
</itemizedlist>
-Note that <computeroutput>when<></computeroutput> is implemented in terms of <computeroutput>call<></computeroutput> and <computeroutput>make<></computeroutput>, so the above procedure is evaluated recursively. </para></description><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+Note that <computeroutput>when<></computeroutput> is implemented in terms of <computeroutput>call<></computeroutput> and <computeroutput>make<></computeroutput>, so the above procedure is evaluated recursively. </para></description><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Data"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Data)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name=""><paramtype>Expr const &</paramtype></parameter><parameter name=""><paramtype>State const &</paramtype></parameter><parameter name=""><paramtype>Data &</paramtype></parameter><description><para>
-
-</para></description><returns><para><computeroutput>result<void(Expr, State, Data)>::type()</computeroutput> </para></returns></method></method-group></struct><struct-specialization name="make"><template>
+ </template><typedef name="result_type"><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name=""><paramtype>typename impl::expr_param</paramtype></parameter><parameter name=""><paramtype>typename impl::state_param</paramtype></parameter><parameter name=""><paramtype>typename impl::data_param</paramtype></parameter><purpose>
+</purpose></method></method-group></struct></struct><struct-specialization name="make"><template>
       <template-type-parameter name="Object"/>
- </template><specialization><template-arg>Object()</template-arg></specialization><inherit access="public">boost::proto::callable</inherit><purpose>A PrimitiveTransform which computes a type by evaluating any nested transforms and then constructs an object of that type with the current expression, state and data, transformed according to <computeroutput>A0</computeroutput> through <computeroutput>AN</computeroutput>. </purpose><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+ </template><specialization><template-arg>Object()</template-arg></specialization><inherit access="public">transform< boost::proto::make< Object()> ></inherit><purpose>A PrimitiveTransform which computes a type by evaluating any nested transforms and then constructs an object of that type with the current expression, state and data, transformed according to <computeroutput>A0</computeroutput> through <computeroutput>AN</computeroutput>. </purpose><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Data"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Data)</template-arg></specialization><typedef name="type"><purpose><computeroutput>make<Object>::result<void(Expr, State, Data)>::type</computeroutput> </purpose><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>Let <computeroutput>ax</computeroutput> be <computeroutput>when<_, Ax>()(expr, state, data)</computeroutput> for each <computeroutput>x</computeroutput> in <computeroutput>[0,N]</computeroutput>. Let <computeroutput>T</computeroutput> be <computeroutput>result<void(Expr, State, Data)>::type</computeroutput>. Return <computeroutput>T(a0, a1,... aN)</computeroutput>.</para><para>
-</para></description></method></method-group></struct-specialization><struct-specialization name="make"><template>
+ </template><typedef name="result_type"><purpose><computeroutput>make<Object>::result<void(Expr, State, Data)>::type</computeroutput> </purpose><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl::expr_param</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>typename impl::state_param</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>typename impl::data_param</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>Let <computeroutput>ax</computeroutput> be <computeroutput>when<_, Ax>()(expr, state, data)</computeroutput> for each <computeroutput>x</computeroutput> in <computeroutput>[0,N]</computeroutput>. Let <computeroutput>T</computeroutput> be <computer
output>result<void(Expr, State, Data)>::type</computeroutput>. Return <computeroutput>T(a0, a1,... aN)</computeroutput>.</para><para>
+</para></description></method></method-group></struct></struct-specialization><struct-specialization name="make"><template>
       <template-type-parameter name="Object"/>
       <template-type-parameter name="A0"/>
- </template><specialization><template-arg>Object(A0)</template-arg></specialization><inherit access="public">boost::proto::callable</inherit><purpose>A PrimitiveTransform which computes a type by evaluating any nested transforms and then constructs an object of that type with the current expression, state and data, transformed according to <computeroutput>A0</computeroutput> through <computeroutput>AN</computeroutput>. </purpose><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+ </template><specialization><template-arg>Object(A0)</template-arg></specialization><inherit access="public">transform< boost::proto::make< Object(A0)> ></inherit><purpose>A PrimitiveTransform which computes a type by evaluating any nested transforms and then constructs an object of that type with the current expression, state and data, transformed according to <computeroutput>A0</computeroutput> through <computeroutput>AN</computeroutput>. </purpose><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Data"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Data)</template-arg></specialization><typedef name="type"><purpose><computeroutput>make<Object>::result<void(Expr, State, Data)>::type</computeroutput> </purpose><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>Let <computeroutput>ax</computeroutput> be <computeroutput>when<_, Ax>()(expr, state, data)</computeroutput> for each <computeroutput>x</computeroutput> in <computeroutput>[0,N]</computeroutput>. Let <computeroutput>T</computeroutput> be <computeroutput>result<void(Expr, State, Data)>::type</computeroutput>. Return <computeroutput>T(a0, a1,... aN)</computeroutput>.</para><para>
-</para></description></method></method-group></struct-specialization><struct-specialization name="make"><template>
+ </template><typedef name="result_type"><purpose><computeroutput>make<Object>::result<void(Expr, State, Data)>::type</computeroutput> </purpose><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl::expr_param</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>typename impl::state_param</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>typename impl::data_param</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>Let <computeroutput>ax</computeroutput> be <computeroutput>when<_, Ax>()(expr, state, data)</computeroutput> for each <computeroutput>x</computeroutput> in <computeroutput>[0,N]</computeroutput>. Let <computeroutput>T</computeroutput> be <computer
output>result<void(Expr, State, Data)>::type</computeroutput>. Return <computeroutput>T(a0, a1,... aN)</computeroutput>.</para><para>
+</para></description></method></method-group></struct></struct-specialization><struct-specialization name="make"><template>
       <template-type-parameter name="Object"/>
       <template-type-parameter name="A0"/>
       <template-type-parameter name="A1"/>
- </template><specialization><template-arg>Object(A0</template-arg><template-arg>A1)</template-arg></specialization><inherit access="public">boost::proto::callable</inherit><purpose>A PrimitiveTransform which computes a type by evaluating any nested transforms and then constructs an object of that type with the current expression, state and data, transformed according to <computeroutput>A0</computeroutput> through <computeroutput>AN</computeroutput>. </purpose><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+ </template><specialization><template-arg>Object(A0</template-arg><template-arg>A1)</template-arg></specialization><inherit access="public">transform< boost::proto::make< Object(A0, A1)> ></inherit><purpose>A PrimitiveTransform which computes a type by evaluating any nested transforms and then constructs an object of that type with the current expression, state and data, transformed according to <computeroutput>A0</computeroutput> through <computeroutput>AN</computeroutput>. </purpose><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Data"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Data)</template-arg></specialization><typedef name="type"><purpose><computeroutput>make<Object>::result<void(Expr, State, Data)>::type</computeroutput> </purpose><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>Let <computeroutput>ax</computeroutput> be <computeroutput>when<_, Ax>()(expr, state, data)</computeroutput> for each <computeroutput>x</computeroutput> in <computeroutput>[0,N]</computeroutput>. Let <computeroutput>T</computeroutput> be <computeroutput>result<void(Expr, State, Data)>::type</computeroutput>. Return <computeroutput>T(a0, a1,... aN)</computeroutput>.</para><para>
-</para></description></method></method-group></struct-specialization><struct-specialization name="make"><template>
+ </template><typedef name="result_type"><purpose><computeroutput>make<Object>::result<void(Expr, State, Data)>::type</computeroutput> </purpose><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl::expr_param</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>typename impl::state_param</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>typename impl::data_param</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>Let <computeroutput>ax</computeroutput> be <computeroutput>when<_, Ax>()(expr, state, data)</computeroutput> for each <computeroutput>x</computeroutput> in <computeroutput>[0,N]</computeroutput>. Let <computeroutput>T</computeroutput> be <computer
output>result<void(Expr, State, Data)>::type</computeroutput>. Return <computeroutput>T(a0, a1,... aN)</computeroutput>.</para><para>
+</para></description></method></method-group></struct></struct-specialization><struct-specialization name="make"><template>
       <template-type-parameter name="Object"/>
       <template-type-parameter name="A0"/>
       <template-type-parameter name="A1"/>
       <template-type-parameter name="A2"/>
- </template><specialization><template-arg>Object(A0</template-arg><template-arg>A1</template-arg><template-arg>A2)</template-arg></specialization><inherit access="public">boost::proto::callable</inherit><purpose>A PrimitiveTransform which computes a type by evaluating any nested transforms and then constructs an object of that type with the current expression, state and data, transformed according to <computeroutput>A0</computeroutput> through <computeroutput>AN</computeroutput>. </purpose><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+ </template><specialization><template-arg>Object(A0</template-arg><template-arg>A1</template-arg><template-arg>A2)</template-arg></specialization><inherit access="public">transform< boost::proto::make< Object(A0, A1, A2)> ></inherit><purpose>A PrimitiveTransform which computes a type by evaluating any nested transforms and then constructs an object of that type with the current expression, state and data, transformed according to <computeroutput>A0</computeroutput> through <computeroutput>AN</computeroutput>. </purpose><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Data"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Data)</template-arg></specialization><typedef name="type"><purpose><computeroutput>make<Object>::result<void(Expr, State, Data)>::type</computeroutput> </purpose><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>Let <computeroutput>ax</computeroutput> be <computeroutput>when<_, Ax>()(expr, state, data)</computeroutput> for each <computeroutput>x</computeroutput> in <computeroutput>[0,N]</computeroutput>. Let <computeroutput>T</computeroutput> be <computeroutput>result<void(Expr, State, Data)>::type</computeroutput>. Return <computeroutput>T(a0, a1,... aN)</computeroutput>.</para><para>
-</para></description></method></method-group></struct-specialization><struct-specialization name="make"><template>
+ </template><typedef name="result_type"><purpose><computeroutput>make<Object>::result<void(Expr, State, Data)>::type</computeroutput> </purpose><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl::expr_param</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>typename impl::state_param</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>typename impl::data_param</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>Let <computeroutput>ax</computeroutput> be <computeroutput>when<_, Ax>()(expr, state, data)</computeroutput> for each <computeroutput>x</computeroutput> in <computeroutput>[0,N]</computeroutput>. Let <computeroutput>T</computeroutput> be <computer
output>result<void(Expr, State, Data)>::type</computeroutput>. Return <computeroutput>T(a0, a1,... aN)</computeroutput>.</para><para>
+</para></description></method></method-group></struct></struct-specialization><struct-specialization name="make"><template>
       <template-type-parameter name="Object"/>
       <template-type-parameter name="A0"/>
       <template-type-parameter name="A1"/>
       <template-type-parameter name="A2"/>
       <template-type-parameter name="A3"/>
- </template><specialization><template-arg>Object(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3)</template-arg></specialization><inherit access="public">boost::proto::callable</inherit><purpose>A PrimitiveTransform which computes a type by evaluating any nested transforms and then constructs an object of that type with the current expression, state and data, transformed according to <computeroutput>A0</computeroutput> through <computeroutput>AN</computeroutput>. </purpose><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+ </template><specialization><template-arg>Object(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3)</template-arg></specialization><inherit access="public">transform< boost::proto::make< Object(A0, A1, A2, A3)> ></inherit><purpose>A PrimitiveTransform which computes a type by evaluating any nested transforms and then constructs an object of that type with the current expression, state and data, transformed according to <computeroutput>A0</computeroutput> through <computeroutput>AN</computeroutput>. </purpose><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Data"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Data)</template-arg></specialization><typedef name="type"><purpose><computeroutput>make<Object>::result<void(Expr, State, Data)>::type</computeroutput> </purpose><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>Let <computeroutput>ax</computeroutput> be <computeroutput>when<_, Ax>()(expr, state, data)</computeroutput> for each <computeroutput>x</computeroutput> in <computeroutput>[0,N]</computeroutput>. Let <computeroutput>T</computeroutput> be <computeroutput>result<void(Expr, State, Data)>::type</computeroutput>. Return <computeroutput>T(a0, a1,... aN)</computeroutput>.</para><para>
-</para></description></method></method-group></struct-specialization><struct-specialization name="make"><template>
+ </template><typedef name="result_type"><purpose><computeroutput>make<Object>::result<void(Expr, State, Data)>::type</computeroutput> </purpose><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl::expr_param</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>typename impl::state_param</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>typename impl::data_param</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>Let <computeroutput>ax</computeroutput> be <computeroutput>when<_, Ax>()(expr, state, data)</computeroutput> for each <computeroutput>x</computeroutput> in <computeroutput>[0,N]</computeroutput>. Let <computeroutput>T</computeroutput> be <computer
output>result<void(Expr, State, Data)>::type</computeroutput>. Return <computeroutput>T(a0, a1,... aN)</computeroutput>.</para><para>
+</para></description></method></method-group></struct></struct-specialization><struct-specialization name="make"><template>
       <template-type-parameter name="Object"/>
       <template-type-parameter name="A0"/>
       <template-type-parameter name="A1"/>
       <template-type-parameter name="A2"/>
       <template-type-parameter name="A3"/>
       <template-type-parameter name="A4"/>
- </template><specialization><template-arg>Object(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3</template-arg><template-arg>A4)</template-arg></specialization><inherit access="public">boost::proto::callable</inherit><purpose>A PrimitiveTransform which computes a type by evaluating any nested transforms and then constructs an object of that type with the current expression, state and data, transformed according to <computeroutput>A0</computeroutput> through <computeroutput>AN</computeroutput>. </purpose><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+ </template><specialization><template-arg>Object(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3</template-arg><template-arg>A4)</template-arg></specialization><inherit access="public">transform< boost::proto::make< Object(A0, A1, A2, A3, A4)> ></inherit><purpose>A PrimitiveTransform which computes a type by evaluating any nested transforms and then constructs an object of that type with the current expression, state and data, transformed according to <computeroutput>A0</computeroutput> through <computeroutput>AN</computeroutput>. </purpose><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Data"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Data)</template-arg></specialization><typedef name="type"><purpose><computeroutput>make<Object>::result<void(Expr, State, Data)>::type</computeroutput> </purpose><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>Let <computeroutput>ax</computeroutput> be <computeroutput>when<_, Ax>()(expr, state, data)</computeroutput> for each <computeroutput>x</computeroutput> in <computeroutput>[0,N]</computeroutput>. Let <computeroutput>T</computeroutput> be <computeroutput>result<void(Expr, State, Data)>::type</computeroutput>. Return <computeroutput>T(a0, a1,... aN)</computeroutput>.</para><para>
-</para></description></method></method-group></struct-specialization></namespace></namespace></header><header name="boost/proto/transform/pass_through.hpp"><para>Definition of the pass_through transform, which is the default transform of all of the expression generator metafunctions such as unary_plus<>, plus<> and nary_expr<>. </para><namespace name="boost"><namespace name="proto"><struct name="pass_through"><template>
+ </template><typedef name="result_type"><purpose><computeroutput>make<Object>::result<void(Expr, State, Data)>::type</computeroutput> </purpose><type><emphasis>unspecified</emphasis></type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl::expr_param</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>typename impl::state_param</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>typename impl::data_param</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>Let <computeroutput>ax</computeroutput> be <computeroutput>when<_, Ax>()(expr, state, data)</computeroutput> for each <computeroutput>x</computeroutput> in <computeroutput>[0,N]</computeroutput>. Let <computeroutput>T</computeroutput> be <computer
output>result<void(Expr, State, Data)>::type</computeroutput>. Return <computeroutput>T(a0, a1,... aN)</computeroutput>.</para><para>
+</para></description></method></method-group></struct></struct-specialization></namespace></namespace></header><header name="boost/proto/transform/pass_through.hpp"><para>Definition of the pass_through transform, which is the default transform of all of the expression generator metafunctions such as unary_plus<>, plus<> and nary_expr<>. </para><namespace name="boost"><namespace name="proto"><struct name="pass_through"><template>
       <template-type-parameter name="Grammar"/>
- </template><inherit access="public">boost::proto::callable</inherit><purpose>A PrimitiveTransform that transforms the child expressions of an expression node according to the corresponding children of a Grammar. </purpose><description><para>Given a Grammar such as <computeroutput>plus<T0, T1></computeroutput>, an expression type that matches the grammar such as <computeroutput>plus<E0, E1>::type</computeroutput>, a state <computeroutput>S</computeroutput> and a data <computeroutput>V</computeroutput>, the result of applying the <computeroutput>pass_through<plus<T0, T1> ></computeroutput> transform is:</para><para><programlisting> plus<
+ </template><inherit access="public">transform< boost::proto::pass_through< Grammar > ></inherit><purpose>A PrimitiveTransform that transforms the child expressions of an expression node according to the corresponding children of a Grammar. </purpose><description><para>Given a Grammar such as <computeroutput>plus<T0, T1></computeroutput>, an expression type that matches the grammar such as <computeroutput>plus<E0, E1>::type</computeroutput>, a state <computeroutput>S</computeroutput> and a data <computeroutput>V</computeroutput>, the result of applying the <computeroutput>pass_through<plus<T0, T1> ></computeroutput> transform is:</para><para><programlisting> plus<
      T0::result<void(E0, S, V)>::type
    , T1::result<void(E1, S, V)>::type
  >::type
@@ -3136,18 +3124,11 @@
        , nary_expr<_, vararg<Promote> >
      >
  {};
-</programlisting> </para></description><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+</programlisting> </para></description><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Data"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Data)</template-arg></specialization><typedef name="impl"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="type"><type>impl::type</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>
-
-</para></description><requires><para><computeroutput>matches<Expr, Grammar>::value</computeroutput> is <computeroutput>true</computeroutput>. </para></requires></method></method-group></struct></namespace></namespace></header><header name="boost/proto/transform/when.hpp"><para>Definition of when transform. </para><namespace name="boost"><namespace name="proto"><struct name="when"><template>
+ </template></struct></struct></namespace></namespace></header><header name="boost/proto/transform/when.hpp"><para>Definition of when transform. </para><namespace name="boost"><namespace name="proto"><struct name="when"><template>
       <template-type-parameter name="Grammar"/>
       <template-type-parameter name="PrimitiveTransform"><default>Grammar</default></template-type-parameter>
     </template><purpose>A grammar element and a PrimitiveTransform that associates a transform with the grammar. </purpose><description><para>Use <computeroutput>when<></computeroutput> to override a grammar's default transform with a custom transform. It is for used when composing larger transforms by associating smaller transforms with individual rules in your grammar, as in the following transform which counts the number of terminals in an expression.</para><para><programlisting> // Count the terminals in an expression tree.
@@ -3174,7 +3155,7 @@
</programlisting> </para></description></struct><struct-specialization name="when"><template>
       <template-type-parameter name="Grammar"/>
       <template-type-parameter name="R"/>
- </template><specialization><template-arg>Grammar</template-arg><template-arg>R()</template-arg></specialization><inherit access="public">boost::proto::callable</inherit><purpose>A grammar element and a PrimitiveTransform that associates a transform with the grammar. </purpose><description><para>Use <computeroutput>when<></computeroutput> to override a grammar's default transform with a custom transform. It is for used when composing larger transforms by associating smaller transforms with individual rules in your grammar, as in the following transform which counts the number of terminals in an expression.</para><para><programlisting> // Count the terminals in an expression tree.
+ </template><specialization><template-arg>Grammar</template-arg><template-arg>R()</template-arg></specialization><inherit access="public">transform< boost::proto::when< Grammar, R()> ></inherit><purpose>A grammar element and a PrimitiveTransform that associates a transform with the grammar. </purpose><description><para>Use <computeroutput>when<></computeroutput> to override a grammar's default transform with a custom transform. It is for used when composing larger transforms by associating smaller transforms with individual rules in your grammar, as in the following transform which counts the number of terminals in an expression.</para><para><programlisting> // Count the terminals in an expression tree.
  // Must be invoked with initial state == mpl::int_<0>().
  struct CountLeaves
    : or_<
@@ -3182,23 +3163,18 @@
        , otherwise<fold<_, _state, CountLeaves> >
      >
  {};
-</programlisting></para><para>The <computeroutput>when<G, R(A0,A1,...)></computeroutput> form accepts either a CallableTransform or an ObjectTransform as its second parameter. <computeroutput>when<></computeroutput> uses <computeroutput>is_callable<R>::value</computeroutput> to distinguish between the two, and uses <computeroutput>call<></computeroutput> to evaluate CallableTransforms and <computeroutput>make<></computeroutput> to evaluate ObjectTransforms. </para></description><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+</programlisting></para><para>The <computeroutput>when<G, R(A0,A1,...)></computeroutput> form accepts either a CallableTransform or an ObjectTransform as its second parameter. <computeroutput>when<></computeroutput> uses <computeroutput>is_callable<R>::value</computeroutput> to distinguish between the two, and uses <computeroutput>call<></computeroutput> to evaluate CallableTransforms and <computeroutput>make<></computeroutput> to evaluate ObjectTransforms. </para></description><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Data"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Data)</template-arg></specialization><typedef name="call_"><type><classname>call</classname>< R()></type></typedef><typedef name="make_"><type><classname>make</classname>< R()></type></typedef><typedef name="impl"><type>mpl::if_c< <classname>is_callable</classname>< R >::value, <classname>call_</classname>, <classname>make_</classname> >::type</type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Data)>::type</type></typedef></struct-specialization><typedef name="proto_base_expr"><type>Grammar::proto_base_expr</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>Evaluate <computeroutput>R(A0,A1,...)</computeroutput> as a transform either with <computeroutput>call<></computeroutput> or with <computeroutput>make<></computeroutput> depending on whether <computeroutput>is_callable<R>::value</computeroutput> is <computeroutput>true</computeroutput> or <computeroutput>false</computeroutput>.</para><para>
+ </template><typedef name="call_"><type><classname>call</classname>< R()></type></typedef><typedef name="make_"><type><classname>make</classname>< R()></type></typedef><typedef name="which"><type>mpl::if_c< <classname>is_callable</classname>< R >::value, <classname>call_</classname>, <classname>make_</classname> >::type</type></typedef><typedef name="result_type"><type>which::template impl< Expr, State, Data >::result_type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl::expr_param</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>typename impl::state_param</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>typename impl::data_param</paramtype><description><para>An arbitrary data </para></description></parameter><descripti
on><para>Evaluate <computeroutput>R(A0,A1,...)</computeroutput> as a transform either with <computeroutput>call<></computeroutput> or with <computeroutput>make<></computeroutput> depending on whether <computeroutput>is_callable<R>::value</computeroutput> is <computeroutput>true</computeroutput> or <computeroutput>false</computeroutput>.</para><para>

-</para></description><requires><para><computeroutput>matches<Expr, Grammar>::value</computeroutput> is <computeroutput>true</computeroutput> </para></requires><returns><para><computeroutput>result<void(Expr, State, Data)>::impl()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct-specialization><struct-specialization name="when"><template>
+</para></description><requires><para><computeroutput>matches<Expr, Grammar>::value</computeroutput> is <computeroutput>true</computeroutput> </para></requires><returns><para><computeroutput>result<void(Expr, State, Data)>::impl()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><typedef name="proto_base_expr"><type>Grammar::proto_base_expr</type></typedef></struct-specialization><struct-specialization name="when"><template>
       <template-type-parameter name="Grammar"/>
       <template-type-parameter name="R"/>
       <template-type-parameter name="A0"/>
- </template><specialization><template-arg>Grammar</template-arg><template-arg>R(A0)</template-arg></specialization><inherit access="public">boost::proto::callable</inherit><purpose>A grammar element and a PrimitiveTransform that associates a transform with the grammar. </purpose><description><para>Use <computeroutput>when<></computeroutput> to override a grammar's default transform with a custom transform. It is for used when composing larger transforms by associating smaller transforms with individual rules in your grammar, as in the following transform which counts the number of terminals in an expression.</para><para><programlisting> // Count the terminals in an expression tree.
+ </template><specialization><template-arg>Grammar</template-arg><template-arg>R(A0)</template-arg></specialization><inherit access="public">transform< boost::proto::when< Grammar, R(A0)> ></inherit><purpose>A grammar element and a PrimitiveTransform that associates a transform with the grammar. </purpose><description><para>Use <computeroutput>when<></computeroutput> to override a grammar's default transform with a custom transform. It is for used when composing larger transforms by associating smaller transforms with individual rules in your grammar, as in the following transform which counts the number of terminals in an expression.</para><para><programlisting> // Count the terminals in an expression tree.
  // Must be invoked with initial state == mpl::int_<0>().
  struct CountLeaves
    : or_<
@@ -3206,24 +3182,19 @@
        , otherwise<fold<_, _state, CountLeaves> >
      >
  {};
-</programlisting></para><para>The <computeroutput>when<G, R(A0,A1,...)></computeroutput> form accepts either a CallableTransform or an ObjectTransform as its second parameter. <computeroutput>when<></computeroutput> uses <computeroutput>is_callable<R>::value</computeroutput> to distinguish between the two, and uses <computeroutput>call<></computeroutput> to evaluate CallableTransforms and <computeroutput>make<></computeroutput> to evaluate ObjectTransforms. </para></description><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+</programlisting></para><para>The <computeroutput>when<G, R(A0,A1,...)></computeroutput> form accepts either a CallableTransform or an ObjectTransform as its second parameter. <computeroutput>when<></computeroutput> uses <computeroutput>is_callable<R>::value</computeroutput> to distinguish between the two, and uses <computeroutput>call<></computeroutput> to evaluate CallableTransforms and <computeroutput>make<></computeroutput> to evaluate ObjectTransforms. </para></description><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Data"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Data)</template-arg></specialization><typedef name="call_"><type><classname>call</classname>< R(A0)></type></typedef><typedef name="make_"><type><classname>make</classname>< R(A0)></type></typedef><typedef name="impl"><type>mpl::if_c< <classname>is_callable</classname>< R >::value, <classname>call_</classname>, <classname>make_</classname> >::type</type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Data)>::type</type></typedef></struct-specialization><typedef name="proto_base_expr"><type>Grammar::proto_base_expr</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>Evaluate <computeroutput>R(A0,A1,...)</computeroutput> as a transform either with <computeroutput>call<></computeroutput> or with <computeroutput>make<></computeroutput> depending on whether <computeroutput>is_callable<R>::value</computeroutput> is <computeroutput>true</computeroutput> or <computeroutput>false</computeroutput>.</para><para>
+ </template><typedef name="call_"><type><classname>call</classname>< R(A0)></type></typedef><typedef name="make_"><type><classname>make</classname>< R(A0)></type></typedef><typedef name="which"><type>mpl::if_c< <classname>is_callable</classname>< R >::value, <classname>call_</classname>, <classname>make_</classname> >::type</type></typedef><typedef name="result_type"><type>which::template impl< Expr, State, Data >::result_type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl::expr_param</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>typename impl::state_param</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>typename impl::data_param</paramtype><description><para>An arbitrary data </para></description></parameter><descr
iption><para>Evaluate <computeroutput>R(A0,A1,...)</computeroutput> as a transform either with <computeroutput>call<></computeroutput> or with <computeroutput>make<></computeroutput> depending on whether <computeroutput>is_callable<R>::value</computeroutput> is <computeroutput>true</computeroutput> or <computeroutput>false</computeroutput>.</para><para>

-</para></description><requires><para><computeroutput>matches<Expr, Grammar>::value</computeroutput> is <computeroutput>true</computeroutput> </para></requires><returns><para><computeroutput>result<void(Expr, State, Data)>::impl()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct-specialization><struct-specialization name="when"><template>
+</para></description><requires><para><computeroutput>matches<Expr, Grammar>::value</computeroutput> is <computeroutput>true</computeroutput> </para></requires><returns><para><computeroutput>result<void(Expr, State, Data)>::impl()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><typedef name="proto_base_expr"><type>Grammar::proto_base_expr</type></typedef></struct-specialization><struct-specialization name="when"><template>
       <template-type-parameter name="Grammar"/>
       <template-type-parameter name="R"/>
       <template-type-parameter name="A0"/>
       <template-type-parameter name="A1"/>
- </template><specialization><template-arg>Grammar</template-arg><template-arg>R(A0</template-arg><template-arg>A1)</template-arg></specialization><inherit access="public">boost::proto::callable</inherit><purpose>A grammar element and a PrimitiveTransform that associates a transform with the grammar. </purpose><description><para>Use <computeroutput>when<></computeroutput> to override a grammar's default transform with a custom transform. It is for used when composing larger transforms by associating smaller transforms with individual rules in your grammar, as in the following transform which counts the number of terminals in an expression.</para><para><programlisting> // Count the terminals in an expression tree.
+ </template><specialization><template-arg>Grammar</template-arg><template-arg>R(A0</template-arg><template-arg>A1)</template-arg></specialization><inherit access="public">transform< boost::proto::when< Grammar, R(A0, A1)> ></inherit><purpose>A grammar element and a PrimitiveTransform that associates a transform with the grammar. </purpose><description><para>Use <computeroutput>when<></computeroutput> to override a grammar's default transform with a custom transform. It is for used when composing larger transforms by associating smaller transforms with individual rules in your grammar, as in the following transform which counts the number of terminals in an expression.</para><para><programlisting> // Count the terminals in an expression tree.
  // Must be invoked with initial state == mpl::int_<0>().
  struct CountLeaves
    : or_<
@@ -3231,25 +3202,20 @@
        , otherwise<fold<_, _state, CountLeaves> >
      >
  {};
-</programlisting></para><para>The <computeroutput>when<G, R(A0,A1,...)></computeroutput> form accepts either a CallableTransform or an ObjectTransform as its second parameter. <computeroutput>when<></computeroutput> uses <computeroutput>is_callable<R>::value</computeroutput> to distinguish between the two, and uses <computeroutput>call<></computeroutput> to evaluate CallableTransforms and <computeroutput>make<></computeroutput> to evaluate ObjectTransforms. </para></description><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+</programlisting></para><para>The <computeroutput>when<G, R(A0,A1,...)></computeroutput> form accepts either a CallableTransform or an ObjectTransform as its second parameter. <computeroutput>when<></computeroutput> uses <computeroutput>is_callable<R>::value</computeroutput> to distinguish between the two, and uses <computeroutput>call<></computeroutput> to evaluate CallableTransforms and <computeroutput>make<></computeroutput> to evaluate ObjectTransforms. </para></description><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Data"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Data)</template-arg></specialization><typedef name="call_"><type><classname>call</classname>< R(A0, A1)></type></typedef><typedef name="make_"><type><classname>make</classname>< R(A0, A1)></type></typedef><typedef name="impl"><type>mpl::if_c< <classname>is_callable</classname>< R >::value, <classname>call_</classname>, <classname>make_</classname> >::type</type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Data)>::type</type></typedef></struct-specialization><typedef name="proto_base_expr"><type>Grammar::proto_base_expr</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>Evaluate <computeroutput>R(A0,A1,...)</computeroutput> as a transform either with <computeroutput>call<></computeroutput> or with <computeroutput>make<></computeroutput> depending on whether <computeroutput>is_callable<R>::value</computeroutput> is <computeroutput>true</computeroutput> or <computeroutput>false</computeroutput>.</para><para>
+ </template><typedef name="call_"><type><classname>call</classname>< R(A0, A1)></type></typedef><typedef name="make_"><type><classname>make</classname>< R(A0, A1)></type></typedef><typedef name="which"><type>mpl::if_c< <classname>is_callable</classname>< R >::value, <classname>call_</classname>, <classname>make_</classname> >::type</type></typedef><typedef name="result_type"><type>which::template impl< Expr, State, Data >::result_type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl::expr_param</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>typename impl::state_param</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>typename impl::data_param</paramtype><description><para>An arbitrary data </para></description></paramete
r><description><para>Evaluate <computeroutput>R(A0,A1,...)</computeroutput> as a transform either with <computeroutput>call<></computeroutput> or with <computeroutput>make<></computeroutput> depending on whether <computeroutput>is_callable<R>::value</computeroutput> is <computeroutput>true</computeroutput> or <computeroutput>false</computeroutput>.</para><para>

-</para></description><requires><para><computeroutput>matches<Expr, Grammar>::value</computeroutput> is <computeroutput>true</computeroutput> </para></requires><returns><para><computeroutput>result<void(Expr, State, Data)>::impl()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct-specialization><struct-specialization name="when"><template>
+</para></description><requires><para><computeroutput>matches<Expr, Grammar>::value</computeroutput> is <computeroutput>true</computeroutput> </para></requires><returns><para><computeroutput>result<void(Expr, State, Data)>::impl()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><typedef name="proto_base_expr"><type>Grammar::proto_base_expr</type></typedef></struct-specialization><struct-specialization name="when"><template>
       <template-type-parameter name="Grammar"/>
       <template-type-parameter name="R"/>
       <template-type-parameter name="A0"/>
       <template-type-parameter name="A1"/>
       <template-type-parameter name="A2"/>
- </template><specialization><template-arg>Grammar</template-arg><template-arg>R(A0</template-arg><template-arg>A1</template-arg><template-arg>A2)</template-arg></specialization><inherit access="public">boost::proto::callable</inherit><purpose>A grammar element and a PrimitiveTransform that associates a transform with the grammar. </purpose><description><para>Use <computeroutput>when<></computeroutput> to override a grammar's default transform with a custom transform. It is for used when composing larger transforms by associating smaller transforms with individual rules in your grammar, as in the following transform which counts the number of terminals in an expression.</para><para><programlisting> // Count the terminals in an expression tree.
+ </template><specialization><template-arg>Grammar</template-arg><template-arg>R(A0</template-arg><template-arg>A1</template-arg><template-arg>A2)</template-arg></specialization><inherit access="public">transform< boost::proto::when< Grammar, R(A0, A1, A2)> ></inherit><purpose>A grammar element and a PrimitiveTransform that associates a transform with the grammar. </purpose><description><para>Use <computeroutput>when<></computeroutput> to override a grammar's default transform with a custom transform. It is for used when composing larger transforms by associating smaller transforms with individual rules in your grammar, as in the following transform which counts the number of terminals in an expression.</para><para><programlisting> // Count the terminals in an expression tree.
  // Must be invoked with initial state == mpl::int_<0>().
  struct CountLeaves
    : or_<
@@ -3257,26 +3223,21 @@
        , otherwise<fold<_, _state, CountLeaves> >
      >
  {};
-</programlisting></para><para>The <computeroutput>when<G, R(A0,A1,...)></computeroutput> form accepts either a CallableTransform or an ObjectTransform as its second parameter. <computeroutput>when<></computeroutput> uses <computeroutput>is_callable<R>::value</computeroutput> to distinguish between the two, and uses <computeroutput>call<></computeroutput> to evaluate CallableTransforms and <computeroutput>make<></computeroutput> to evaluate ObjectTransforms. </para></description><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+</programlisting></para><para>The <computeroutput>when<G, R(A0,A1,...)></computeroutput> form accepts either a CallableTransform or an ObjectTransform as its second parameter. <computeroutput>when<></computeroutput> uses <computeroutput>is_callable<R>::value</computeroutput> to distinguish between the two, and uses <computeroutput>call<></computeroutput> to evaluate CallableTransforms and <computeroutput>make<></computeroutput> to evaluate ObjectTransforms. </para></description><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Data"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Data)</template-arg></specialization><typedef name="call_"><type><classname>call</classname>< R(A0, A1, A2)></type></typedef><typedef name="make_"><type><classname>make</classname>< R(A0, A1, A2)></type></typedef><typedef name="impl"><type>mpl::if_c< <classname>is_callable</classname>< R >::value, <classname>call_</classname>, <classname>make_</classname> >::type</type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Data)>::type</type></typedef></struct-specialization><typedef name="proto_base_expr"><type>Grammar::proto_base_expr</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>Evaluate <computeroutput>R(A0,A1,...)</computeroutput> as a transform either with <computeroutput>call<></computeroutput> or with <computeroutput>make<></computeroutput> depending on whether <computeroutput>is_callable<R>::value</computeroutput> is <computeroutput>true</computeroutput> or <computeroutput>false</computeroutput>.</para><para>
+ </template><typedef name="call_"><type><classname>call</classname>< R(A0, A1, A2)></type></typedef><typedef name="make_"><type><classname>make</classname>< R(A0, A1, A2)></type></typedef><typedef name="which"><type>mpl::if_c< <classname>is_callable</classname>< R >::value, <classname>call_</classname>, <classname>make_</classname> >::type</type></typedef><typedef name="result_type"><type>which::template impl< Expr, State, Data >::result_type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl::expr_param</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>typename impl::state_param</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>typename impl::data_param</paramtype><description><para>An arbitrary data </para></description></
parameter><description><para>Evaluate <computeroutput>R(A0,A1,...)</computeroutput> as a transform either with <computeroutput>call<></computeroutput> or with <computeroutput>make<></computeroutput> depending on whether <computeroutput>is_callable<R>::value</computeroutput> is <computeroutput>true</computeroutput> or <computeroutput>false</computeroutput>.</para><para>

-</para></description><requires><para><computeroutput>matches<Expr, Grammar>::value</computeroutput> is <computeroutput>true</computeroutput> </para></requires><returns><para><computeroutput>result<void(Expr, State, Data)>::impl()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct-specialization><struct-specialization name="when"><template>
+</para></description><requires><para><computeroutput>matches<Expr, Grammar>::value</computeroutput> is <computeroutput>true</computeroutput> </para></requires><returns><para><computeroutput>result<void(Expr, State, Data)>::impl()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><typedef name="proto_base_expr"><type>Grammar::proto_base_expr</type></typedef></struct-specialization><struct-specialization name="when"><template>
       <template-type-parameter name="Grammar"/>
       <template-type-parameter name="R"/>
       <template-type-parameter name="A0"/>
       <template-type-parameter name="A1"/>
       <template-type-parameter name="A2"/>
       <template-type-parameter name="A3"/>
- </template><specialization><template-arg>Grammar</template-arg><template-arg>R(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3)</template-arg></specialization><inherit access="public">boost::proto::callable</inherit><purpose>A grammar element and a PrimitiveTransform that associates a transform with the grammar. </purpose><description><para>Use <computeroutput>when<></computeroutput> to override a grammar's default transform with a custom transform. It is for used when composing larger transforms by associating smaller transforms with individual rules in your grammar, as in the following transform which counts the number of terminals in an expression.</para><para><programlisting> // Count the terminals in an expression tree.
+ </template><specialization><template-arg>Grammar</template-arg><template-arg>R(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3)</template-arg></specialization><inherit access="public">transform< boost::proto::when< Grammar, R(A0, A1, A2, A3)> ></inherit><purpose>A grammar element and a PrimitiveTransform that associates a transform with the grammar. </purpose><description><para>Use <computeroutput>when<></computeroutput> to override a grammar's default transform with a custom transform. It is for used when composing larger transforms by associating smaller transforms with individual rules in your grammar, as in the following transform which counts the number of terminals in an expression.</para><para><programlisting> // Count the terminals in an expression tree.
  // Must be invoked with initial state == mpl::int_<0>().
  struct CountLeaves
    : or_<
@@ -3284,19 +3245,14 @@
        , otherwise<fold<_, _state, CountLeaves> >
      >
  {};
-</programlisting></para><para>The <computeroutput>when<G, R(A0,A1,...)></computeroutput> form accepts either a CallableTransform or an ObjectTransform as its second parameter. <computeroutput>when<></computeroutput> uses <computeroutput>is_callable<R>::value</computeroutput> to distinguish between the two, and uses <computeroutput>call<></computeroutput> to evaluate CallableTransforms and <computeroutput>make<></computeroutput> to evaluate ObjectTransforms. </para></description><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+</programlisting></para><para>The <computeroutput>when<G, R(A0,A1,...)></computeroutput> form accepts either a CallableTransform or an ObjectTransform as its second parameter. <computeroutput>when<></computeroutput> uses <computeroutput>is_callable<R>::value</computeroutput> to distinguish between the two, and uses <computeroutput>call<></computeroutput> to evaluate CallableTransforms and <computeroutput>make<></computeroutput> to evaluate ObjectTransforms. </para></description><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Data"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Data)</template-arg></specialization><typedef name="call_"><type><classname>call</classname>< R(A0, A1, A2, A3)></type></typedef><typedef name="make_"><type><classname>make</classname>< R(A0, A1, A2, A3)></type></typedef><typedef name="impl"><type>mpl::if_c< <classname>is_callable</classname>< R >::value, <classname>call_</classname>, <classname>make_</classname> >::type</type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Data)>::type</type></typedef></struct-specialization><typedef name="proto_base_expr"><type>Grammar::proto_base_expr</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>Evaluate <computeroutput>R(A0,A1,...)</computeroutput> as a transform either with <computeroutput>call<></computeroutput> or with <computeroutput>make<></computeroutput> depending on whether <computeroutput>is_callable<R>::value</computeroutput> is <computeroutput>true</computeroutput> or <computeroutput>false</computeroutput>.</para><para>
+ </template><typedef name="call_"><type><classname>call</classname>< R(A0, A1, A2, A3)></type></typedef><typedef name="make_"><type><classname>make</classname>< R(A0, A1, A2, A3)></type></typedef><typedef name="which"><type>mpl::if_c< <classname>is_callable</classname>< R >::value, <classname>call_</classname>, <classname>make_</classname> >::type</type></typedef><typedef name="result_type"><type>which::template impl< Expr, State, Data >::result_type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl::expr_param</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>typename impl::state_param</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>typename impl::data_param</paramtype><description><para>An arbitrary data </para></descri
ption></parameter><description><para>Evaluate <computeroutput>R(A0,A1,...)</computeroutput> as a transform either with <computeroutput>call<></computeroutput> or with <computeroutput>make<></computeroutput> depending on whether <computeroutput>is_callable<R>::value</computeroutput> is <computeroutput>true</computeroutput> or <computeroutput>false</computeroutput>.</para><para>

-</para></description><requires><para><computeroutput>matches<Expr, Grammar>::value</computeroutput> is <computeroutput>true</computeroutput> </para></requires><returns><para><computeroutput>result<void(Expr, State, Data)>::impl()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct-specialization><struct-specialization name="when"><template>
+</para></description><requires><para><computeroutput>matches<Expr, Grammar>::value</computeroutput> is <computeroutput>true</computeroutput> </para></requires><returns><para><computeroutput>result<void(Expr, State, Data)>::impl()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><typedef name="proto_base_expr"><type>Grammar::proto_base_expr</type></typedef></struct-specialization><struct-specialization name="when"><template>
       <template-type-parameter name="Grammar"/>
       <template-type-parameter name="R"/>
       <template-type-parameter name="A0"/>
@@ -3304,7 +3260,7 @@
       <template-type-parameter name="A2"/>
       <template-type-parameter name="A3"/>
       <template-type-parameter name="A4"/>
- </template><specialization><template-arg>Grammar</template-arg><template-arg>R(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3</template-arg><template-arg>A4)</template-arg></specialization><inherit access="public">boost::proto::callable</inherit><purpose>A grammar element and a PrimitiveTransform that associates a transform with the grammar. </purpose><description><para>Use <computeroutput>when<></computeroutput> to override a grammar's default transform with a custom transform. It is for used when composing larger transforms by associating smaller transforms with individual rules in your grammar, as in the following transform which counts the number of terminals in an expression.</para><para><programlisting> // Count the terminals in an expression tree.
+ </template><specialization><template-arg>Grammar</template-arg><template-arg>R(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3</template-arg><template-arg>A4)</template-arg></specialization><inherit access="public">transform< boost::proto::when< Grammar, R(A0, A1, A2, A3, A4)> ></inherit><purpose>A grammar element and a PrimitiveTransform that associates a transform with the grammar. </purpose><description><para>Use <computeroutput>when<></computeroutput> to override a grammar's default transform with a custom transform. It is for used when composing larger transforms by associating smaller transforms with individual rules in your grammar, as in the following transform which counts the number of terminals in an expression.</para><para><programlisting> // Count the terminals in an expression tree.
  // Must be invoked with initial state == mpl::int_<0>().
  struct CountLeaves
    : or_<
@@ -3312,16 +3268,11 @@
        , otherwise<fold<_, _state, CountLeaves> >
      >
  {};
-</programlisting></para><para>The <computeroutput>when<G, R(A0,A1,...)></computeroutput> form accepts either a CallableTransform or an ObjectTransform as its second parameter. <computeroutput>when<></computeroutput> uses <computeroutput>is_callable<R>::value</computeroutput> to distinguish between the two, and uses <computeroutput>call<></computeroutput> to evaluate CallableTransforms and <computeroutput>make<></computeroutput> to evaluate ObjectTransforms. </para></description><struct-specialization name="result"><template>
- <template-type-parameter name="This"/>
+</programlisting></para><para>The <computeroutput>when<G, R(A0,A1,...)></computeroutput> form accepts either a CallableTransform or an ObjectTransform as its second parameter. <computeroutput>when<></computeroutput> uses <computeroutput>is_callable<R>::value</computeroutput> to distinguish between the two, and uses <computeroutput>call<></computeroutput> to evaluate CallableTransforms and <computeroutput>make<></computeroutput> to evaluate ObjectTransforms. </para></description><struct name="impl"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Data"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Data)</template-arg></specialization><typedef name="call_"><type><classname>call</classname>< R(A0, A1, A2, A3, A4)></type></typedef><typedef name="make_"><type><classname>make</classname>< R(A0, A1, A2, A3, A4)></type></typedef><typedef name="impl"><type>mpl::if_c< <classname>is_callable</classname>< R >::value, <classname>call_</classname>, <classname>make_</classname> >::type</type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Data)>::type</type></typedef></struct-specialization><typedef name="proto_base_expr"><type>Grammar::proto_base_expr</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Data)>::type</type><template>
- <template-type-parameter name="Expr"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Data"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>State const &</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>Data &</paramtype><description><para>An arbitrary data </para></description></parameter><description><para>Evaluate <computeroutput>R(A0,A1,...)</computeroutput> as a transform either with <computeroutput>call<></computeroutput> or with <computeroutput>make<></computeroutput> depending on whether <computeroutput>is_callable<R>::value</computeroutput> is <computeroutput>true</computeroutput> or <computeroutput>false</computeroutput>.</para><para>
+ </template><typedef name="call_"><type><classname>call</classname>< R(A0, A1, A2, A3, A4)></type></typedef><typedef name="make_"><type><classname>make</classname>< R(A0, A1, A2, A3, A4)></type></typedef><typedef name="which"><type>mpl::if_c< <classname>is_callable</classname>< R >::value, <classname>call_</classname>, <classname>make_</classname> >::type</type></typedef><typedef name="result_type"><type>which::template impl< Expr, State, Data >::result_type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><parameter name="expr"><paramtype>typename impl::expr_param</paramtype><description><para>The current expression </para></description></parameter><parameter name="state"><paramtype>typename impl::state_param</paramtype><description><para>The current state </para></description></parameter><parameter name="data"><paramtype>typename impl::data_param</paramtype><description><para>An arbitrary data </para>
</description></parameter><description><para>Evaluate <computeroutput>R(A0,A1,...)</computeroutput> as a transform either with <computeroutput>call<></computeroutput> or with <computeroutput>make<></computeroutput> depending on whether <computeroutput>is_callable<R>::value</computeroutput> is <computeroutput>true</computeroutput> or <computeroutput>false</computeroutput>.</para><para>

-</para></description><requires><para><computeroutput>matches<Expr, Grammar>::value</computeroutput> is <computeroutput>true</computeroutput> </para></requires><returns><para><computeroutput>result<void(Expr, State, Data)>::impl()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct-specialization></namespace></namespace></header></library-reference>
+</para></description><requires><para><computeroutput>matches<Expr, Grammar>::value</computeroutput> is <computeroutput>true</computeroutput> </para></requires><returns><para><computeroutput>result<void(Expr, State, Data)>::impl()(expr, state, data)</computeroutput> </para></returns></method></method-group></struct><typedef name="proto_base_expr"><type>Grammar::proto_base_expr</type></typedef></struct-specialization></namespace></namespace></header></library-reference>

Next message: grafikrobot_at_[hidden]: "[Boost-commit] svn:boost r44379 - trunk/libs/crc/test"
Previous message: grafikrobot_at_[hidden]: "[Boost-commit] svn:boost r44377 - in trunk: libs/crc libs/crc/test status"

Date view	Thread view	Subject view	Author view

Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk