Boost-Commit :

Date view	Thread view	Subject view	Author view

From: eric_at_[hidden]
Date: 2008-02-07 03:06:32

Next message: nesotto_at_[hidden]: "[Boost-commit] svn:boost r43139 - in branches/release/libs/range: doc test"
Previous message: JakeVoytko_at_[hidden]: "[Boost-commit] svn:boost r43137 - sandbox/SOC/2007/visualization/boost/svg_plot/detail"

Author: eric_niebler
Date: 2008-02-07 03:06:29 EST (Thu, 07 Feb 2008)
New Revision: 43138
URL: http://svn.boost.org/trac/boost/changeset/43138

Log:
tweaks for doxygen 1.5.4, document matches<>
Text files modified:
   trunk/boost/xpressive/proto/deep_copy.hpp | 2
   trunk/boost/xpressive/proto/eval.hpp | 2
   trunk/boost/xpressive/proto/fusion.hpp | 16
   trunk/boost/xpressive/proto/make_expr.hpp | 8
   trunk/boost/xpressive/proto/matches.hpp | 145 ++++++-
   trunk/boost/xpressive/proto/ref.hpp | 2
   trunk/boost/xpressive/proto/traits.hpp | 19
   trunk/boost/xpressive/proto/transform/arg.hpp | 27 +
   trunk/boost/xpressive/proto/transform/bind.hpp | 8
   trunk/boost/xpressive/proto/transform/call.hpp | 17
   trunk/boost/xpressive/proto/transform/fold.hpp | 16
   trunk/boost/xpressive/proto/transform/fold_tree.hpp | 13
   trunk/boost/xpressive/proto/transform/make.hpp | 11
   trunk/boost/xpressive/proto/transform/pass_through.hpp | 5
   trunk/boost/xpressive/proto/transform/when.hpp | 3
   trunk/libs/xpressive/proto/doc/Jamfile.v2 | 22
   trunk/libs/xpressive/proto/doc/protodoc.xml | 753 ++++++++++++++++++++-------------------
   17 files changed, 620 insertions(+), 449 deletions(-)

Modified: trunk/boost/xpressive/proto/deep_copy.hpp
==============================================================================
--- trunk/boost/xpressive/proto/deep_copy.hpp (original)
+++ trunk/boost/xpressive/proto/deep_copy.hpp 2008-02-07 03:06:29 EST (Thu, 07 Feb 2008)
@@ -86,7 +86,7 @@
                 BOOST_PROTO_CALLABLE()

                 template<typename Sig>
- struct result {};
+ struct result;

                 template<typename This, typename Expr>
                 struct result<This(Expr)>

Modified: trunk/boost/xpressive/proto/eval.hpp
==============================================================================
--- trunk/boost/xpressive/proto/eval.hpp (original)
+++ trunk/boost/xpressive/proto/eval.hpp 2008-02-07 03:06:29 EST (Thu, 07 Feb 2008)
@@ -43,7 +43,7 @@
             BOOST_PROTO_CALLABLE()

             template<typename Sig>
- struct result {};
+ struct result;

             template<typename This, typename Expr, typename Context>
             struct result<This(Expr, Context)>

Modified: trunk/boost/xpressive/proto/fusion.hpp
==============================================================================
--- trunk/boost/xpressive/proto/fusion.hpp (original)
+++ trunk/boost/xpressive/proto/fusion.hpp 2008-02-07 03:06:29 EST (Thu, 07 Feb 2008)
@@ -96,7 +96,7 @@
         struct as_element
         {
             template<typename Sig>
- struct result {};
+ struct result;

             template<typename This, typename Expr>
             struct result<This(Expr)>
@@ -136,7 +136,7 @@
             BOOST_PROTO_CALLABLE()

             template<typename Sig>
- struct result {};
+ struct result;

             template<typename This, typename Expr>
             struct result<This(Expr)>
@@ -166,7 +166,7 @@
             BOOST_PROTO_CALLABLE()

             template<typename Sig>
- struct result {};
+ struct result;

             template<typename This, typename Expr>
             struct result<This(Expr)>
@@ -197,7 +197,7 @@
             BOOST_PROTO_CALLABLE()

             template<typename Sig>
- struct result {};
+ struct result;

             template<typename This, typename Expr>
             struct result<This(Expr)>
@@ -222,16 +222,22 @@
     /// \sa boost::proto::functional::flatten
     functional::flatten const flatten = {};

+ /// INTERNAL ONLY
+ ///
     template<>
     struct is_callable<functional::flatten>
       : mpl::true_
     {};

+ /// INTERNAL ONLY
+ ///
     template<>
     struct is_callable<functional::pop_front>
       : mpl::true_
     {};

+ /// INTERNAL ONLY
+ ///
     template<>
     struct is_callable<functional::reverse>
       : mpl::true_
@@ -247,7 +253,7 @@
         {}

         template<typename Sig>
- struct result {};
+ struct result;

         template<typename This, typename Expr>
         struct result<This(Expr)>

Modified: trunk/boost/xpressive/proto/make_expr.hpp
==============================================================================
--- trunk/boost/xpressive/proto/make_expr.hpp (original)
+++ trunk/boost/xpressive/proto/make_expr.hpp 2008-02-07 03:06:29 EST (Thu, 07 Feb 2008)
@@ -566,7 +566,7 @@
                 BOOST_PROTO_CALLABLE()

                 template<typename Sig>
- struct result {};
+ struct result;

                 template<typename This, typename A0>
                 struct result<This(A0)>
@@ -648,7 +648,7 @@
                 BOOST_PROTO_CALLABLE()

                 template<typename Sig>
- struct result {};
+ struct result;

                 template<typename This, typename Sequence>
                 struct result<This(Sequence)>
@@ -760,11 +760,15 @@

     #include BOOST_PP_ITERATE()

+ /// INTERNAL ONLY
+ ///
         template<typename Tag, typename Domain>
         struct is_callable<functional::make_expr<Tag, Domain> >
           : mpl::true_
         {};

+ /// INTERNAL ONLY
+ ///
         template<typename Tag, typename Domain>
         struct is_callable<functional::unpack_expr<Tag, Domain> >
           : mpl::true_

Modified: trunk/boost/xpressive/proto/matches.hpp
==============================================================================
--- trunk/boost/xpressive/proto/matches.hpp (original)
+++ trunk/boost/xpressive/proto/matches.hpp 2008-02-07 03:06:29 EST (Thu, 07 Feb 2008)
@@ -392,9 +392,76 @@

         namespace result_of
         {
+ /// \brief A Boolean metafunction that evaluates whether a given
+ /// expression type matches a grammar.
+ ///
+ /// <tt>matches\<Expr,Grammar\></tt> inherits (indirectly) from
+ /// \c mpl::true_ if <tt>Expr::proto_base_expr</tt> matches
+ /// <tt>Grammar::proto_base_expr</tt>, and from \c mpl::false_
+ /// otherwise.
+ ///
+ /// Non-terminal expressions are matched against a grammar
+ /// according to the following rules:
+ ///
+ /// \li The wildcard pattern, \c _, matches any expression.
+ /// \li An expression <tt>expr\<AT, argsN\<A0,A1,...An\> \></tt>
+ /// matches a grammar <tt>expr\<BT, argsN\<B0,B1,...Bn\> \></tt>
+ /// if \c BT is \c _ or \c AT, and if \c Ax matches \c Bx for
+ /// each \c x in <tt>[0,n)</tt>.
+ /// \li An expression <tt>expr\<AT, argsN\<A0,...An,U0,...Um\> \></tt>
+ /// matches a grammar <tt>expr\<BT, argsM\<B0,...Bn,vararg\<V\> \> \></tt>
+ /// if \c BT is \c _ or \c AT, and if \c Ax matches \c Bx
+ /// for each \c x in <tt>[0,n)</tt> and if \c Ux matches \c V
+ /// for each \c x in <tt>[0,m)</tt>.
+ /// \li An expression \c E matches <tt>or_\<B0,B1,...Bn\></tt> if \c E
+ /// matches some \c Bx for \c x in <tt>[0,n)</tt>.
+ /// \li An expression \c E matches <tt>and_\<B0,B1,...Bn\></tt> if \c E
+ /// matches all \c Bx for \c x in <tt>[0,n)</tt>.
+ /// \li An expression \c E matches <tt>if_\<T\></tt> if
+ /// <tt>when\<_,T\>::result\<void(E,int,int)\>::type::value</tt>
+ /// is \c true.
+ /// \li An expression \c E matches <tt>if_\<T,U,V\></tt> if
+ /// <tt>when\<_,T\>::result\<void(E,int,int)\>::type::value</tt>
+ /// is \c true and \E matches \c U; or, if
+ /// <tt>when\<_,T\>::result\<void(E,int,int)\>::type::value</tt>
+ /// is \c false and \E matches \c V.
+ /// \li An expression \c E matches <tt>not_\<T\></tt> if \c E does
+ /// not match \c T.
+ /// \li An expression \c E matches <tt>switch_\<C\></tt> if
+ /// \c E matches <tt>C::case_\<E::proto_tag\></tt>.
+ ///
+ /// A terminal expression <tt>expr\<tag::terminal,args0\<A\> \></tt> matches
+ /// a grammar <tt>expr\<BT,args0\<B\> \></tt> if \c BT is \c _ or
+ /// \c tag::terminal and one of the following is true:
+ ///
+ /// \li \c B is the wildcard pattern, \c _
+ /// \li \c A is \c B
+ /// \li \c A is <tt>B &</tt>
+ /// \li \c A is <tt>B const &</tt>
+ /// \li \c B is <tt>exact\<A\></tt>
+ /// \li \c B is <tt>convertible_to\<X\></tt> and
+ /// <tt>is_convertible\<A,X\>::value</tt> is \c true.
+ /// \li \c A is <tt>X[M]</tt> or <tt>X(&)[M]</tt> and
+ /// \c B is <tt>X[proto::N]</tt>.
+ /// \li \c A is <tt>X(&)[M]</tt> and \c B is <tt>X(&)[proto::N]</tt>.
+ /// \li \c A is <tt>X[M]</tt> or <tt>X(&)[M]</tt> and
+ /// \c B is <tt>X*</tt>.
+ /// \li \c B lambda-matches \c A (see below).
+ ///
+ /// A type \c B lambda-matches \c A if one of the following is true:
+ ///
+ /// \li \c B is \c A
+ /// \li \c B is the wildcard pattern, \c _
+ /// \li \c B is <tt>T\<B0,B1,...Bn\></tt> and \c A is
+ /// <tt>T\<A0,A1,...An\></tt> and for each \c x in
+ /// <tt>[0,n)</tt>, \c Ax and \c Bx are types
+ /// such that \c Ax lambda-matches \c Bx
             template<typename Expr, typename Grammar>
             struct matches
- : detail::matches_<typename Expr::proto_base_expr, typename Grammar::proto_base_expr>
+ : detail::matches_<
+ typename Expr::proto_base_expr
+ , typename Grammar::proto_base_expr
+ >
             {};
         }

@@ -404,7 +471,8 @@
             {
                 typedef _ proto_base_expr;

- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;

                 template<typename This, typename Expr, typename State, typename Visitor>
                 struct result<This(Expr, State, Visitor)>
@@ -412,6 +480,8 @@
                     typedef Expr type;
                 };

+ /// \param expr An expression
+ /// \return expr
                 template<typename Expr, typename State, typename Visitor>
                 Expr const &operator ()(Expr const &expr, State const &, Visitor &) const
                 {
@@ -428,7 +498,8 @@
             {
                 typedef not_ proto_base_expr;

- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;

                 template<typename This, typename Expr, typename State, typename Visitor>
                 struct result<This(Expr, State, Visitor)>
@@ -436,6 +507,8 @@
                     typedef Expr type;
                 };

+ /// \param expr An expression
+ /// \return expr
                 template<typename Expr, typename State, typename Visitor>
                 Expr const &operator ()(Expr const &expr, State const &, Visitor &) const
                 {
@@ -449,35 +522,40 @@
             {
                 typedef if_ proto_base_expr;

- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;

                 template<typename This, typename Expr, typename State, typename Visitor>
                 struct result<This(Expr, State, Visitor)>
                 {
                     typedef
+ typename when<_, If>::template result<void(Expr, State, Visitor)>::type
+ condition;
+
+ typedef
                         typename mpl::if_<
- typename when<_, If>::template result<void(Expr, State, Visitor)>::type
+ condition
                           , when<_, Then>
                           , when<_, Else>
>::type
- branch;
+ which;

- typedef typename branch::template result<void(Expr, State, Visitor)>::type type;
+ typedef typename which::template result<void(Expr, State, Visitor)>::type type;
                 };

+ /// \param expr An expression
+ /// \param state The current state
+ /// \param visitor A visitor of arbitrary type
+ /// \return <tt>result\<void(Expr, State, Visitor)\>::which()(expr, state, visitor)</tt>
                 template<typename Expr, typename State, typename Visitor>
                 typename result<void(Expr, State, Visitor)>::type
                 operator ()(Expr const &expr, State const &state, Visitor &visitor) const
                 {
                     typedef
- typename mpl::if_<
- typename when<_, If>::template result<void(Expr, State, Visitor)>::type
- , when<_, Then>
- , when<_, Else>
- >::type
- branch;
+ typename result<void(Expr, State, Visitor)>::which
+ which;

- return branch()(expr, state, visitor);
+ return which()(expr, state, visitor);
                 }
             };

@@ -487,7 +565,8 @@
             {
                 typedef or_ proto_base_expr;

- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;

                 template<typename This, typename Expr, typename State, typename Visitor>
                 struct result<This(Expr, State, Visitor)>
@@ -496,6 +575,10 @@
                     typedef typename which::template result<void(Expr, State, Visitor)>::type type;
                 };

+ /// \param expr An expression
+ /// \param state The current state
+ /// \param visitor A visitor of arbitrary type
+ /// \return <tt>result\<void(Expr, State, Visitor)\>::which()(expr, state, visitor)</tt>
                 template<typename Expr, typename State, typename Visitor>
                 typename result<void(Expr, State, Visitor)>::type
                 operator ()(Expr const &expr, State const &state, Visitor &visitor) const
@@ -511,7 +594,8 @@
             {
                 typedef and_ proto_base_expr;

- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;

                 template<typename This, typename Expr, typename State, typename Visitor>
                 struct result<This(Expr, State, Visitor)>
@@ -520,6 +604,10 @@
                     typedef typename which::template result<void(Expr, State, Visitor)>::type type;
                 };

+ /// \param expr An expression
+ /// \param state The current state
+ /// \param visitor A visitor of arbitrary type
+ /// \return <tt>result\<void(Expr, State, Visitor)\>::which()(expr, state, visitor)</tt>
                 template<typename Expr, typename State, typename Visitor>
                 typename result<void(Expr, State, Visitor)>::type
                 operator ()(Expr const &expr, State const &state, Visitor &visitor) const
@@ -535,21 +623,26 @@
             {
                 typedef switch_ proto_base_expr;

- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;

                 template<typename This, typename Expr, typename State, typename Visitor>
                 struct result<This(Expr, State, Visitor)>
                 {
- typedef typename Cases::template case_<typename Expr::proto_tag> impl;
- typedef typename impl::template result<void(Expr, State, Visitor)>::type type;
+ typedef typename Cases::template case_<typename Expr::proto_tag> which;
+ typedef typename which::template result<void(Expr, State, Visitor)>::type type;
                 };

+ /// \param expr An expression
+ /// \param state The current state
+ /// \param visitor A visitor of arbitrary type
+ /// \return <tt>result\<void(Expr, State, Visitor)\>::which()(expr, state, visitor)</tt>
                 template<typename Expr, typename State, typename Visitor>
                 typename result<void(Expr, State, Visitor)>::type
                 operator ()(Expr const &expr, State const &state, Visitor &visitor) const
                 {
- typedef typename Cases::template case_<typename Expr::proto_tag> impl;
- return impl()(expr, state, visitor);
+ typedef typename Cases::template case_<typename Expr::proto_tag> which;
+ return which()(expr, state, visitor);
                 }
             };

@@ -569,26 +662,36 @@
             };
         }

+ /// INTERNAL ONLY
+ ///
         template<BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_LOGICAL_ARITY, typename G)>
         struct is_callable<or_<BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_LOGICAL_ARITY, G)> >
           : mpl::true_
         {};

+ /// INTERNAL ONLY
+ ///
         template<BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_LOGICAL_ARITY, typename G)>
         struct is_callable<and_<BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_LOGICAL_ARITY, G)> >
           : mpl::true_
         {};

+ /// INTERNAL ONLY
+ ///
         template<typename Grammar>
         struct is_callable<not_<Grammar> >
           : mpl::true_
         {};

+ /// INTERNAL ONLY
+ ///
         template<typename If, typename Then, typename Else>
         struct is_callable<if_<If, Then, Else> >
           : mpl::true_
         {};

+ /// INTERNAL ONLY
+ ///
         template<typename Grammar>
         struct is_callable<vararg<Grammar> >
           : mpl::true_

Modified: trunk/boost/xpressive/proto/ref.hpp
==============================================================================
--- trunk/boost/xpressive/proto/ref.hpp (original)
+++ trunk/boost/xpressive/proto/ref.hpp 2008-02-07 03:06:29 EST (Thu, 07 Feb 2008)
@@ -136,7 +136,7 @@
         struct unref
         {
             template<typename T>
- struct result {};
+ struct result;

             template<typename This, typename T>
             struct result<This(T)>

Modified: trunk/boost/xpressive/proto/traits.hpp
==============================================================================
--- trunk/boost/xpressive/proto/traits.hpp (original)
+++ trunk/boost/xpressive/proto/traits.hpp 2008-02-07 03:06:29 EST (Thu, 07 Feb 2008)
@@ -83,11 +83,15 @@
           : proto::detail::is_callable_<T>
         {};

+ /// INTERNAL ONLY
+ ///
         template<>
         struct is_callable<proto::_>
           : mpl::true_
         {};

+ /// INTERNAL ONLY
+ ///
         template<>
         struct is_callable<proto::callable>
           : mpl::false_
@@ -243,7 +247,8 @@
             template<typename T>
             struct terminal
             {
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;

                 template<typename This, typename Expr, typename State, typename Visitor>
                 struct result<This(Expr, State, Visitor)>
@@ -401,7 +406,7 @@
             struct as_expr
             {
                 template<typename Sig>
- struct result {};
+ struct result;

                 template<typename This, typename T>
                 struct result<This(T)>
@@ -443,7 +448,7 @@
             struct as_arg
             {
                 template<typename Sig>
- struct result {};
+ struct result;

                 template<typename This, typename T>
                 struct result<This(T)>
@@ -469,7 +474,7 @@
             struct arg_c
             {
                 template<typename Sig>
- struct result {};
+ struct result;

                 template<typename This, typename Expr>
                 struct result<This(Expr)>
@@ -493,7 +498,7 @@
             struct arg
             {
                 template<typename Sig>
- struct result {};
+ struct result;

                 template<typename This, typename Expr>
                 struct result<This(Expr)>
@@ -516,7 +521,7 @@
             struct left
             {
                 template<typename Sig>
- struct result {};
+ struct result;

                 template<typename This, typename Expr>
                 struct result<This(Expr)>
@@ -539,7 +544,7 @@
             struct right
             {
                 template<typename Sig>
- struct result {};
+ struct result;

                 template<typename This, typename Expr>
                 struct result<This(Expr)>

Modified: trunk/boost/xpressive/proto/transform/arg.hpp
==============================================================================
--- trunk/boost/xpressive/proto/transform/arg.hpp (original)
+++ trunk/boost/xpressive/proto/transform/arg.hpp 2008-02-07 03:06:29 EST (Thu, 07 Feb 2008)
@@ -22,7 +22,8 @@

         struct expr : proto::callable
         {
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;

             template<typename This, typename Expr, typename State, typename Visitor>
             struct result<This(Expr, State, Visitor)>
@@ -40,7 +41,8 @@

         struct state : proto::callable
         {
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;

             template<typename This, typename Expr, typename State, typename Visitor>
             struct result<This(Expr, State, Visitor)>
@@ -58,7 +60,8 @@

         struct visitor : proto::callable
         {
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;

             template<typename This, typename Expr, typename State, typename Visitor>
             struct result<This(Expr, State, Visitor)>
@@ -77,7 +80,8 @@
         template<int I>
         struct arg_c : proto::callable
         {
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;

             template<typename This, typename Expr, typename State, typename Visitor>
             struct result<This(Expr, State, Visitor)>
@@ -95,7 +99,8 @@

         struct _ref : proto::callable
         {
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;

             template<typename This, typename T>
             struct result<This(T)>
@@ -130,31 +135,43 @@
       : transform::arg_c<I>
     {};

+ /// INTERNAL ONLY
+ ///
     template<>
     struct is_callable<transform::expr>
       : mpl::true_
     {};

+ /// INTERNAL ONLY
+ ///
     template<>
     struct is_callable<transform::state>
       : mpl::true_
     {};

+ /// INTERNAL ONLY
+ ///
     template<>
     struct is_callable<transform::visitor>
       : mpl::true_
     {};

+ /// INTERNAL ONLY
+ ///
     template<int I>
     struct is_callable<transform::arg_c<I> >
       : mpl::true_
     {};

+ /// INTERNAL ONLY
+ ///
     template<int I>
     struct is_callable<_arg_c<I> >
       : mpl::true_
     {};

+ /// INTERNAL ONLY
+ ///
     template<>
     struct is_callable<transform::_ref>
       : mpl::true_

Modified: trunk/boost/xpressive/proto/transform/bind.hpp
==============================================================================
--- trunk/boost/xpressive/proto/transform/bind.hpp (original)
+++ trunk/boost/xpressive/proto/transform/bind.hpp 2008-02-07 03:06:29 EST (Thu, 07 Feb 2008)
@@ -27,7 +27,8 @@
             template<typename Fun>
             struct bind : proto::callable
             {
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;

                 template<typename This, typename Expr, typename State, typename Visitor>
                 struct result<This(Expr, State, Visitor)>
@@ -49,6 +50,8 @@

         }

+ /// INTERNAL ONLY
+ ///
         template<typename Fun>
         struct is_callable<transform::bind<Fun> >
           : mpl::true_
@@ -65,7 +68,8 @@
             template<typename Return BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
             struct bind<Return(BOOST_PP_ENUM_PARAMS(N, A))> : proto::callable
             {
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;

                 template<typename This, typename Expr, typename State, typename Visitor>
                 struct result<This(Expr, State, Visitor)>

Modified: trunk/boost/xpressive/proto/transform/call.hpp
==============================================================================
--- trunk/boost/xpressive/proto/transform/call.hpp (original)
+++ trunk/boost/xpressive/proto/transform/call.hpp 2008-02-07 03:06:29 EST (Thu, 07 Feb 2008)
@@ -186,7 +186,8 @@
             template<typename Fun>
             struct call<Fun()> : proto::callable
             {
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;

                 template<typename This, typename Expr, typename State, typename Visitor>
                 struct result<This(Expr, State, Visitor)>
@@ -221,7 +222,8 @@
             template<typename Fun, typename Arg0>
             struct call<Fun(Arg0)> : proto::callable
             {
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;

                 template<typename This, typename Expr, typename State, typename Visitor>
                 struct result<This(Expr, State, Visitor)>
@@ -260,7 +262,8 @@
             template<typename Fun, typename Arg0, typename Arg1>
             struct call<Fun(Arg0, Arg1)> : proto::callable
             {
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;

                 template<typename This, typename Expr, typename State, typename Visitor>
                 struct result<This(Expr, State, Visitor)>
@@ -299,7 +302,8 @@
             template<typename Fun, typename Arg0, typename Arg1, typename Arg2>
             struct call<Fun(Arg0, Arg1, Arg2)> : proto::callable
             {
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;

                 template<typename This, typename Expr, typename State, typename Visitor>
                 struct result<This(Expr, State, Visitor)>
@@ -334,6 +338,8 @@
             #endif
         }

+ /// INTERNAL ONLY
+ ///
         template<typename Fun>
         struct is_callable<transform::call<Fun> >
           : mpl::true_
@@ -350,7 +356,8 @@
         template<typename Fun BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
         struct call<Fun(BOOST_PP_ENUM_PARAMS(N, A))> : proto::callable
         {
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;

             template<typename This, typename Expr, typename State, typename Visitor>
             struct result<This(Expr, State, Visitor)>

Modified: trunk/boost/xpressive/proto/transform/fold.hpp
==============================================================================
--- trunk/boost/xpressive/proto/transform/fold.hpp (original)
+++ trunk/boost/xpressive/proto/transform/fold.hpp 2008-02-07 03:06:29 EST (Thu, 07 Feb 2008)
@@ -43,7 +43,8 @@
                       : v_(v)
                     {}

- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;

                     template<typename This, typename Expr, typename State>
                     struct result<This(Expr, State)>
@@ -161,7 +162,8 @@
             template<typename Sequence, typename State0, typename Fun>
             struct fold : proto::callable
             {
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;

                 template<typename This, typename Expr, typename State, typename Visitor>
                 struct result<This(Expr, State, Visitor)>
@@ -206,7 +208,8 @@
             template<typename State0, typename Fun>
             struct fold<_, State0, Fun> : proto::callable
             {
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;

                 template<typename This, typename Expr, typename State, typename Visitor>
                 struct result<This(Expr, State, Visitor)>
@@ -250,7 +253,8 @@
             template<typename State0, typename Fun>
             struct reverse_fold<_, State0, Fun> : proto::callable
             {
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;

                 template<typename This, typename Expr, typename State, typename Visitor>
                 struct result<This(Expr, State, Visitor)>
@@ -287,11 +291,15 @@
             };
         }

+ /// INTERNAL ONLY
+ ///
         template<typename Sequence, typename State, typename Fun>
         struct is_callable<transform::fold<Sequence, State, Fun> >
           : mpl::true_
         {};

+ /// INTERNAL ONLY
+ ///
         template<typename Sequence, typename State, typename Fun>
         struct is_callable<transform::reverse_fold<Sequence, State, Fun> >
           : mpl::true_

Modified: trunk/boost/xpressive/proto/transform/fold_tree.hpp
==============================================================================
--- trunk/boost/xpressive/proto/transform/fold_tree.hpp (original)
+++ trunk/boost/xpressive/proto/transform/fold_tree.hpp 2008-02-07 03:06:29 EST (Thu, 07 Feb 2008)
@@ -26,7 +26,8 @@
             template<typename Tag>
             struct is_tag : proto::callable
             {
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;

                 template<typename This, typename Expr, typename State, typename Visitor>
                 struct result<This(Expr, State, Visitor)>
@@ -49,7 +50,8 @@
         struct fold_tree
           : proto::callable
         {
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;

             template<typename This, typename Expr, typename State, typename Visitor>
             struct result<This(Expr, State, Visitor)>
@@ -81,7 +83,8 @@
         struct reverse_fold_tree
           : proto::callable
         {
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;

             template<typename This, typename Expr, typename State, typename Visitor>
             struct result<This(Expr, State, Visitor)>
@@ -110,11 +113,15 @@
         };
     }

+ /// INTERNAL ONLY
+ ///
     template<typename Sequence, typename State0, typename Fun>
     struct is_callable<transform::fold_tree<Sequence, State0, Fun> >
       : mpl::true_
     {};

+ /// INTERNAL ONLY
+ ///
     template<typename Sequence, typename State0, typename Fun>
     struct is_callable<transform::reverse_fold_tree<Sequence, State0, Fun> >
       : mpl::true_

Modified: trunk/boost/xpressive/proto/transform/make.hpp
==============================================================================
--- trunk/boost/xpressive/proto/transform/make.hpp (original)
+++ trunk/boost/xpressive/proto/transform/make.hpp 2008-02-07 03:06:29 EST (Thu, 07 Feb 2008)
@@ -168,7 +168,8 @@
             template<typename Fun>
             struct make : proto::callable
             {
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;

                 template<typename This, typename Expr, typename State, typename Visitor>
                 struct result<This(Expr, State, Visitor)>
@@ -189,6 +190,8 @@
             #include BOOST_PP_ITERATE()
         }

+ /// INTERNAL ONLY
+ ///
         template<typename Fun>
         struct is_callable<transform::make<Fun> >
           : mpl::true_
@@ -273,7 +276,8 @@
         template<typename Return BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
         struct make<Return(BOOST_PP_ENUM_PARAMS(N, A))> : proto::callable
         {
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;

             template<typename This, typename Expr, typename State, typename Visitor>
             struct result<This(Expr, State, Visitor)>
@@ -300,7 +304,8 @@
         struct make<proto::expr<Tag, Args, Arity>(BOOST_PP_ENUM_PARAMS(N, A))>
           : proto::callable
         {
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;

             template<typename This, typename Expr, typename State, typename Visitor>
             struct result<This(Expr, State, Visitor)>

Modified: trunk/boost/xpressive/proto/transform/pass_through.hpp
==============================================================================
--- trunk/boost/xpressive/proto/transform/pass_through.hpp (original)
+++ trunk/boost/xpressive/proto/transform/pass_through.hpp 2008-02-07 03:06:29 EST (Thu, 07 Feb 2008)
@@ -66,7 +66,8 @@
         template<typename Grammar>
         struct pass_through : proto::callable
         {
- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;

             template<typename This, typename Expr, typename State, typename Visitor>
             struct result<This(Expr, State, Visitor)>
@@ -102,6 +103,8 @@

     } // namespace transform

+ /// INTERNAL ONLY
+ ///
     template<typename Grammar>
     struct is_callable<transform::pass_through<Grammar> >
       : mpl::true_

Modified: trunk/boost/xpressive/proto/transform/when.hpp
==============================================================================
--- trunk/boost/xpressive/proto/transform/when.hpp (original)
+++ trunk/boost/xpressive/proto/transform/when.hpp 2008-02-07 03:06:29 EST (Thu, 07 Feb 2008)
@@ -60,7 +60,8 @@
         {
             typedef typename Grammar::proto_base_expr proto_base_expr;

- template<typename Sig> struct result {};
+ template<typename Sig>
+ struct result;

             template<typename This, typename Expr, typename State, typename Visitor>
             struct result<This(Expr, State, Visitor)>

Modified: trunk/libs/xpressive/proto/doc/Jamfile.v2
==============================================================================
--- trunk/libs/xpressive/proto/doc/Jamfile.v2 (original)
+++ trunk/libs/xpressive/proto/doc/Jamfile.v2 2008-02-07 03:06:29 EST (Thu, 07 Feb 2008)
@@ -6,7 +6,7 @@
import doxygen ;
import quickbook ;

-#wave-command = [ path.native ../../../../dist/bin/wave ] ;
+wave-command = [ path.native ../../../../dist/bin/wave ] ;

# Generate reference section using Doxygen
doxygen protodoc
@@ -47,15 +47,15 @@
         <doxygen:param>EXTRACT_ALL=YES
         <doxygen:param>HIDE_UNDOC_MEMBERS=NO
         # Use Boost.Wave to preprocess Proto's source
- <doxygen:param>INPUT_FILTER=./wave.sh
-# <doxygen:param>"INPUT_FILTER=\"$(wave-command) \\
-# -S ../../../.. \\
-# -S \\\"C:\\Program Files\\Microsoft Visual Studio .NET 2003\\vc7\\include\\\" \\
-# -D _WIN32 \\
-# -D BOOST_PROTO_DOXYGEN_INVOKED \\
-# -p 1 \""
-# # This ensures that Wave is actually built before we try to execute it
-# <dependency>../../../../tools/wave/build release
+# <doxygen:param>INPUT_FILTER=./wave.sh
+ <doxygen:param>"INPUT_FILTER=\"$(wave-command) \\
+ -S ../../../.. \\
+ -S \\\"C:\\Program Files\\Microsoft Visual Studio .NET 2003\\vc7\\include\\\" \\
+ -D _WIN32 \\
+ -D BOOST_PROTO_DOXYGEN_INVOKED \\
+ -p 1 \""
+ # This ensures that Wave is actually built before we try to execute it
+ <dependency>../../../../tools/wave/build release
     ;

xml proto
@@ -104,5 +104,5 @@
         # better use SVG's instead:
         # <xsl:param>admon.graphics.extension=".svg"

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

Modified: trunk/libs/xpressive/proto/doc/protodoc.xml
==============================================================================
--- trunk/libs/xpressive/proto/doc/protodoc.xml (original)
+++ trunk/libs/xpressive/proto/doc/protodoc.xml 2008-02-07 03:06:29 EST (Thu, 07 Feb 2008)
@@ -54,10 +54,7 @@
       <template-type-parameter name="Context"/>
       <template-type-parameter name="Tag"/>
       <template-nontype-parameter name="Arity"><type>long</type></template-nontype-parameter>
- </template></struct><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><struct-specialization name="default_eval"><template>
+ </template></struct><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::posit</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>
@@ -174,7 +171,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::arg</classname>< Expr >::const_reference, typename <classname>proto::result_of::arg</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>mpl::if_< is_const< Expr >, typename <classname>proto::result_of::arg</classname>< Expr >::const_reference, typename <classname>proto::result_of::arg</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-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>
@@ -207,7 +204,10 @@
     </template><specialization><template-arg>Expr</template-arg><template-arg>Context</template-arg><template-arg>proto::tag::function</template-arg><template-arg>4</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::arg_c< Expr, 1 >::type >::type, Context >::type, typename <classname>proto::result_of::eval</classname>< typename remove_reference< typename proto::result_of::arg_c< Expr, 2 >::type >::type, Context >::type, typename <classname>proto::result_of::eval</classname>< typename remove_reference< typename proto::result_of::arg_c< Expr, 3 >::type >::type, Context >::type)>::type</type></typedef><method-group name="public member functions"><method name="operator()" cv="const"><type>result_type</type><paramete
r 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>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::arg_c< Expr, 1 >::type >::type, Context >::type, typename <classname>proto::result_of::eval</classname>< typename remove_reference< typename proto::result_of::arg_c< Expr, 2 >::type >::type, Context >::type, typename <classname>proto::result_of::eval</classname>< typename remove_reference< typename proto::result_of::arg_c< Expr, 3 >::type >::type, Context >::type, typename <classname>proto::result_of::eval</classname>< typename remove_reference< typename proto::result_of::arg_c< Expr, 4 >::t
ype >::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></namespace></namespace></namespace></header><header name="boost/xpressive/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><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::arg_c< Expr, 1 >::type >::type, Context >::type, typename <classname>proto::result_of::eval</classname>< typename remove_reference< typename proto::result_of::arg_c< Expr, 2 >::type >::type, Context >::type, typename <classname>proto::result_of::eval</classname>< typename remove_reference< typename proto::result_of::arg_c< Expr, 3 >::type >::type, Context >::type, typename <classname>proto::result_of::eval</classname>< typename remove_reference< typename proto::result_of::arg_c< Expr, 4 >::t
ype >::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/xpressive/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></template-nontype-parameter>
@@ -250,12 +250,10 @@
         </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/xpressive/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 name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+</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>< 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><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="Expr"/>
@@ -292,9 +290,7 @@
     </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="EnableIf"/>
- </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>default_domain</type></typedef></struct></namespace></namespace></namespace></header><header name="boost/xpressive/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 name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </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>default_domain</type></typedef></struct></namespace></namespace></namespace></header><header name="boost/xpressive/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"/>
@@ -321,23 +317,23 @@
           <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>args2</classname>< ref_< expr const >, typename <classname>result_of::as_arg</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>args2</classname>< ref_< expr const >, typename <classname>result_of::as_arg</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>args2</classname>< ref_< expr >, typename <classname>result_of::as_arg</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>args2</classname>< ref_< expr >, typename <classname>result_of::as_arg</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>args1</classname>< ref_< 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>args1</classname>< ref_< 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, 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>args1</classname>< ref_< 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>args1</classname>< ref_< 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 , 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, const A0, const A1 >::type const</type><template>
+ </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 , const A0, const A1 >::type const</type><template>
           <template-type-parameter name="A0"/>
           <template-type-parameter name="A1"/>
- </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 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::funop3</classname>< expr const, const A0, const A1, const A2 >::type const</type><template>
+ </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 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::funop3</classname>< expr const , const A0, const A1, const A2 >::type const</type><template>
           <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>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::funop4</classname>< expr const, const A0, const A1, const A2, const A3 >::type const</type><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>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::funop4</classname>< expr const , const A0, const A1, const A2, const A3 >::type const</type><template>
           <template-type-parameter name="A0"/>
           <template-type-parameter name="A1"/>
           <template-type-parameter name="A2"/>
@@ -375,19 +371,19 @@
           <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>args2</classname>< ref_< expr const >, typename <classname>result_of::as_arg</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>args2</classname>< ref_< expr const >, typename <classname>result_of::as_arg</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>args1</classname>< ref_< 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, 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>args1</classname>< ref_< 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 , 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, const A0, const A1 >::type const</type><template>
+ </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 , const A0, const A1 >::type const</type><template>
           <template-type-parameter name="A0"/>
           <template-type-parameter name="A1"/>
- </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 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::funop3</classname>< expr const, const A0, const A1, const A2 >::type const</type><template>
+ </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 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::funop3</classname>< expr const , const A0, const A1, const A2 >::type const</type><template>
           <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>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::funop4</classname>< expr const, const A0, const A1, const A2, const A3 >::type const</type><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>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::funop4</classname>< expr const , const A0, const A1, const A2, const A3 >::type const</type><template>
           <template-type-parameter name="A0"/>
           <template-type-parameter name="A1"/>
           <template-type-parameter name="A2"/>
@@ -411,19 +407,19 @@
           <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>args2</classname>< ref_< expr const >, typename <classname>result_of::as_arg</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>args2</classname>< ref_< expr const >, typename <classname>result_of::as_arg</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>args1</classname>< ref_< 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, 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>args1</classname>< ref_< 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 , 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, const A0, const A1 >::type const</type><template>
+ </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 , const A0, const A1 >::type const</type><template>
           <template-type-parameter name="A0"/>
           <template-type-parameter name="A1"/>
- </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 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::funop3</classname>< expr const, const A0, const A1, const A2 >::type const</type><template>
+ </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 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::funop3</classname>< expr const , const A0, const A1, const A2 >::type const</type><template>
           <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>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::funop4</classname>< expr const, const A0, const A1, const A2, const A3 >::type const</type><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>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::funop4</classname>< expr const , const A0, const A1, const A2, const A3 >::type const</type><template>
           <template-type-parameter name="A0"/>
           <template-type-parameter name="A1"/>
           <template-type-parameter name="A2"/>
@@ -448,19 +444,19 @@
           <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>args2</classname>< ref_< expr const >, typename <classname>result_of::as_arg</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>args2</classname>< ref_< expr const >, typename <classname>result_of::as_arg</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>args1</classname>< ref_< 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, 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>args1</classname>< ref_< 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 , 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, const A0, const A1 >::type const</type><template>
+ </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 , const A0, const A1 >::type const</type><template>
           <template-type-parameter name="A0"/>
           <template-type-parameter name="A1"/>
- </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 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::funop3</classname>< expr const, const A0, const A1, const A2 >::type const</type><template>
+ </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 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::funop3</classname>< expr const , const A0, const A1, const A2 >::type const</type><template>
           <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>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::funop4</classname>< expr const, const A0, const A1, const A2, const A3 >::type const</type><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>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::funop4</classname>< expr const , const A0, const A1, const A2, const A3 >::type const</type><template>
           <template-type-parameter name="A0"/>
           <template-type-parameter name="A1"/>
           <template-type-parameter name="A2"/>
@@ -486,19 +482,19 @@
           <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>args2</classname>< ref_< expr const >, typename <classname>result_of::as_arg</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>args2</classname>< ref_< expr const >, typename <classname>result_of::as_arg</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>args1</classname>< ref_< 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, 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>args1</classname>< ref_< 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 , 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, const A0, const A1 >::type const</type><template>
+ </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 , const A0, const A1 >::type const</type><template>
           <template-type-parameter name="A0"/>
           <template-type-parameter name="A1"/>
- </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 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::funop3</classname>< expr const, const A0, const A1, const A2 >::type const</type><template>
+ </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 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::funop3</classname>< expr const , const A0, const A1, const A2 >::type const</type><template>
           <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>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::funop4</classname>< expr const, const A0, const A1, const A2, const A3 >::type const</type><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>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::funop4</classname>< expr const , const A0, const A1, const A2, const A3 >::type const</type><template>
           <template-type-parameter name="A0"/>
           <template-type-parameter name="A1"/>
           <template-type-parameter name="A2"/>
@@ -525,19 +521,19 @@
           <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>args2</classname>< ref_< expr const >, typename <classname>result_of::as_arg</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>args2</classname>< ref_< expr const >, typename <classname>result_of::as_arg</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>args1</classname>< ref_< 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, 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>args1</classname>< ref_< 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 , 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, const A0, const A1 >::type const</type><template>
+ </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 , const A0, const A1 >::type const</type><template>
           <template-type-parameter name="A0"/>
           <template-type-parameter name="A1"/>
- </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 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::funop3</classname>< expr const, const A0, const A1, const A2 >::type const</type><template>
+ </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><parameter name="a1"><paramtype>A1 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::funop3</classname>< expr const , const A0, const A1, const A2 >::type const</type><template>
           <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>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::funop4</classname>< expr const, const A0, const A1, const A2, const A3 >::type const</type><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>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::funop4</classname>< expr const , const A0, const A1, const A2, const A3 >::type const</type><template>
           <template-type-parameter name="A0"/>
           <template-type-parameter name="A1"/>
           <template-type-parameter name="A2"/>
@@ -563,7 +559,7 @@
     </template><specialization><template-arg>Expr()</template-arg><template-arg>This</template-arg></specialization><inherit access="public">boost::proto::result_of::funop0< This ></inherit><purpose>A helper metafunction for computing the return type of <computeroutput>proto::expr<>operator()</computeroutput>. </purpose></struct-specialization><struct-specialization name="funop"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="This"/>
- </template><specialization><template-arg>Expr const()</template-arg><template-arg>This</template-arg></specialization><inherit access="public">boost::proto::result_of::funop0< Expr ></inherit><purpose>A helper metafunction for computing the return type of <computeroutput>proto::expr<>operator()</computeroutput>. </purpose></struct-specialization><struct name="funop1"><template>
+ </template><specialization><template-arg>Expr const ()</template-arg><template-arg>This</template-arg></specialization><inherit access="public">boost::proto::result_of::funop0< Expr ></inherit><purpose>A helper metafunction for computing the return type of <computeroutput>proto::expr<>operator()</computeroutput>. </purpose></struct-specialization><struct name="funop1"><template>
       <template-type-parameter name="Expr"/>
       <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>args2</classname>< ref_< Expr >, typename <classname>result_of::as_arg</classname>< A0 >::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>
@@ -574,7 +570,7 @@
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="A0"/>
       <template-type-parameter name="This"/>
- </template><specialization><template-arg>Expr const(A0)</template-arg><template-arg>This</template-arg></specialization><inherit access="public">boost::proto::result_of::funop1< Expr, A0 ></inherit><purpose>A helper metafunction for computing the return type of <computeroutput>proto::expr<>operator()</computeroutput>. </purpose></struct-specialization><struct name="funop2"><template>
+ </template><specialization><template-arg>Expr const (A0)</template-arg><template-arg>This</template-arg></specialization><inherit access="public">boost::proto::result_of::funop1< Expr, A0 ></inherit><purpose>A helper metafunction for computing the return type of <computeroutput>proto::expr<>operator()</computeroutput>. </purpose></struct-specialization><struct name="funop2"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="A0"/>
       <template-type-parameter name="A1"/>
@@ -588,7 +584,7 @@
       <template-type-parameter name="A0"/>
       <template-type-parameter name="A1"/>
       <template-type-parameter name="This"/>
- </template><specialization><template-arg>Expr const(A0</template-arg><template-arg>A1)</template-arg><template-arg>This</template-arg></specialization><inherit access="public">boost::proto::result_of::funop2< Expr, A0, A1 ></inherit><purpose>A helper metafunction for computing the return type of <computeroutput>proto::expr<>operator()</computeroutput>. </purpose></struct-specialization><struct name="funop3"><template>
+ </template><specialization><template-arg>Expr const (A0</template-arg><template-arg>A1)</template-arg><template-arg>This</template-arg></specialization><inherit access="public">boost::proto::result_of::funop2< Expr, A0, A1 ></inherit><purpose>A helper metafunction for computing the return type of <computeroutput>proto::expr<>operator()</computeroutput>. </purpose></struct-specialization><struct name="funop3"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="A0"/>
       <template-type-parameter name="A1"/>
@@ -605,7 +601,7 @@
       <template-type-parameter name="A1"/>
       <template-type-parameter name="A2"/>
       <template-type-parameter name="This"/>
- </template><specialization><template-arg>Expr const(A0</template-arg><template-arg>A1</template-arg><template-arg>A2)</template-arg><template-arg>This</template-arg></specialization><inherit access="public">boost::proto::result_of::funop3< Expr, A0, A1, A2 ></inherit><purpose>A helper metafunction for computing the return type of <computeroutput>proto::expr<>operator()</computeroutput>. </purpose></struct-specialization><struct name="funop4"><template>
+ </template><specialization><template-arg>Expr const (A0</template-arg><template-arg>A1</template-arg><template-arg>A2)</template-arg><template-arg>This</template-arg></specialization><inherit access="public">boost::proto::result_of::funop3< Expr, A0, A1, A2 ></inherit><purpose>A helper metafunction for computing the return type of <computeroutput>proto::expr<>operator()</computeroutput>. </purpose></struct-specialization><struct name="funop4"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="A0"/>
       <template-type-parameter name="A1"/>
@@ -625,7 +621,7 @@
       <template-type-parameter name="A2"/>
       <template-type-parameter name="A3"/>
       <template-type-parameter name="This"/>
- </template><specialization><template-arg>Expr const(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3)</template-arg><template-arg>This</template-arg></specialization><inherit access="public">boost::proto::result_of::funop4< Expr, A0, A1, A2, A3 ></inherit><purpose>A helper metafunction for computing the return type of <computeroutput>proto::expr<>operator()</computeroutput>. </purpose></struct-specialization></namespace></namespace></namespace></header><header name="boost/xpressive/proto/extends.hpp"><para>Macros and a base class for defining end-user expression types </para><namespace name="boost"><namespace name="proto"><namespace name="exprns_"><struct name="is_proto_expr"><purpose>Empty type to be used as a dummy template parameter of POD expression wrappers. It allows argument-dependent lookup to find Proto's operator overloads. </purpose><description><para><computeroutput>proto::is_proto_expr</computeroutput> allows argument-dependent look
up to find Proto's operator overloads. For example:</para><para><programlisting> template<typename T, typename Dummy = proto::is_proto_expr>
+ </template><specialization><template-arg>Expr const (A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3)</template-arg><template-arg>This</template-arg></specialization><inherit access="public">boost::proto::result_of::funop4< Expr, A0, A1, A2, A3 ></inherit><purpose>A helper metafunction for computing the return type of <computeroutput>proto::expr<>operator()</computeroutput>. </purpose></struct-specialization></namespace></namespace></namespace></header><header name="boost/xpressive/proto/extends.hpp"><para>Macros and a base class for defining end-user expression types </para><namespace name="boost"><namespace name="proto"><namespace name="exprns_"><struct name="is_proto_expr"><purpose>Empty type to be used as a dummy template parameter of POD expression wrappers. It allows argument-dependent lookup to find Proto's operator overloads. </purpose><description><para><computeroutput>proto::is_proto_expr</computeroutput> allows argument-dependent loo
kup to find Proto's operator overloads. For example:</para><para><programlisting> template<typename T, typename Dummy = proto::is_proto_expr>
  struct my_terminal
  {
      BOOST_PROTO_EXTENDS(
@@ -645,9 +641,9 @@
       <template-type-parameter name="Tag"/>
     </template><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::mpl::apply_wrap1< Domain, typename boost::proto::result_of::funop< Sig, Derived >::type >::type</type></typedef></struct><data-member name="expr"><type>Expr</type></data-member><typedef name="proto_base_expr"><type>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>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_is_expr_"><type>void</type></typedef><typedef name="fusion_tag"><type>boost::proto::tag::proto_expr</type></typedef><typedef name="proto_arg0"><type>Expr::proto_arg0</type></typedef><typedef name="proto_arg1"><type>Expr::proto_arg1</type></typedef><typedef name="proto_arg2"><type>Expr::proto_arg2</type></typedef><typedef name="proto_arg3"><type>Expr::proto_arg3</type></typedef><ty
pedef name="proto_arg4"><type>Expr::proto_arg4</type></typedef><method-group name="public member functions"><method name="proto_base" cv=""><type>Expr &</type></method><method name="proto_base" cv="const"><type>Expr const &</type></method><method name="operator[]" cv="const"><type>boost::mpl::apply_wrap1< Domain, boost::proto::expr< <classname>boost::proto::tag::subscript</classname>, <classname>boost::proto::args2</classname>< boost::proto::ref_< Derived const >, typename <classname>boost::proto::result_of::as_arg</classname>< A >::type > > >::type const</type><template>
+ </template><typedef name="type"><type>boost::mpl::apply_wrap1< Domain, typename boost::proto::result_of::funop< Sig, Derived >::type >::type</type></typedef></struct><data-member name="expr"><type>Expr</type></data-member><typedef name="proto_base_expr"><type>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>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_is_expr_"><type>void</type></typedef><typedef name="fusion_tag"><type>boost::proto::tag::proto_expr</type></typedef><typedef name="proto_arg0"><type>Expr::proto_arg0</type></typedef><typedef name="proto_arg1"><type>Expr::proto_arg1</type></typedef><typedef name="proto_arg2"><type>Expr::proto_arg2</type></typedef><typedef name="proto_arg3"><type>Expr::proto_arg3</type></typedef><ty
pedef name="proto_arg4"><type>Expr::proto_arg4</type></typedef><method-group name="public member functions"><method name="proto_base" cv=""><type>Expr &</type></method><method name="proto_base" cv="const"><type>Expr const &</type></method><method name="operator[]" cv="const"><type>boost::mpl::apply_wrap1< Domain, boost::proto::expr< <classname>boost::proto::tag::subscript</classname>, <classname>boost::proto::args2</classname>< boost::proto::ref_< Derived const >, typename <classname>boost::proto::result_of::as_arg</classname>< A >::type > > >::type const</type><template>
           <template-type-parameter name="A"/>
- </template><parameter name="a"><paramtype>A &</paramtype></parameter></method><method name="operator[]" cv="const"><type>boost::mpl::apply_wrap1< Domain, boost::proto::expr< <classname>boost::proto::tag::subscript</classname>, <classname>boost::proto::args2</classname>< boost::proto::ref_< Derived const >, typename <classname>boost::proto::result_of::as_arg</classname>< A const >::type > > >::type const</type><template>
+ </template><parameter name="a"><paramtype>A &</paramtype></parameter></method><method name="operator[]" cv="const"><type>boost::mpl::apply_wrap1< Domain, boost::proto::expr< <classname>boost::proto::tag::subscript</classname>, <classname>boost::proto::args2</classname>< boost::proto::ref_< Derived const >, typename <classname>boost::proto::result_of::as_arg</classname>< A const >::type > > >::type const</type><template>
           <template-type-parameter name="A"/>
         </template><parameter name="a"><paramtype>A const &</paramtype></parameter></method><method name="operator()" cv="const"><type>boost::mpl::apply_wrap1< Domain, typename <classname>boost::proto::result_of::funop0</classname>< Derived const >::type >::type const</type></method><method name="operator()" cv="const"><type>boost::mpl::apply_wrap1< Domain, typename <classname>boost::proto::result_of::funop1</classname>< Derived const , const A0 >::type >::type const</type><template>
           <template-type-parameter name="A0"/>
@@ -673,9 +669,9 @@
       <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::mpl::apply_wrap1< Domain, typename boost::proto::result_of::funop< Sig, Derived >::type >::type</type></typedef></struct><data-member name="expr"><type>Expr</type></data-member><typedef name="proto_base_expr"><type>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>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_is_expr_"><type>void</type></typedef><typedef name="fusion_tag"><type>boost::proto::tag::proto_expr</type></typedef><typedef name="proto_arg0"><type>Expr::proto_arg0</type></typedef><typedef name="proto_arg1"><type>Expr::proto_arg1</type></typedef><typedef name="proto_arg2"><type>Expr::proto_arg2</type></typedef><typedef name="proto_arg3"><type>Expr::proto_arg3</type></typedef><ty
pedef name="proto_arg4"><type>Expr::proto_arg4</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>Expr &</type></method><method name="proto_base" cv="const"><type>Expr const &</type></method><method name="operator[]" cv="const"><type>boost::mpl::apply_wrap1< Domain, boost::proto::expr< <classname>boost::proto::tag::subscript</classname>, <classname>boost::proto::args2</classname>< boost::proto::ref_< Derived const >, typename <classname>boost::proto::result_of::as_arg</classname>< A >::type > > >::type const</type><template>
+ </template><typedef name="type"><type>boost::mpl::apply_wrap1< Domain, typename boost::proto::result_of::funop< Sig, Derived >::type >::type</type></typedef></struct><data-member name="expr"><type>Expr</type></data-member><typedef name="proto_base_expr"><type>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>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_is_expr_"><type>void</type></typedef><typedef name="fusion_tag"><type>boost::proto::tag::proto_expr</type></typedef><typedef name="proto_arg0"><type>Expr::proto_arg0</type></typedef><typedef name="proto_arg1"><type>Expr::proto_arg1</type></typedef><typedef name="proto_arg2"><type>Expr::proto_arg2</type></typedef><typedef name="proto_arg3"><type>Expr::proto_arg3</type></typedef><ty
pedef name="proto_arg4"><type>Expr::proto_arg4</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>Expr &</type></method><method name="proto_base" cv="const"><type>Expr const &</type></method><method name="operator[]" cv="const"><type>boost::mpl::apply_wrap1< Domain, boost::proto::expr< <classname>boost::proto::tag::subscript</classname>, <classname>boost::proto::args2</classname>< boost::proto::ref_< Derived const >, typename <classname>boost::proto::result_of::as_arg</classname>< A >::type > > >::type const</type><template>
           <template-type-parameter name="A"/>
- </template><parameter name="a"><paramtype>A &</paramtype></parameter></method><method name="operator[]" cv="const"><type>boost::mpl::apply_wrap1< Domain, boost::proto::expr< <classname>boost::proto::tag::subscript</classname>, <classname>boost::proto::args2</classname>< boost::proto::ref_< Derived const >, typename <classname>boost::proto::result_of::as_arg</classname>< A const >::type > > >::type const</type><template>
+ </template><parameter name="a"><paramtype>A &</paramtype></parameter></method><method name="operator[]" cv="const"><type>boost::mpl::apply_wrap1< Domain, boost::proto::expr< <classname>boost::proto::tag::subscript</classname>, <classname>boost::proto::args2</classname>< boost::proto::ref_< Derived const >, typename <classname>boost::proto::result_of::as_arg</classname>< A const >::type > > >::type const</type><template>
           <template-type-parameter name="A"/>
         </template><parameter name="a"><paramtype>A const &</paramtype></parameter></method><method name="operator[]" cv=""><type>boost::mpl::apply_wrap1< Domain, boost::proto::expr< <classname>boost::proto::tag::subscript</classname>, <classname>boost::proto::args2</classname>< boost::proto::ref_< Derived >, typename <classname>boost::proto::result_of::as_arg</classname>< A >::type > > >::type const</type><template>
           <template-type-parameter name="A"/>
@@ -717,29 +713,20 @@
           <template-type-parameter name="A"/>
         </template><parameter name="a"><paramtype>A &</paramtype></parameter></copy-assignment><copy-assignment><template>
           <template-type-parameter name="A"/>
- </template><parameter name="a"><paramtype>A const &</paramtype></parameter></copy-assignment><method-group name="public static functions"><method name="make" cv=""><type>static Derived const</type><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></method></method-group></struct-specialization></namespace></namespace></namespace></header><header name="boost/xpressive/proto/fusion.hpp"><para>Make any Proto expression a valid Fusion sequence </para><namespace name="boost"><namespace name="proto"><struct-specialization name="is_callable"><template>
- </template><specialization><template-arg>functional::flatten</template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><struct-specialization name="is_callable"><template>
- </template><specialization><template-arg>functional::pop_front</template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><struct-specialization name="is_callable"><template>
- </template><specialization><template-arg>functional::reverse</template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><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 name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><parameter name="a"><paramtype>A const &</paramtype></parameter></copy-assignment><method-group name="public static functions"><method name="make" cv=""><type>static Derived const</type><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></method></method-group></struct-specialization></namespace></namespace></namespace></header><header name="boost/xpressive/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>
           <template-type-parameter name="Expr"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></method></method-group></struct><struct name="pop_front"><purpose>A PolymorphicFunctionObject type that invokes the <computeroutput>fusion::pop_front()</computeroutput> algorithm on its argument. </purpose><description><para>A PolymorphicFunctionObject type that invokes the <computeroutput>fusion::pop_front()</computeroutput> algorithm on its argument. This is useful for defining a CallableTransform like <computeroutput>pop_front(_)</computeroutput> which removes the first child from a Proto expression node. Such a transform might be used as the first argument to the <computeroutput>proto::transform::fold<></computeroutput> transform; that is, fold all but the first child. </para></description><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></method></method-group></struct><struct name="pop_front"><purpose>A PolymorphicFunctionObject type that invokes the <computeroutput>fusion::pop_front()</computeroutput> algorithm on its argument. </purpose><description><para>A PolymorphicFunctionObject type that invokes the <computeroutput>fusion::pop_front()</computeroutput> algorithm on its argument. This is useful for defining a CallableTransform like <computeroutput>pop_front(_)</computeroutput> which removes the first child from a Proto expression node. Such a transform might be used as the first argument to the <computeroutput>proto::transform::fold<></computeroutput> transform; that is, fold all but the first child. </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>fusion::result_of::pop_front< typename boost::remove_reference< Expr >::type const >::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>fusion::result_of::pop_front< Expr const >::type</type><template>
+ </template><specialization><template-arg>This(Expr)</template-arg></specialization><typedef name="type"><type>fusion::result_of::pop_front< typename boost::remove_reference< Expr >::type const >::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>fusion::result_of::pop_front< Expr const >::type</type><template>
           <template-type-parameter name="Expr"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></method></method-group></struct><struct name="reverse"><purpose>A PolymorphicFunctionObject type that invokes the <computeroutput>fusion::reverse()</computeroutput> algorithm on its argument. </purpose><description><para>A PolymorphicFunctionObject type that invokes the <computeroutput>fusion::reverse()</computeroutput> algorithm on its argument. This is useful for defining a CallableTransform like <computeroutput>reverse(_)</computeroutput> which reverses the order of the children of a Proto expression node. </para></description><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></method></method-group></struct><struct name="reverse"><purpose>A PolymorphicFunctionObject type that invokes the <computeroutput>fusion::reverse()</computeroutput> algorithm on its argument. </purpose><description><para>A PolymorphicFunctionObject type that invokes the <computeroutput>fusion::reverse()</computeroutput> algorithm on its argument. This is useful for defining a CallableTransform like <computeroutput>reverse(_)</computeroutput> which reverses the order of the children of a Proto expression node. </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>fusion::result_of::reverse< typename boost::remove_reference< Expr >::type const >::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>fusion::result_of::reverse< Expr const >::type</type><template>
+ </template><specialization><template-arg>This(Expr)</template-arg></specialization><typedef name="type"><type>fusion::result_of::reverse< typename boost::remove_reference< Expr >::type const >::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>fusion::result_of::reverse< Expr const >::type</type><template>
           <template-type-parameter name="Expr"/>
         </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></method></method-group></struct></namespace><data-member name="flatten"><type><classname>functional::flatten</classname> const</type><purpose>A PolymorphicFunctionObject type that returns a "flattened" view of a Proto expression tree. </purpose><description><para><para>boost::proto::functional::flatten </para>
</para></description></data-member></namespace></namespace></header><header name="boost/xpressive/proto/generate.hpp"><para>Contains definition of generate<> class template, which end users can specialize for generating domain-specific expression wrappers. </para><namespace name="boost"><namespace name="proto"><namespace name="generatorns_"><struct name="default_generator"><purpose>A simple generator that passes an expression through unchanged. </purpose><description><para>Generators are intended for use as the first template parameter to the <computeroutput>domain<></computeroutput> class template and control if and how expressions within that domain are to be customized. The <computeroutput>default_generator</computeroutput> makes no modifications to the expressions passed to it. </para></description><struct name="apply"><template>
@@ -789,18 +776,10 @@

-</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/xpressive/proto/make_expr.hpp"><para>Definition of the <computeroutput>make_expr()</computeroutput> and <computeroutput>unpack_expr()</computeroutput> utilities for building Proto expression nodes from children nodes or from a Fusion sequence of children nodes, respectively. </para><namespace name="boost"><namespace name="proto"><struct-specialization name="is_callable"><template>
- <template-type-parameter name="Tag"/>
- <template-type-parameter name="Domain"/>
- </template><specialization><template-arg>functional::make_expr< Tag</template-arg><template-arg>Domain ></template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><struct-specialization name="is_callable"><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/xpressive/proto/make_expr.hpp"><para>Definition of the <computeroutput>make_expr()</computeroutput> and <computeroutput>unpack_expr()</computeroutput> utilities for building Proto expression nodes from children nodes or from a Fusion sequence of children nodes, respectively. </para><namespace name="boost"><namespace name="proto"><namespace name="functional"><struct name="make_expr"><template>
       <template-type-parameter name="Tag"/>
       <template-type-parameter name="Domain"/>
- </template><specialization><template-arg>functional::unpack_expr< Tag</template-arg><template-arg>Domain ></template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><namespace name="functional"><struct name="make_expr"><template>
- <template-type-parameter name="Tag"/>
- <template-type-parameter name="Domain"/>
- </template><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><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>
@@ -825,7 +804,7 @@
       <template-type-parameter name="A2"/>
       <template-type-parameter name="A3"/>
       <template-type-parameter name="A4"/>
- </template><specialization><template-arg>This(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3</template-arg><template-arg>A4)</template-arg></specialization><typedef name="type"><type><classname>result_of::make_expr</classname>< Tag, Domain, A0, A1, A2, A3, A4 >::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::make_expr</classname>< Tag, Domain, A0 const >::type const</type><template>
+ </template><specialization><template-arg>This(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3</template-arg><template-arg>A4)</template-arg></specialization><typedef name="type"><type><classname>result_of::make_expr</classname>< Tag, Domain, A0, A1, A2, A3, A4 >::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::make_expr</classname>< Tag, Domain, A0 const >::type const</type><template>
           <template-type-parameter name="A0"/>
         </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter><description><para>Construct an expression node with tag type <computeroutput>Tag</computeroutput> and in the domain <computeroutput>Domain</computeroutput>. </para></description></method><method name="operator()" cv="const"><type><classname>result_of::make_expr</classname>< Tag, Domain, const A0, const A1 >::type const</type><template>
           <template-type-parameter name="A0"/>
@@ -860,7 +839,11 @@
       <template-type-parameter name="Sequence"/>
       <template-type-parameter name="EnableIf1"/>
       <template-type-parameter name="EnableIf2"/>
- </template><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct><struct name="make_expr"><template>
+ </template><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct><struct-specialization name="unpack_expr"><template>
+ <template-type-parameter name="Tag"/>
+ <template-type-parameter name="Domain"/>
+ <template-type-parameter name="Sequence"/>
+ </template><specialization><template-arg>Tag</template-arg><template-arg>Domain</template-arg><template-arg>Sequence</template-arg><template-arg>typename Domain::proto_is_domain_</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><struct name="make_expr"><template>
       <template-type-parameter name="Tag"/>
       <template-type-parameter name="A0"/>
       <template-type-parameter name="A1"/>
@@ -869,11 +852,7 @@
       <template-type-parameter name="A4"/>
       <template-type-parameter name="EnableIf1"/>
       <template-type-parameter name="EnableIf2"/>
- </template><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct><struct-specialization name="unpack_expr"><template>
- <template-type-parameter name="Tag"/>
- <template-type-parameter name="Domain"/>
- <template-type-parameter name="Sequence"/>
- </template><specialization><template-arg>Tag</template-arg><template-arg>Domain</template-arg><template-arg>Sequence</template-arg><template-arg>typename Domain::proto_is_domain_</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization><struct-specialization name="make_expr"><template>
+ </template><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct><struct-specialization name="make_expr"><template>
       <template-type-parameter name="Tag"/>
       <template-type-parameter name="Domain"/>
       <template-type-parameter name="A0"/>
@@ -884,14 +863,14 @@
     </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><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization></namespace><overloaded-function name="unpack_expr"><signature><type>lazy_disable_if< is_domain< Sequence >, <classname>result_of::unpack_expr</classname>< Tag, Sequence const >>::type const</type><template>
           <template-type-parameter name="Tag"/>
           <template-type-parameter name="Sequence"/>
- </template><parameter name="sequence"><paramtype>Sequence const &</paramtype></parameter></signature><signature><type><classname>result_of::unpack_expr</classname>< Tag, Domain, Sequence2 const >::type const</type><template>
+ </template><parameter name="sequence"><paramtype>Sequence const &</paramtype></parameter></signature><signature><type><classname>result_of::unpack_expr</classname>< Tag, Domain, Sequence2 const >::type const</type><template>
           <template-type-parameter name="Tag"/>
           <template-type-parameter name="Domain"/>
           <template-type-parameter name="Sequence2"/>
         </template><parameter name="sequence2"><paramtype>Sequence2 const &</paramtype></parameter></signature><description><para>unpack_expr </para></description></overloaded-function><overloaded-function name="make_expr"><signature><type>lazy_disable_if< is_domain< A0 >, <classname>result_of::make_expr</classname>< Tag, A0 const >>::type const</type><template>
           <template-type-parameter name="Tag"/>
           <template-type-parameter name="A0"/>
- </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter></signature><signature><type><classname>result_of::make_expr</classname>< Tag, Domain, B0 const >::type const</type><template>
+ </template><parameter name="a0"><paramtype>A0 const &</paramtype></parameter></signature><signature><type><classname>result_of::make_expr</classname>< Tag, Domain, B0 const >::type const</type><template>
           <template-type-parameter name="Tag"/>
           <template-type-parameter name="Domain"/>
           <template-type-parameter name="B0"/>
@@ -943,37 +922,9 @@
           <template-type-parameter name="B2"/>
           <template-type-parameter name="B3"/>
           <template-type-parameter name="B4"/>
- </template><parameter name="b0"><paramtype>const B0 &</paramtype></parameter><parameter name="b1"><paramtype>const B1 &</paramtype></parameter><parameter name="b2"><paramtype>const B2 &</paramtype></parameter><parameter name="b3"><paramtype>const B3 &</paramtype></parameter><parameter name="b4"><paramtype>const B4 &</paramtype></parameter></signature><description><para>make_expr </para></description></overloaded-function></namespace></namespace></header><header name="boost/xpressive/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"><struct-specialization name="is_callable"><template>
- <template-type-parameter name="G0"/>
- <template-type-parameter name="G1"/>
- <template-type-parameter name="G2"/>
- <template-type-parameter name="G3"/>
- <template-type-parameter name="G4"/>
- <template-type-parameter name="G5"/>
- <template-type-parameter name="G6"/>
- <template-type-parameter name="G7"/>
- </template><specialization><template-arg>or_< G0</template-arg><template-arg>G1</template-arg><template-arg>G2</template-arg><template-arg>G3</template-arg><template-arg>G4</template-arg><template-arg>G5</template-arg><template-arg>G6</template-arg><template-arg>G7 ></template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><struct-specialization name="is_callable"><template>
- <template-type-parameter name="G0"/>
- <template-type-parameter name="G1"/>
- <template-type-parameter name="G2"/>
- <template-type-parameter name="G3"/>
- <template-type-parameter name="G4"/>
- <template-type-parameter name="G5"/>
- <template-type-parameter name="G6"/>
- <template-type-parameter name="G7"/>
- </template><specialization><template-arg>and_< G0</template-arg><template-arg>G1</template-arg><template-arg>G2</template-arg><template-arg>G3</template-arg><template-arg>G4</template-arg><template-arg>G5</template-arg><template-arg>G6</template-arg><template-arg>G7 ></template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><struct-specialization name="is_callable"><template>
- <template-type-parameter name="Grammar"/>
- </template><specialization><template-arg>not_< Grammar ></template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><struct-specialization name="is_callable"><template>
- <template-type-parameter name="If"/>
- <template-type-parameter name="Then"/>
- <template-type-parameter name="Else"/>
- </template><specialization><template-arg>if_< If</template-arg><template-arg>Then</template-arg><template-arg>Else ></template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><struct-specialization name="is_callable"><template>
+ </template><parameter name="b0"><paramtype>const B0 &</paramtype></parameter><parameter name="b1"><paramtype>const B1 &</paramtype></parameter><parameter name="b2"><paramtype>const B2 &</paramtype></parameter><parameter name="b3"><paramtype>const B3 &</paramtype></parameter><parameter name="b4"><paramtype>const B4 &</paramtype></parameter></signature><description><para>make_expr </para></description></overloaded-function></namespace></namespace></header><header name="boost/xpressive/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><specialization><template-arg>vararg< Grammar ></template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><namespace name="control"><struct name="not_"><template>
- <template-type-parameter name="Grammar"/>
- </template><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
@@ -982,18 +933,24 @@
           <template-type-parameter name="Expr"/>
           <template-type-parameter name="State"/>
           <template-type-parameter name="Visitor"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name=""><paramtype>State const &</paramtype></parameter><parameter name=""><paramtype>Visitor &</paramtype></parameter></method></method-group></struct><struct name="if_"><template>
+ </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>Visitor &</paramtype></parameter><description><para>
+
+</para></description><returns><para>expr </para></returns></method></method-group></struct><struct name="if_"><template>
       <template-type-parameter name="If"/>
       <template-type-parameter name="Then"/>
       <template-type-parameter name="Else"/>
- </template><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="branch"><type>mpl::if_< typename when< _, If >::template <classname>result</classname>< void(Expr, State, Visitor) >::type, when< _, Then >, when< _, Else >>::type</type></typedef><typedef name="type"><type>branch::template <classname>result</classname>< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><typedef name="proto_base_expr"><type><classname>if_</classname></type></typedef></struct><struct name="or_"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="condition"><type>when< _, If >::template result< void(Expr, State, Visitor) >::type</type></typedef><typedef name="which"><type>mpl::if_< condition, when< _, Then >, when< _, Else >>::type</type></typedef><typedef name="type"><type>which::template result< void(Expr, State, Visitor) >::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, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </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="visitor"><paramtype>Visitor &</paramtype><description><para>A visitor of arbitrary type </para></description></parameter><description><para>
+
+</para></description><returns><para>result<void(Expr, State, Visitor)>which()(expr, state, visitor) </para></returns></method></method-group></struct><struct name="or_"><template>
       <template-type-parameter name="G0"/>
       <template-type-parameter name="G1"/>
       <template-type-parameter name="G2"/>
@@ -1002,14 +959,18 @@
       <template-type-parameter name="G5"/>
       <template-type-parameter name="G6"/>
       <template-type-parameter name="G7"/>
- </template><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="which"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="type"><type>which::template <classname>result</classname>< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><typedef name="proto_base_expr"><type><classname>or_</classname></type></typedef></struct><struct name="and_"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="which"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="type"><type>which::template result< void(Expr, State, Visitor) >::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, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </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="visitor"><paramtype>Visitor &</paramtype><description><para>A visitor of arbitrary type </para></description></parameter><description><para>
+
+</para></description><returns><para>result<void(Expr, State, Visitor)>which()(expr, state, visitor) </para></returns></method></method-group></struct><struct name="and_"><template>
       <template-type-parameter name="G0"/>
       <template-type-parameter name="G1"/>
       <template-type-parameter name="G2"/>
@@ -1018,23 +979,31 @@
       <template-type-parameter name="G5"/>
       <template-type-parameter name="G6"/>
       <template-type-parameter name="G7"/>
- </template><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="which"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="type"><type>which::template <classname>result</classname>< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><typedef name="proto_base_expr"><type><classname>and_</classname></type></typedef></struct><struct name="switch_"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="which"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="type"><type>which::template result< void(Expr, State, Visitor) >::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, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </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="visitor"><paramtype>Visitor &</paramtype><description><para>A visitor of arbitrary type </para></description></parameter><description><para>
+
+</para></description><returns><para>result<void(Expr, State, Visitor)>which()(expr, state, visitor) </para></returns></method></method-group></struct><struct name="switch_"><template>
       <template-type-parameter name="Cases"/>
- </template><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type>Cases::template case_< typename Expr::proto_tag ></type></typedef><typedef name="type"><type>impl::template <classname>result</classname>< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><typedef name="proto_base_expr"><type><classname>switch_</classname></type></typedef></struct><struct name="exact"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</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, Visitor) >::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, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </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="visitor"><paramtype>Visitor &</paramtype><description><para>A visitor of arbitrary type </para></description></parameter><description><para>
+
+</para></description><returns><para>result<void(Expr, State, Visitor)>which()(expr, state, visitor) </para></returns></method></method-group></struct><struct name="exact"><template>
       <template-type-parameter name="T"/>
     </template></struct><struct name="convertible_to"><template>
       <template-type-parameter name="T"/>
@@ -1043,9 +1012,35 @@
     </template><typedef name="proto_is_vararg_"><type>void</type></typedef></struct></namespace><namespace name="result_of"><struct name="matches"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="Grammar"/>
- </template></struct></namespace><namespace name="wildcardns_"><struct name="_"><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><purpose>A Boolean metafunction that evaluates whether a given expression type matches a a grammar. </purpose><description><para><computeroutput>matches<Expr,Grammar></computeroutput> inherits (indirectly) from <computeroutput>mpl::true_</computeroutput> if <computeroutput>Expr::proto_base_expr</computeroutput> matches <computeroutput>Grammar::proto_base_expr</computeroutput>, and from <computeroutput>mpl::false_</computeroutput> otherwise.</para><para>Non-terminal expressions are matched against a grammar according to the following rules:</para><para><itemizedlist>
+<listitem><para>The wildcard pattern, <computeroutput>_</computeroutput>, matches any expression. </para></listitem>
+<listitem><para>An expression <computeroutput>expr<AT, argsN<A0,A1,...An> ></computeroutput> matches a grammar <computeroutput>expr<BT, argsN<B0,B1,...Bn> ></computeroutput> if <computeroutput>BT</computeroutput> is <computeroutput>_</computeroutput> or <computeroutput>AT</computeroutput>, and if <computeroutput>Ax</computeroutput> matches <computeroutput>Bx</computeroutput> for each <computeroutput>x</computeroutput> in <computeroutput>[0,n)</computeroutput>. </para></listitem>
+<listitem><para>An expression <computeroutput>expr<AT, argsN<A0,...An,U0,...Um> ></computeroutput> matches a grammar <computeroutput>expr<BT, argsM<B0,...Bn,vararg<V> > ></computeroutput> if <computeroutput>BT</computeroutput> is <computeroutput>_</computeroutput> or <computeroutput>AT</computeroutput>, and if <computeroutput>Ax</computeroutput> matches <computeroutput>Bx</computeroutput> for each <computeroutput>x</computeroutput> in <computeroutput>[0,n)</computeroutput> and if <computeroutput>Ux</computeroutput> matches <computeroutput>V</computeroutput> for each <computeroutput>x</computeroutput> in <computeroutput>[0,m)</computeroutput>. </para></listitem>
+<listitem><para>An expression <computeroutput>E</computeroutput> matches <computeroutput>or_<B0,B1,...Bn></computeroutput> if <computeroutput>E</computeroutput> matches some <computeroutput>Bx</computeroutput> for <computeroutput>x</computeroutput> in <computeroutput>[0,n)</computeroutput>. </para></listitem>
+<listitem><para>An expression <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></listitem>
+<listitem><para>An expression <computeroutput>E</computeroutput> matches <computeroutput>if_<T></computeroutput> if <computeroutput>when<_,T>result<void(E,int,int)>type::value</computeroutput> is <computeroutput>true</computeroutput>. </para></listitem>
+<listitem><para>An expression <computeroutput>E</computeroutput> matches <computeroutput>if_<T,U,V></computeroutput> if <computeroutput>when<_,T>result<void(E,int,int)>type::value</computeroutput> is <computeroutput>true</computeroutput> and matches <computeroutput>U</computeroutput>; or, if <computeroutput>when<_,T>result<void(E,int,int)>type::value</computeroutput> is <computeroutput>false</computeroutput> and matches <computeroutput>V</computeroutput>. </para></listitem>
+<listitem><para>An expression <computeroutput>E</computeroutput> matches <computeroutput>not_<T></computeroutput> if <computeroutput>E</computeroutput> does not match <computeroutput>T</computeroutput>. </para></listitem>
+<listitem><para>An expression <computeroutput>E</computeroutput> matches <computeroutput>switch_<C></computeroutput> if <computeroutput>E</computeroutput> matches <computeroutput>C::case_<E::proto_tag></computeroutput>.</para></listitem>
+</itemizedlist>
+A terminal expression <computeroutput>expr<tag::terminal,args0<A> ></computeroutput> matches a grammar <computeroutput>expr<BT,args0<B> ></computeroutput> if <computeroutput>BT</computeroutput> is <computeroutput>_</computeroutput> or <computeroutput>tag::terminal</computeroutput> and one of the following is true:</para><para><itemizedlist>
+<listitem><para><computeroutput>B</computeroutput> is the wildcard pattern, <computeroutput>_</computeroutput> </para></listitem>
+<listitem><para><computeroutput>A</computeroutput> is <computeroutput>B</computeroutput> </para></listitem>
+<listitem><para><computeroutput>A</computeroutput> is <computeroutput>B &</computeroutput> </para></listitem>
+<listitem><para><computeroutput>A</computeroutput> is <computeroutput>B const &</computeroutput> </para></listitem>
+<listitem><para><computeroutput>B</computeroutput> is <computeroutput>exact<A></computeroutput> </para></listitem>
+<listitem><para><computeroutput>B</computeroutput> is <computeroutput>convertible_to<X></computeroutput> and <computeroutput>is_convertible<A,X>value</computeroutput> is <computeroutput>true</computeroutput>. </para></listitem>
+<listitem><para><computeroutput>A</computeroutput> is <computeroutput>X[M]</computeroutput> or <computeroutput>X(&)[M]</computeroutput> and <computeroutput>B</computeroutput> is <computeroutput>X[proto::N]</computeroutput>. </para></listitem>
+<listitem><para><computeroutput>A</computeroutput> is <computeroutput>X(&)[M]</computeroutput> and <computeroutput>B</computeroutput> is <computeroutput>X(&)[proto::N]</computeroutput>. </para></listitem>
+<listitem><para><computeroutput>A</computeroutput> is <computeroutput>X[M]</computeroutput> or <computeroutput>X(&)[M]</computeroutput> and <computeroutput>B</computeroutput> is <computeroutput>X*</computeroutput>. </para></listitem>
+<listitem><para><computeroutput>B</computeroutput> lambda-matches <computeroutput>A</computeroutput> (see below).</para></listitem>
+</itemizedlist>
+A type <computeroutput>B</computeroutput> lambda-matches <computeroutput>A</computeroutput> one of the following is true:</para><para><itemizedlist>
+<listitem><para><computeroutput>B</computeroutput> is <computeroutput>A</computeroutput> </para></listitem>
+<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="_"><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
@@ -1054,7 +1049,9 @@
           <template-type-parameter name="Expr"/>
           <template-type-parameter name="State"/>
           <template-type-parameter name="Visitor"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name=""><paramtype>State const &</paramtype></parameter><parameter name=""><paramtype>Visitor &</paramtype></parameter></method></method-group></struct></namespace></namespace></namespace></header><header name="boost/xpressive/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><parameter name="expr"><paramtype>Expr const &</paramtype><description><para>An expression </para></description></parameter><parameter name=""><paramtype>State const &</paramtype></parameter><parameter name=""><paramtype>Visitor &</paramtype></parameter><description><para>
+
+</para></description><returns><para>expr </para></returns></method></method-group></struct></namespace></namespace></namespace></header><header name="boost/xpressive/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><namespace name="exprns_"><function name="operator+"><type><emphasis>unspecified</emphasis></type><template>
           <template-type-parameter name="Arg"/>
@@ -1460,12 +1457,10 @@
           <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></namespace></header><header name="boost/xpressive/proto/proto.hpp"><para>The proto expression template compiler and supporting utilities. </para></header><header name="boost/xpressive/proto/proto_fwd.hpp"><para>Forward declarations of all of proto's public types and functions. </para><namespace name="boost"><namespace name="proto"><namespace name="context"/><namespace name="control"><data-member name="N"><type>int const</type></data-member></namespace><namespace name="domainns_"/><namespace name="exops"/><namespace name="exprns_"/><namespace name="functional"><typedef name="make_terminal"><type><classname>make_expr</classname>< <classname>tag::terminal</classname> ></type></typedef><typedef nam
e="make_posit"><type><classname>make_expr</classname>< <classname>tag::posit</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> &g
t;</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>< <classna
me>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>< <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><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><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::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="generatorns_"/><namespace name="op"/><namespace name="refns_"/><namespace name="result_of"/><namespace name="tag"/><namespace name="transform"><struct name="callable"><typedef
name="proto_is_callable_"><type>void</type></typedef></struct><typedef name="arg0"><type><classname>arg_c</classname>< 0 ></type></typedef><typedef name="arg1"><type><classname>arg_c</classname>< 1 ></type></typedef><typedef name="arg2"><type><classname>arg_c</classname>< 2 ></type></typedef><typedef name="arg3"><type><classname>arg_c</classname>< 3 ></type></typedef><typedef name="arg4"><type><classname>arg_c</classname>< 4 ></type></typedef><typedef name="arg5"><type><classname>arg_c</classname>< 5 ></type></typedef><typedef name="arg6"><type><classname>arg_c</classname>< 6 ></type></typedef><typedef name="arg7"><type><classname>arg_c</classname>< 7 ></type></typedef><typedef name="arg8"><type><classname>arg_c</classname>< 8 ></type></typedef><typedef name="arg9"><type><classname>arg_c</classname>< 9 ></type></typedef><typedef name="arg"><type><classname>arg0</classname></type></typedef><typedef name="left"><type><classname>arg0</classname></type>
</typedef><typedef name="right"><type><classname>arg1</classname></type></typedef></namespace><namespace name="utility"/><namespace name="wildcardns_"/><typedef name="_make_terminal"><type><classname>functional::make_terminal</classname></type></typedef><typedef name="_make_posit"><type><classname>functional::make_posit</classname></type></typedef><typedef name="_make_negate"><type><classname>functional::make_negate</classname></type></typedef><typedef name="_make_dereference"><type><classname>functional::make_dereference</classname></type></typedef><typedef name="_make_complement"><type><classname>functional::make_complement</classname></type></typedef><typedef name="_make_address_of"><type><classname>functional::make_address_of</classname></type></typedef><typedef name="_make_logical_not"><type><classname>functional::make_logical_not</classname></type></typedef><typedef name="_make_pre_inc"><type><classname>functional::make_pre_inc</classname></type></typedef><typedef name="_make_pre_dec"><type><classname>
functional::make_pre_dec</classname></type></typedef><typedef name="_make_post_inc"><type><classname>functional::make_post_inc</classname></type></typedef><typedef name="_make_post_dec"><type><classname>functional::make_post_dec</classname></type></typedef><typedef name="_make_shift_left"><type><classname>functional::make_shift_left</classname></type></typedef><typedef name="_make_shift_right"><type><classname>functional::make_shift_right</classname></type></typedef><typedef name="_make_multiplies"><type><classname>functional::make_multiplies</classname></type></typedef><typedef name="_make_divides"><type><classname>functional::make_divides</classname></type></typedef><typedef name="_make_modulus"><type><classname>functional::make_modulus</classname></type></typedef><typedef name="_make_plus"><type><classname>functional::make_plus</classname></type></typedef><typedef name="_make_minus"><type><classname>functional::make_minus</classname></type></typedef><typedef name="_make_less"><type><classname>functional::
make_less</classname></type></typedef><typedef name="_make_greater"><type><classname>functional::make_greater</classname></type></typedef><typedef name="_make_less_equal"><type><classname>functional::make_less_equal</classname></type></typedef><typedef name="_make_greater_equal"><type><classname>functional::make_greater_equal</classname></type></typedef><typedef name="_make_equal_to"><type><classname>functional::make_equal_to</classname></type></typedef><typedef name="_make_not_equal_to"><type><classname>functional::make_not_equal_to</classname></type></typedef><typedef name="_make_logical_or"><type><classname>functional::make_logical_or</classname></type></typedef><typedef name="_make_logical_and"><type><classname>functional::make_logical_and</classname></type></typedef><typedef name="_make_bitwise_and"><type><classname>functional::make_bitwise_and</classname></type></typedef><typedef name="_make_bitwise_or"><type><classname>functional::make_bitwise_or</classname></type></typedef><typedef name="_make_bitwis
e_xor"><type><classname>functional::make_bitwise_xor</classname></type></typedef><typedef name="_make_comma"><type><classname>functional::make_comma</classname></type></typedef><typedef name="_make_mem_ptr"><type><classname>functional::make_mem_ptr</classname></type></typedef><typedef name="_make_assign"><type><classname>functional::make_assign</classname></type></typedef><typedef name="_make_shift_left_assign"><type><classname>functional::make_shift_left_assign</classname></type></typedef><typedef name="_make_shift_right_assign"><type><classname>functional::make_shift_right_assign</classname></type></typedef><typedef name="_make_multiplies_assign"><type><classname>functional::make_multiplies_assign</classname></type></typedef><typedef name="_make_divides_assign"><type><classname>functional::make_divides_assign</classname></type></typedef><typedef name="_make_modulus_assign"><type><classname>functional::make_modulus_assign</classname></type></typedef><typedef name="_make_plus_assign"><type><classname>functio
nal::make_plus_assign</classname></type></typedef><typedef name="_make_minus_assign"><type><classname>functional::make_minus_assign</classname></type></typedef><typedef name="_make_bitwise_and_assign"><type><classname>functional::make_bitwise_and_assign</classname></type></typedef><typedef name="_make_bitwise_or_assign"><type><classname>functional::make_bitwise_or_assign</classname></type></typedef><typedef name="_make_bitwise_xor_assign"><type><classname>functional::make_bitwise_xor_assign</classname></type></typedef><typedef name="_make_subscript"><type><classname>functional::make_subscript</classname></type></typedef><typedef name="_make_if_else"><type><classname>functional::make_if_else</classname></type></typedef><typedef name="_make_function"><type><classname>functional::make_function</classname></type></typedef><typedef name="_flatten"><type><classname>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::deep_copy</classname></type></typedef><typedef name="_deep_copy"><type><classname>functional::deep_copy</classname></type></typedef><typedef name="_expr"><type><classname>transform::expr</classname></type></typedef><typedef name="_state"><type><classname>transform::state</classname></type></typedef><typedef name="_visitor"><type><classname>transform::visitor</classname></type></typedef><typedef name="_arg0"><type><classname>transform::arg0</classname></type></typedef><typedef name="_arg1"><type><classname>transform::arg1</classname></type></typedef><typedef name="_arg2"><type><classname>transform::arg2</classname></type></typedef><typedef name="_arg3"><type><classname>transform::arg3</classname></type></typedef><typedef name="_arg4"><type><classname>transform::arg4</classname></type></typedef><typedef name="_arg5"><type><classname>transform::arg5</classname></type></typedef><typ
edef name="_arg6"><type><classname>transform::arg6</classname></type></typedef><typedef name="_arg7"><type><classname>transform::arg7</classname></type></typedef><typedef name="_arg8"><type><classname>transform::arg8</classname></type></typedef><typedef name="_arg9"><type><classname>transform::arg9</classname></type></typedef><typedef name="_arg"><type><classname>transform::arg</classname></type></typedef><typedef name="_left"><type><classname>transform::left</classname></type></typedef><typedef name="_right"><type><classname>transform::right</classname></type></typedef></namespace></namespace></header><header name="boost/xpressive/proto/ref.hpp"><para>Utility for storing a sub-expr by reference </para><namespace name="boost"><namespace name="proto"><namespace name="functional"><struct name="unref"><struct name="result"><template>
- <template-type-parameter name="T"/>
- </template></struct><struct-specialization name="result"><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></namespace></header><header name="boost/xpressive/proto/proto.hpp"><para>The proto expression template compiler and supporting utilities. </para></header><header name="boost/xpressive/proto/proto_fwd.hpp"><para>Forward declarations of all of proto's public types and functions. </para><namespace name="boost"><namespace name="proto"><namespace name="context"/><namespace name="control"><data-member name="N"><type>int const</type></data-member></namespace><namespace name="domainns_"/><namespace name="exops"/><namespace name="exprns_"/><namespace name="functional"><typedef name="make_terminal"><type><classname>make_expr</classname>< <classname>tag::terminal</classname> ></type></typedef><typedef nam
e="make_posit"><type><classname>make_expr</classname>< <classname>tag::posit</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> &g
t;</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>< <classna
me>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>< <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><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><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::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="generatorns_"/><namespace name="op"/><namespace name="refns_"/><namespace name="result_of"/><namespace name="tag"/><namespace name="transform"><struct name="callable"><typedef
name="proto_is_callable_"><type>void</type></typedef></struct><typedef name="arg0"><type><classname>arg_c</classname>< 0 ></type></typedef><typedef name="arg1"><type><classname>arg_c</classname>< 1 ></type></typedef><typedef name="arg2"><type><classname>arg_c</classname>< 2 ></type></typedef><typedef name="arg3"><type><classname>arg_c</classname>< 3 ></type></typedef><typedef name="arg4"><type><classname>arg_c</classname>< 4 ></type></typedef><typedef name="arg5"><type><classname>arg_c</classname>< 5 ></type></typedef><typedef name="arg6"><type><classname>arg_c</classname>< 6 ></type></typedef><typedef name="arg7"><type><classname>arg_c</classname>< 7 ></type></typedef><typedef name="arg8"><type><classname>arg_c</classname>< 8 ></type></typedef><typedef name="arg9"><type><classname>arg_c</classname>< 9 ></type></typedef><typedef name="arg"><type><classname>arg0</classname></type></typedef><typedef name="left"><type><classname>arg0</classname></type>
</typedef><typedef name="right"><type><classname>arg1</classname></type></typedef></namespace><namespace name="utility"/><namespace name="wildcardns_"/><typedef name="_make_terminal"><type><classname>functional::make_terminal</classname></type></typedef><typedef name="_make_posit"><type><classname>functional::make_posit</classname></type></typedef><typedef name="_make_negate"><type><classname>functional::make_negate</classname></type></typedef><typedef name="_make_dereference"><type><classname>functional::make_dereference</classname></type></typedef><typedef name="_make_complement"><type><classname>functional::make_complement</classname></type></typedef><typedef name="_make_address_of"><type><classname>functional::make_address_of</classname></type></typedef><typedef name="_make_logical_not"><type><classname>functional::make_logical_not</classname></type></typedef><typedef name="_make_pre_inc"><type><classname>functional::make_pre_inc</classname></type></typedef><typedef name="_make_pre_dec"><type><classname>
functional::make_pre_dec</classname></type></typedef><typedef name="_make_post_inc"><type><classname>functional::make_post_inc</classname></type></typedef><typedef name="_make_post_dec"><type><classname>functional::make_post_dec</classname></type></typedef><typedef name="_make_shift_left"><type><classname>functional::make_shift_left</classname></type></typedef><typedef name="_make_shift_right"><type><classname>functional::make_shift_right</classname></type></typedef><typedef name="_make_multiplies"><type><classname>functional::make_multiplies</classname></type></typedef><typedef name="_make_divides"><type><classname>functional::make_divides</classname></type></typedef><typedef name="_make_modulus"><type><classname>functional::make_modulus</classname></type></typedef><typedef name="_make_plus"><type><classname>functional::make_plus</classname></type></typedef><typedef name="_make_minus"><type><classname>functional::make_minus</classname></type></typedef><typedef name="_make_less"><type><classname>functional::
make_less</classname></type></typedef><typedef name="_make_greater"><type><classname>functional::make_greater</classname></type></typedef><typedef name="_make_less_equal"><type><classname>functional::make_less_equal</classname></type></typedef><typedef name="_make_greater_equal"><type><classname>functional::make_greater_equal</classname></type></typedef><typedef name="_make_equal_to"><type><classname>functional::make_equal_to</classname></type></typedef><typedef name="_make_not_equal_to"><type><classname>functional::make_not_equal_to</classname></type></typedef><typedef name="_make_logical_or"><type><classname>functional::make_logical_or</classname></type></typedef><typedef name="_make_logical_and"><type><classname>functional::make_logical_and</classname></type></typedef><typedef name="_make_bitwise_and"><type><classname>functional::make_bitwise_and</classname></type></typedef><typedef name="_make_bitwise_or"><type><classname>functional::make_bitwise_or</classname></type></typedef><typedef name="_make_bitwis
e_xor"><type><classname>functional::make_bitwise_xor</classname></type></typedef><typedef name="_make_comma"><type><classname>functional::make_comma</classname></type></typedef><typedef name="_make_mem_ptr"><type><classname>functional::make_mem_ptr</classname></type></typedef><typedef name="_make_assign"><type><classname>functional::make_assign</classname></type></typedef><typedef name="_make_shift_left_assign"><type><classname>functional::make_shift_left_assign</classname></type></typedef><typedef name="_make_shift_right_assign"><type><classname>functional::make_shift_right_assign</classname></type></typedef><typedef name="_make_multiplies_assign"><type><classname>functional::make_multiplies_assign</classname></type></typedef><typedef name="_make_divides_assign"><type><classname>functional::make_divides_assign</classname></type></typedef><typedef name="_make_modulus_assign"><type><classname>functional::make_modulus_assign</classname></type></typedef><typedef name="_make_plus_assign"><type><classname>functio
nal::make_plus_assign</classname></type></typedef><typedef name="_make_minus_assign"><type><classname>functional::make_minus_assign</classname></type></typedef><typedef name="_make_bitwise_and_assign"><type><classname>functional::make_bitwise_and_assign</classname></type></typedef><typedef name="_make_bitwise_or_assign"><type><classname>functional::make_bitwise_or_assign</classname></type></typedef><typedef name="_make_bitwise_xor_assign"><type><classname>functional::make_bitwise_xor_assign</classname></type></typedef><typedef name="_make_subscript"><type><classname>functional::make_subscript</classname></type></typedef><typedef name="_make_if_else"><type><classname>functional::make_if_else</classname></type></typedef><typedef name="_make_function"><type><classname>functional::make_function</classname></type></typedef><typedef name="_flatten"><type><classname>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::deep_copy</classname></type></typedef><typedef name="_deep_copy"><type><classname>functional::deep_copy</classname></type></typedef><typedef name="_expr"><type><classname>transform::expr</classname></type></typedef><typedef name="_state"><type><classname>transform::state</classname></type></typedef><typedef name="_visitor"><type><classname>transform::visitor</classname></type></typedef><typedef name="_arg0"><type><classname>transform::arg0</classname></type></typedef><typedef name="_arg1"><type><classname>transform::arg1</classname></type></typedef><typedef name="_arg2"><type><classname>transform::arg2</classname></type></typedef><typedef name="_arg3"><type><classname>transform::arg3</classname></type></typedef><typedef name="_arg4"><type><classname>transform::arg4</classname></type></typedef><typedef name="_arg5"><type><classname>transform::arg5</classname></type></typedef><typ
edef name="_arg6"><type><classname>transform::arg6</classname></type></typedef><typedef name="_arg7"><type><classname>transform::arg7</classname></type></typedef><typedef name="_arg8"><type><classname>transform::arg8</classname></type></typedef><typedef name="_arg9"><type><classname>transform::arg9</classname></type></typedef><typedef name="_arg"><type><classname>transform::arg</classname></type></typedef><typedef name="_left"><type><classname>transform::left</classname></type></typedef><typedef name="_right"><type><classname>transform::right</classname></type></typedef></namespace></namespace></header><header name="boost/xpressive/proto/ref.hpp"><para>Utility for storing a sub-expr by reference </para><namespace name="boost"><namespace name="proto"><namespace name="functional"><struct name="unref"><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::result_of::unref< T ></inherit></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>T &</type><template>
+ </template><specialization><template-arg>This(T)</template-arg></specialization><inherit access="public">boost::proto::result_of::unref< boost::remove_const< boost::remove_reference< T >::type >::type ></inherit></struct-specialization><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></parameter></method><method name="operator()" cv="const"><type>T const &</type><template>
           <template-type-parameter name="T"/>
@@ -1475,7 +1470,7 @@
           <template-type-parameter name="T"/>
         </template><parameter name="t"><paramtype>ref_< T > const &</paramtype></parameter></method></method-group></struct></namespace><namespace name="refns_"><struct name="ref_"><template>
       <template-type-parameter name="Expr"/>
- </template><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_arg0"><type>Expr::proto_arg0</type></typedef><typedef name="proto_arg1"><type>Expr::proto_arg1</type></typedef><typedef name="proto_arg2"><type>Expr::proto_arg2</type></typedef><typedef name="proto_arg3"><type>Expr::proto_arg3</type></typedef><typedef name="proto_arg4"><type>Expr::proto_arg4</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::i
f_< is_const < Expr >, 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><struct-specialization name="ref_"><template>
+ </template><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_arg0"><type>Expr::proto_arg0</type></typedef><typedef name="proto_arg1"><type>Expr::proto_arg1</type></typedef><typedef name="proto_arg2"><type>Expr::proto_arg2</type></typedef><typedef name="proto_arg3"><type>Expr::proto_arg3</type></typedef><typedef name="proto_arg4"><type>Expr::proto_arg4</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::i
f_< is_const< Expr >, 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><struct-specialization name="ref_"><template>
       <template-type-parameter name="Expr"/>
     </template><specialization><template-arg>ref_< Expr ></template-arg></specialization></struct-specialization></namespace><namespace name="result_of"><struct name="unref"><template>
       <template-type-parameter name="T"/>
@@ -1491,17 +1486,13 @@
       <template-type-parameter name="T"/>
     </template></struct><struct name="is_aggregate"><template>
       <template-type-parameter name="T"/>
- </template><description><para>is_aggregate </para></description></struct><struct-specialization name="is_callable"><template>
- </template><specialization><template-arg>proto::_</template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><struct-specialization name="is_callable"><template>
- </template><specialization><template-arg>proto::callable</template-arg></specialization><inherit access="public">boost::mpl::false_</inherit></struct-specialization><struct-specialization name="is_aggregate"><template>
+ </template><description><para>is_aggregate </para></description></struct><struct-specialization name="is_aggregate"><template>
       <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></struct-specialization><namespace name="functional"><struct name="as_expr"><template>
       <template-type-parameter name="Domain"/>
- </template><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><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::result_of::as_expr< remove_reference< T >::type, Domain ></inherit></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result_of::as_expr</classname>< T, Domain >::result_type</type><template>
@@ -1510,9 +1501,7 @@
           <template-type-parameter name="T"/>
         </template><parameter name="t"><paramtype>T const &</paramtype></parameter></method></method-group></struct><struct name="as_arg"><template>
       <template-type-parameter name="Domain"/>
- </template><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><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::result_of::as_arg< remove_reference< T >::type, Domain ></inherit></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result_of::as_arg</classname>< T, Domain >::type</type><template>
@@ -1521,9 +1510,7 @@
           <template-type-parameter name="T"/>
         </template><parameter name="t"><paramtype>T const &</paramtype></parameter></method></method-group></struct><struct name="arg_c"><template>
       <template-nontype-parameter name="N"><type>long</type></template-nontype-parameter>
- </template><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
     </template><specialization><template-arg>This(Expr)</template-arg></specialization></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result_of::arg_c< Expr, N >::reference</type><template>
@@ -1532,38 +1519,30 @@
           <template-type-parameter name="Expr"/>
         </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></method></method-group></struct><struct name="arg"><template>
       <template-type-parameter name="N"/>
- </template><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
- </template><specialization><template-arg>This(Expr)</template-arg></specialization><inherit access="public">boost::proto::result_of::arg< boost::remove_const < boost::remove_reference< Expr >::type >::type, N ></inherit></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result_of::arg</classname>< Expr, N >::reference</type><template>
+ </template><specialization><template-arg>This(Expr)</template-arg></specialization><inherit access="public">boost::proto::result_of::arg< boost::remove_const< boost::remove_reference< Expr >::type >::type, N ></inherit></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result_of::arg</classname>< Expr, N >::reference</type><template>
           <template-type-parameter name="Expr"/>
         </template><parameter name="expr"><paramtype>Expr &</paramtype></parameter></method><method name="operator()" cv="const"><type><classname>result_of::arg</classname>< Expr, N >::const_reference</type><template>
           <template-type-parameter name="Expr"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></method></method-group></struct><struct name="left"><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></method></method-group></struct><struct name="left"><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
- </template><specialization><template-arg>This(Expr)</template-arg></specialization><inherit access="public">boost::proto::result_of::left< boost::remove_const < boost::remove_reference< Expr >::type >::type ></inherit></struct-specialization><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><inherit access="public">boost::proto::result_of::left< boost::remove_const< boost::remove_reference< Expr >::type >::type ></inherit></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result_of::left</classname>< Expr >::reference</type><template>
           <template-type-parameter name="Expr"/>
         </template><parameter name="expr"><paramtype>Expr &</paramtype></parameter></method><method name="operator()" cv="const"><type><classname>result_of::left</classname>< Expr >::const_reference</type><template>
           <template-type-parameter name="Expr"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></method></method-group></struct><struct name="right"><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></method></method-group></struct><struct name="right"><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
- </template><specialization><template-arg>This(Expr)</template-arg></specialization><inherit access="public">boost::proto::result_of::right< Expr ></inherit></struct-specialization><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><inherit access="public">boost::proto::result_of::right< boost::remove_const< boost::remove_reference< Expr >::type >::type ></inherit></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type><classname>result_of::right</classname>< Expr >::reference</type><template>
           <template-type-parameter name="Expr"/>
         </template><parameter name="expr"><paramtype>Expr &</paramtype></parameter></method><method name="operator()" cv="const"><type><classname>result_of::right</classname>< Expr >::const_reference</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><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
@@ -1747,10 +1726,14 @@
     </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><typedef name="proto_is_callable_"><type>int</type></typedef><typedef name="type"><type>proto::expr< Tag, <classname>args5</classname>< A0, A1, A2, A3, A4 > ></type></typedef><typedef name="proto_base_expr"><type>type</type></typedef><typedef name="proto_tag"><type>Tag</type></typedef><typedef name="proto_arg0"><type>A0</type></typedef><typedef name="proto_arg1"><type>A1</type></typedef><typedef name="proto_arg2"><type>A2</type></typedef><typedef name="proto_arg3"><type>A3</type></typedef><typedef name="proto_arg4"><type>A4</type></typedef></struct-specialization></namespace><namespace name="result_of"><struct name="is_ref"><template>
       <template-type-parameter name="T"/>
       <template-type-parameter name="EnableIf"/>
- </template><inherit access="public">boost::mpl::false_</inherit></struct><struct name="is_expr"><template>
+ </template><inherit access="public">boost::mpl::false_</inherit></struct><struct-specialization name="is_ref"><template>
+ <template-type-parameter name="T"/>
+ </template><specialization><template-arg>T</template-arg><template-arg>typename T::proto_is_ref_</template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><struct name="is_expr"><template>
       <template-type-parameter name="T"/>
       <template-type-parameter name="EnableIf"/>
- </template><inherit access="public">boost::mpl::false_</inherit></struct><struct name="tag_of"><template>
+ </template><inherit access="public">boost::mpl::false_</inherit></struct><struct-specialization name="is_expr"><template>
+ <template-type-parameter name="T"/>
+ </template><specialization><template-arg>T</template-arg><template-arg>typename T::proto_is_expr_</template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><struct name="tag_of"><template>
       <template-type-parameter name="Expr"/>
     </template><typedef name="type"><type>Expr::proto_tag</type></typedef></struct><struct name="as_expr"><template>
       <template-type-parameter name="T"/>
@@ -1758,13 +1741,23 @@
       <template-type-parameter name="EnableIf"/>
     </template><typedef name="proto_arg0"><type>mpl::eval_if< mpl::or_< boost::is_array< T >, is_function< T > >, add_reference< T >, remove_cv< T >>::type</type></typedef><typedef name="expr_type"><type>proto::expr< <classname>proto::tag::terminal</classname>, <classname>args0</classname>< proto_arg0 > ></type></typedef><typedef name="type"><type>Domain::template apply< expr_type >::type</type></typedef><typedef name="result_type"><type>type const</type></typedef><method-group name="public static functions"><method name="call" cv=""><type>static result_type</type><template>
           <template-type-parameter name="T2"/>
- </template><parameter name="t"><paramtype>T2 &</paramtype></parameter></method></method-group></struct><struct name="as_arg"><template>
+ </template><parameter name="t"><paramtype>T2 &</paramtype></parameter></method></method-group></struct><struct-specialization name="as_expr"><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><typedef name="type"><type>T::proto_derived_expr</type></typedef><typedef name="result_type"><type>T &</type></typedef><method-group name="public static functions"><method name="call" cv=""><type>static result_type</type><template>
+ <template-type-parameter name="T2"/>
+ </template><parameter name="t"><paramtype>T2 &</paramtype></parameter></method></method-group></struct-specialization><struct name="as_arg"><template>
       <template-type-parameter name="T"/>
       <template-type-parameter name="Domain"/>
       <template-type-parameter name="EnableIf"/>
     </template><typedef name="expr_type"><type>proto::expr< <classname>proto::tag::terminal</classname>, <classname>args0</classname>< T & > ></type></typedef><typedef name="type"><type>Domain::template apply< expr_type >::type</type></typedef><method-group name="public static functions"><method name="call" cv=""><type>static type</type><template>
           <template-type-parameter name="T2"/>
- </template><parameter name="t"><paramtype>T2 &</paramtype></parameter></method></method-group></struct><struct name="arg"><template>
+ </template><parameter name="t"><paramtype>T2 &</paramtype></parameter></method></method-group></struct><struct-specialization name="as_arg"><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><typedef name="type"><type>ref_< T ></type></typedef><method-group name="public static functions"><method name="call" cv=""><type>static type</type><template>
+ <template-type-parameter name="T2"/>
+ </template><parameter name="t"><paramtype>T2 &</paramtype></parameter></method></method-group></struct-specialization><struct name="arg"><template>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="N"/>
     </template></struct><struct name="left"><template>
@@ -1795,21 +1788,7 @@
       <template-type-parameter name="Expr"/>
     </template><specialization><template-arg>Expr</template-arg><template-arg>5</template-arg></specialization><typedef name="wrapped_type"><type>Expr::proto_arg5</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><method-group name="public static functions"/></struct-specialization><struct-specialization name="arg_c"><template>
       <template-type-parameter name="Expr"/>
- </template><specialization><template-arg>Expr const</template-arg><template-arg>5</template-arg></specialization><inherit access="public">boost::proto::result_of::arg_c< Expr, 5 ></inherit></struct-specialization><struct-specialization name="is_ref"><template>
- <template-type-parameter name="T"/>
- </template><specialization><template-arg>T</template-arg><template-arg>typename T::proto_is_ref_</template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><struct-specialization name="is_expr"><template>
- <template-type-parameter name="T"/>
- </template><specialization><template-arg>T</template-arg><template-arg>typename T::proto_is_expr_</template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><struct-specialization name="as_expr"><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><typedef name="type"><type>T::proto_derived_expr</type></typedef><typedef name="result_type"><type>T &</type></typedef><method-group name="public static functions"><method name="call" cv=""><type>static result_type</type><template>
- <template-type-parameter name="T2"/>
- </template><parameter name="t"><paramtype>T2 &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="as_arg"><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><typedef name="type"><type>ref_< T ></type></typedef><method-group name="public static functions"><method name="call" cv=""><type>static type</type><template>
- <template-type-parameter name="T2"/>
- </template><parameter name="t"><paramtype>T2 &</paramtype></parameter></method></method-group></struct-specialization></namespace><data-member name="left"><type><classname>functional::left</classname> const</type></data-member><data-member name="right"><type><classname>functional::right</classname> const</type></data-member><function name="implicit_expr"><type><emphasis>unspecified</emphasis></type><template>
+ </template><specialization><template-arg>Expr const</template-arg><template-arg>5</template-arg></specialization><inherit access="public">boost::proto::result_of::arg_c< Expr, 5 ></inherit></struct-specialization></namespace><data-member name="left"><type><classname>functional::left</classname> const</type></data-member><data-member name="right"><type><classname>functional::right</classname> const</type></data-member><function name="implicit_expr"><type><emphasis>unspecified</emphasis></type><template>
           <template-type-parameter name="A0"/>
         </template><parameter name="a0"><paramtype>A0 &</paramtype></parameter></function><function name="implicit_expr"><type><emphasis>unspecified</emphasis></type><template>
           <template-type-parameter name="A0"/>
@@ -1831,17 +1810,17 @@
           <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></function><overloaded-function name="as_expr"><signature><type><classname>result_of::as_expr</classname>< T >::result_type</type><template>
           <template-type-parameter name="T"/>
- </template><parameter name="t"><paramtype>T &</paramtype></parameter></signature><signature><type><classname>result_of::as_expr</classname>< T const >::result_type</type><template>
+ </template><parameter name="t"><paramtype>T &</paramtype></parameter></signature><signature><type><classname>result_of::as_expr</classname>< T const >::result_type</type><template>
           <template-type-parameter name="T"/>
- </template><parameter name="t"><paramtype>T const &</paramtype></parameter></signature><description><para>as_expr </para></description></overloaded-function><overloaded-function name="as_arg"><signature><type><classname>result_of::as_arg</classname>< T >::type</type><template>
+ </template><parameter name="t"><paramtype>T const &</paramtype></parameter></signature><description><para>as_expr</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="as_arg"><signature><type><classname>result_of::as_arg</classname>< T >::type</type><template>
           <template-type-parameter name="T"/>
- </template><parameter name="t"><paramtype>T &</paramtype></parameter></signature><signature><type><classname>result_of::as_arg</classname>< T const >::type</type><template>
+ </template><parameter name="t"><paramtype>T &</paramtype></parameter></signature><signature><type><classname>result_of::as_arg</classname>< T const >::type</type><template>
           <template-type-parameter name="T"/>
- </template><parameter name="t"><paramtype>T const &</paramtype></parameter></signature><description><para>as_arg </para></description></overloaded-function><overloaded-function name="arg"><signature><type><classname>result_of::unref</classname>< typename Expr::proto_base_expr::proto_arg0 >::reference</type><template>
+ </template><parameter name="t"><paramtype>T const &</paramtype></parameter></signature><description><para>as_arg</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="arg"><signature><type><classname>result_of::unref</classname>< typename Expr::proto_base_expr::proto_arg0 >::reference</type><template>
           <template-type-parameter name="Expr"/>
         </template><parameter name="expr"><paramtype>Expr &</paramtype></parameter></signature><signature><type><classname>result_of::unref</classname>< typename Expr::proto_base_expr::proto_arg0 >::const_reference</type><template>
           <template-type-parameter name="Expr"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></signature><description><para>arg </para></description></overloaded-function><overloaded-function name="arg_c"><signature><type>result_of::arg_c< Expr, N >::reference</type><template>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></signature><description><para>arg</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="arg_c"><signature><type>result_of::arg_c< Expr, N >::reference</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></parameter></signature><signature><type>result_of::arg_c< Expr, N >::const_reference</type><template>
@@ -1849,17 +1828,7 @@
           <template-type-parameter name="Expr"/>
         </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter></signature><description><para>arg_c </para></description></overloaded-function></namespace></namespace></header><header name="boost/xpressive/proto/transform.hpp"><para>Includes all the transforms in the transform/ sub-directory. </para></header><header name="boost/xpressive/proto/transform/arg.hpp"><para>Contains definition of the argN transforms. </para><namespace name="boost"><namespace name="proto"><struct name="_arg_c"><template>
       <template-nontype-parameter name="I"><type>int</type></template-nontype-parameter>
- </template><inherit access="public">boost::proto::transform::arg_c< I ></inherit></struct><struct-specialization name="is_callable"><template>
- <template-nontype-parameter name="I"><type>int</type></template-nontype-parameter>
- </template><specialization><template-arg>_arg_c< I ></template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><struct-specialization name="is_callable"><template>
- </template><specialization><template-arg>transform::expr</template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><struct-specialization name="is_callable"><template>
- </template><specialization><template-arg>transform::state</template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><struct-specialization name="is_callable"><template>
- </template><specialization><template-arg>transform::visitor</template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><struct-specialization name="is_callable"><template>
- <template-nontype-parameter name="I"><type>int</type></template-nontype-parameter>
- </template><specialization><template-arg>transform::arg_c< I ></template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><struct-specialization name="is_callable"><template>
- </template><specialization><template-arg>transform::_ref</template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><namespace name="transform"><struct name="expr"><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><inherit access="public">boost::proto::transform::arg_c< I ></inherit></struct><namespace name="transform"><struct name="expr"><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
@@ -1868,9 +1837,7 @@
           <template-type-parameter name="Expr"/>
           <template-type-parameter name="State"/>
           <template-type-parameter name="Visitor"/>
- </template><parameter name="expr_"><paramtype>Expr const &</paramtype></parameter><parameter name=""><paramtype>State const &</paramtype></parameter><parameter name=""><paramtype>Visitor &</paramtype></parameter></method></method-group></struct><struct name="state"><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><parameter name="expr_"><paramtype>Expr const &</paramtype></parameter><parameter name=""><paramtype>State const &</paramtype></parameter><parameter name=""><paramtype>Visitor &</paramtype></parameter></method></method-group></struct><struct name="state"><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
@@ -1879,9 +1846,7 @@
           <template-type-parameter name="Expr"/>
           <template-type-parameter name="State"/>
           <template-type-parameter name="Visitor"/>
- </template><parameter name=""><paramtype>Expr const &</paramtype></parameter><parameter name="state_"><paramtype>State const &</paramtype></parameter><parameter name=""><paramtype>Visitor &</paramtype></parameter></method></method-group></struct><struct name="visitor"><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><parameter name=""><paramtype>Expr const &</paramtype></parameter><parameter name="state_"><paramtype>State const &</paramtype></parameter><parameter name=""><paramtype>Visitor &</paramtype></parameter></method></method-group></struct><struct name="visitor"><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
@@ -1892,9 +1857,7 @@
           <template-type-parameter name="Visitor"/>
         </template><parameter name=""><paramtype>Expr const &</paramtype></parameter><parameter name=""><paramtype>State const &</paramtype></parameter><parameter name="visitor_"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct><struct name="arg_c"><template>
       <template-nontype-parameter name="I"><type>int</type></template-nontype-parameter>
- </template><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
@@ -1903,336 +1866,362 @@
           <template-type-parameter name="Expr"/>
           <template-type-parameter name="State"/>
           <template-type-parameter name="Visitor"/>
- </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name=""><paramtype>State const &</paramtype></parameter><parameter name=""><paramtype>Visitor &</paramtype></parameter></method></method-group></struct><struct name="_ref"><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name=""><paramtype>State const &</paramtype></parameter><parameter name=""><paramtype>Visitor &</paramtype></parameter></method></method-group></struct><struct name="_ref"><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-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 ></type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>boost::reference_wrapper< T ></type><template>
           <template-type-parameter name="T"/>
- </template><parameter name="t"><paramtype>T &</paramtype></parameter></method><method name="operator()" cv="const"><type>boost::reference_wrapper< T const ></type><template>
+ </template><parameter name="t"><paramtype>T &</paramtype></parameter></method><method name="operator()" cv="const"><type>boost::reference_wrapper< T const ></type><template>
           <template-type-parameter name="T"/>
- </template><parameter name="t"><paramtype>T const &</paramtype></parameter></method></method-group></struct></namespace></namespace></namespace></header><header name="boost/xpressive/proto/transform/bind.hpp"><para>Contains definition of the bind<> transform. </para><namespace name="boost"><namespace name="proto"><struct-specialization name="is_callable"><template>
+ </template><parameter name="t"><paramtype>T const &</paramtype></parameter></method></method-group></struct></namespace></namespace></namespace></header><header name="boost/xpressive/proto/transform/bind.hpp"><para>Contains definition of the bind<> transform. </para><namespace name="boost"><namespace name="proto"><namespace name="transform"><struct name="bind"><template>
       <template-type-parameter name="Fun"/>
- </template><specialization><template-arg>transform::bind< Fun ></template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><namespace name="transform"><struct name="bind"><template>
- <template-type-parameter name="Fun"/>
- </template><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type><classname>call</classname>< typename <classname>make</classname>< <classname>Fun</classname> >::template <classname>result</classname>< void(Expr, State, Visitor) >::type ></type></typedef><typedef name="type"><type>impl::template <classname>result</classname>< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization></struct><struct-specialization name="bind"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type><classname>call</classname>< typename <classname>make</classname>< <classname>Fun</classname> >::template result< void(Expr, State, Visitor) >::type ></type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct><struct-specialization name="bind"><template>
       <template-type-parameter name="Return"/>
- </template><specialization><template-arg>Return()</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Return()</template-arg></specialization><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type><classname>call</classname>< typename <classname>make</classname>< Return >::template result< void(Expr, State, Visitor) >::type() ></type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization></struct-specialization><struct-specialization name="bind"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type><classname>call</classname>< typename <classname>make</classname>< Return >::template result< void(Expr, State, Visitor) >::type() ></type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="bind"><template>
       <template-type-parameter name="Return"/>
       <template-type-parameter name="A0"/>
- </template><specialization><template-arg>Return(A0)</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Return(A0)</template-arg></specialization><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type><classname>call</classname>< typename <classname>make</classname>< Return >::template result< void(Expr, State, Visitor) >::type(A0) ></type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization></struct-specialization><struct-specialization name="bind"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type><classname>call</classname>< typename <classname>make</classname>< Return >::template result< void(Expr, State, Visitor) >::type(A0) ></type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="bind"><template>
       <template-type-parameter name="Return"/>
       <template-type-parameter name="A0"/>
       <template-type-parameter name="A1"/>
- </template><specialization><template-arg>Return(A0</template-arg><template-arg>A1)</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Return(A0</template-arg><template-arg>A1)</template-arg></specialization><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type><classname>call</classname>< typename <classname>make</classname>< Return >::template result< void(Expr, State, Visitor) >::type(A0, A1) ></type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization></struct-specialization><struct-specialization name="bind"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type><classname>call</classname>< typename <classname>make</classname>< Return >::template result< void(Expr, State, Visitor) >::type(A0, A1) ></type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="bind"><template>
       <template-type-parameter name="Return"/>
       <template-type-parameter name="A0"/>
       <template-type-parameter name="A1"/>
       <template-type-parameter name="A2"/>
- </template><specialization><template-arg>Return(A0</template-arg><template-arg>A1</template-arg><template-arg>A2)</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Return(A0</template-arg><template-arg>A1</template-arg><template-arg>A2)</template-arg></specialization><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type><classname>call</classname>< typename <classname>make</classname>< Return >::template result< void(Expr, State, Visitor) >::type(A0, A1, A2) ></type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization></struct-specialization><struct-specialization name="bind"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type><classname>call</classname>< typename <classname>make</classname>< Return >::template result< void(Expr, State, Visitor) >::type(A0, A1, A2) ></type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="bind"><template>
       <template-type-parameter name="Return"/>
       <template-type-parameter name="A0"/>
       <template-type-parameter name="A1"/>
       <template-type-parameter name="A2"/>
       <template-type-parameter name="A3"/>
- </template><specialization><template-arg>Return(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3)</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Return(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3)</template-arg></specialization><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type><classname>call</classname>< typename <classname>make</classname>< Return >::template result< void(Expr, State, Visitor) >::type(A0, A1, A2, A3) ></type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization></struct-specialization><struct-specialization name="bind"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type><classname>call</classname>< typename <classname>make</classname>< Return >::template result< void(Expr, State, Visitor) >::type(A0, A1, A2, A3) ></type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="bind"><template>
       <template-type-parameter name="Return"/>
       <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>Return(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3</template-arg><template-arg>A4)</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Return(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3</template-arg><template-arg>A4)</template-arg></specialization><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type><classname>call</classname>< typename <classname>make</classname>< Return >::template result< void(Expr, State, Visitor) >::type(A0, A1, A2, A3, A4) ></type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization></struct-specialization></namespace></namespace></namespace></header><header name="boost/xpressive/proto/transform/call.hpp"><para>Contains definition of the call<> transform. </para><namespace name="boost"><namespace name="proto"><struct-specialization name="is_callable"><template>
- <template-type-parameter name="Fun"/>
- </template><specialization><template-arg>transform::call< Fun ></template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><namespace name="transform"><struct name="call"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type><classname>call</classname>< typename <classname>make</classname>< Return >::template result< void(Expr, State, Visitor) >::type(A0, A1, A2, A3, A4) ></type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct-specialization></namespace></namespace></namespace></header><header name="boost/xpressive/proto/transform/call.hpp"><para>Contains definition of the call<> transform. </para><namespace name="boost"><namespace name="proto"><namespace name="transform"><struct name="call"><template>
       <template-type-parameter name="Fun"/>
     </template><inherit access="public">Fun</inherit><typedef name="proto_is_callable_"><type>void</type></typedef></struct><struct-specialization name="call"><template>
       <template-type-parameter name="Fun"/>
- </template><specialization><template-arg>Fun()</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Fun()</template-arg></specialization><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization></struct-specialization><struct-specialization name="call"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</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, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="call"><template>
       <template-type-parameter name="Fun"/>
       <template-type-parameter name="Arg0"/>
- </template><specialization><template-arg>Fun(Arg0)</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Fun(Arg0)</template-arg></specialization><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization></struct-specialization><struct-specialization name="call"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</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, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="call"><template>
       <template-type-parameter name="Fun"/>
       <template-type-parameter name="Arg0"/>
       <template-type-parameter name="Arg1"/>
- </template><specialization><template-arg>Fun(Arg0</template-arg><template-arg>Arg1)</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Fun(Arg0</template-arg><template-arg>Arg1)</template-arg></specialization><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization></struct-specialization><struct-specialization name="call"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</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, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="call"><template>
       <template-type-parameter name="Fun"/>
       <template-type-parameter name="Arg0"/>
       <template-type-parameter name="Arg1"/>
       <template-type-parameter name="Arg2"/>
- </template><specialization><template-arg>Fun(Arg0</template-arg><template-arg>Arg1</template-arg><template-arg>Arg2)</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Fun(Arg0</template-arg><template-arg>Arg1</template-arg><template-arg>Arg2)</template-arg></specialization><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type>boost::result_of< <classname>Fun</classname>(typename <classname>when</classname>< _, Arg0 >::template result< void(Expr, State, Visitor) >::type, typename <classname>when</classname>< _, Arg1 >::template result< void(Expr, State, Visitor) >::type, typename <classname>when</classname>< _, Arg2 >::template result< void(Expr, State, Visitor) >::type)>::type</type></typedef></struct-specialization></struct-specialization><struct-specialization name="call"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type>boost::result_of< <classname>Fun</classname>(typename <classname>when</classname>< _, Arg0 >::template result< void(Expr, State, Visitor) >::type, typename <classname>when</classname>< _, Arg1 >::template result< void(Expr, State, Visitor) >::type, typename <classname>when</classname>< _, Arg2 >::template result< void(Expr, State, Visitor) >::type)>::type</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></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><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Fun(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3)</template-arg></specialization><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type>boost::result_of< <classname>Fun</classname>(typename <classname>when</classname>< _, A0 >::template result< void(Expr, State, Visitor) >::type, typename <classname>when</classname>< _, A1 >::template result< void(Expr, State, Visitor) >::type, typename <classname>when</classname>< _, A2 >::template result< void(Expr, State, Visitor) >::type, typename <classname>when</classname>< _, A3 >::template result< void(Expr, State, Visitor) >::type)>::type</type></typedef></struct-specialization></struct-specialization><struct-specialization name="call"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type>boost::result_of< <classname>Fun</classname>(typename <classname>when</classname>< _, A0 >::template result< void(Expr, State, Visitor) >::type, typename <classname>when</classname>< _, A1 >::template result< void(Expr, State, Visitor) >::type, typename <classname>when</classname>< _, A2 >::template result< void(Expr, State, Visitor) >::type, typename <classname>when</classname>< _, A3 >::template result< void(Expr, State, Visitor) >::type)>::type</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></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><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </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><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type>boost::result_of< <classname>Fun</classname>(typename <classname>when</classname>< _, A0 >::template result< void(Expr, State, Visitor) >::type, typename <classname>when</classname>< _, A1 >::template result< void(Expr, State, Visitor) >::type, typename <classname>when</classname>< _, A2 >::template result< void(Expr, State, Visitor) >::type, typename <classname>when</classname>< _, A3 >::template result< void(Expr, State, Visitor) >::type, typename <classname>when</classname>< _, A4 >::template result< void(Expr, State, Visitor) >::type)>::type</type></typedef></struct-specialization></struct-specialization></namespace></namespace></namespace></header><header name="boost/xpressive/proto/transform/fold.hpp"><para>Contains definition of the fold<> and rever
se_fold<> transforms. </para><namespace name="boost"><namespace name="proto"><struct-specialization name="is_callable"><template>
- <template-type-parameter name="Sequence"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Fun"/>
- </template><specialization><template-arg>transform::fold< Sequence</template-arg><template-arg>State</template-arg><template-arg>Fun ></template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><struct-specialization name="is_callable"><template>
- <template-type-parameter name="Sequence"/>
- <template-type-parameter name="State"/>
- <template-type-parameter name="Fun"/>
- </template><specialization><template-arg>transform::reverse_fold< Sequence</template-arg><template-arg>State</template-arg><template-arg>Fun ></template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><namespace name="transform"><struct name="fold"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type>boost::result_of< <classname>Fun</classname>(typename <classname>when</classname>< _, A0 >::template result< void(Expr, State, Visitor) >::type, typename <classname>when</classname>< _, A1 >::template result< void(Expr, State, Visitor) >::type, typename <classname>when</classname>< _, A2 >::template result< void(Expr, State, Visitor) >::type, typename <classname>when</classname>< _, A3 >::template result< void(Expr, State, Visitor) >::type, typename <classname>when</classname>< _, A4 >::template result< void(Expr, State, Visitor) >::type)>::type</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct-specialization></namespace></namespace></namespace></header><header name="boost/xpressive/proto/transform/fold.hpp"><para>Contains definition of the fold<> and reverse_fold<> transforms.</para><para>Contains definition of the fold_tree<> and reverse_fold_tree<> transforms. </para><namespace name="boost"><namespace name="proto"><namespace name="transform"><struct name="fold"><template>
       <template-type-parameter name="Sequence"/>
       <template-type-parameter name="State0"/>
       <template-type-parameter name="Fun"/>
- </template><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="sequence"><type><classname>when</classname>< _, Sequence >::template <classname>result</classname>< void(Expr, State, Visitor) >::type</type></typedef><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization></struct><struct name="reverse_fold"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="sequence"><type><classname>when</classname>< _, Sequence >::template result< void(Expr, State, Visitor) >::type</type></typedef><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, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct><struct name="reverse_fold"><template>
       <template-type-parameter name="Sequence"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Fun"/>
     </template><inherit access="public">boost::proto::transform::fold< Sequence, State0, Fun ></inherit></struct><struct-specialization name="fold"><template>
       <template-type-parameter name="State0"/>
       <template-type-parameter name="Fun"/>
- </template><specialization><template-arg>_</template-arg><template-arg>State0</template-arg><template-arg>Fun</template-arg></specialization><description><para>This specialization is only for improved compile-time performance in the commom case when the Sequence transform is <computeroutput>proto::_</computeroutput>.</para><para>INTERNAL ONLY </para></description><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>_</template-arg><template-arg>State0</template-arg><template-arg>Fun</template-arg></specialization><description><para>This specialization is only for improved compile-time performance in the commom case when the Sequence transform is <computeroutput>proto::_</computeroutput>.</para><para>INTERNAL ONLY </para></description><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization></struct-specialization><struct-specialization name="reverse_fold"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</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, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="reverse_fold"><template>
       <template-type-parameter name="State0"/>
       <template-type-parameter name="Fun"/>
- </template><specialization><template-arg>_</template-arg><template-arg>State0</template-arg><template-arg>Fun</template-arg></specialization><description><para>This specialization is only for improved compile-time performance in the commom case when the Sequence transform is <computeroutput>proto::_</computeroutput>.</para><para>INTERNAL ONLY </para></description><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>_</template-arg><template-arg>State0</template-arg><template-arg>Fun</template-arg></specialization><description><para>This specialization is only for improved compile-time performance in the commom case when the Sequence transform is <computeroutput>proto::_</computeroutput>.</para><para>INTERNAL ONLY </para></description><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization></struct-specialization></namespace></namespace></namespace></header><header name="boost/xpressive/proto/transform/fold_tree.hpp"><namespace name="boost"><namespace name="proto"><struct-specialization name="is_callable"><template>
- <template-type-parameter name="Sequence"/>
- <template-type-parameter name="State0"/>
- <template-type-parameter name="Fun"/>
- </template><specialization><template-arg>transform::fold_tree< Sequence</template-arg><template-arg>State0</template-arg><template-arg>Fun ></template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><struct-specialization name="is_callable"><template>
- <template-type-parameter name="Sequence"/>
- <template-type-parameter name="State0"/>
- <template-type-parameter name="Fun"/>
- </template><specialization><template-arg>transform::reverse_fold_tree< Sequence</template-arg><template-arg>State0</template-arg><template-arg>Fun ></template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><namespace name="transform"><struct name="fold_tree"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</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, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct-specialization></namespace></namespace></namespace></header><header name="boost/xpressive/proto/transform/fold_tree.hpp"><namespace name="boost"><namespace name="proto"><namespace name="transform"><struct name="fold_tree"><template>
       <template-type-parameter name="Sequence"/>
       <template-type-parameter name="State0"/>
       <template-type-parameter name="Fun"/>
- </template><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="type"><type>impl::template <classname>result</classname>< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization></struct><struct name="reverse_fold_tree"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct><struct name="reverse_fold_tree"><template>
       <template-type-parameter name="Sequence"/>
       <template-type-parameter name="State0"/>
       <template-type-parameter name="Fun"/>
- </template><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="type"><type>impl::template <classname>result</classname>< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization></struct></namespace></namespace></namespace></header><header name="boost/xpressive/proto/transform/make.hpp"><para>Contains definition of the make<> transform. </para><namespace name="boost"><namespace name="proto"><struct-specialization name="is_callable"><template>
- <template-type-parameter name="Fun"/>
- </template><specialization><template-arg>transform::make< Fun ></template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><namespace name="transform"><struct name="make"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type><emphasis>unspecified</emphasis></type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><method-group name="public member functions"><method name="operator()" cv="const"><type>result< void(Expr, State, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct></namespace></namespace></namespace></header><header name="boost/xpressive/proto/transform/make.hpp"><para>Contains definition of the make<> transform. </para><namespace name="boost"><namespace name="proto"><namespace name="transform"><struct name="make"><template>
       <template-type-parameter name="Fun"/>
- </template><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization></struct><struct-specialization name="make"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</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, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name=""><paramtype>Expr const &</paramtype></parameter><parameter name=""><paramtype>State const &</paramtype></parameter><parameter name=""><paramtype>Visitor &</paramtype></parameter></method></method-group></struct><struct-specialization name="make"><template>
       <template-type-parameter name="Return"/>
- </template><specialization><template-arg>Return()</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Return()</template-arg></specialization><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization></struct-specialization><struct-specialization name="make"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</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, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="make"><template>
       <template-type-parameter name="Return"/>
       <template-type-parameter name="A0"/>
- </template><specialization><template-arg>Return(A0)</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Return(A0)</template-arg></specialization><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization></struct-specialization><struct-specialization name="make"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</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, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="make"><template>
       <template-type-parameter name="Return"/>
       <template-type-parameter name="A0"/>
       <template-type-parameter name="A1"/>
- </template><specialization><template-arg>Return(A0</template-arg><template-arg>A1)</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Return(A0</template-arg><template-arg>A1)</template-arg></specialization><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization></struct-specialization><struct-specialization name="make"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</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, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="make"><template>
       <template-type-parameter name="Return"/>
       <template-type-parameter name="A0"/>
       <template-type-parameter name="A1"/>
       <template-type-parameter name="A2"/>
- </template><specialization><template-arg>Return(A0</template-arg><template-arg>A1</template-arg><template-arg>A2)</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Return(A0</template-arg><template-arg>A1</template-arg><template-arg>A2)</template-arg></specialization><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization></struct-specialization><struct-specialization name="make"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</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, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="make"><template>
       <template-type-parameter name="Return"/>
       <template-type-parameter name="A0"/>
       <template-type-parameter name="A1"/>
       <template-type-parameter name="A2"/>
       <template-type-parameter name="A3"/>
- </template><specialization><template-arg>Return(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3)</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Return(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3)</template-arg></specialization><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization></struct-specialization><struct-specialization name="make"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</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, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct-specialization><struct-specialization name="make"><template>
       <template-type-parameter name="Return"/>
       <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>Return(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3</template-arg><template-arg>A4)</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Return(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3</template-arg><template-arg>A4)</template-arg></specialization><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization></struct-specialization></namespace></namespace></namespace></header><header name="boost/xpressive/proto/transform/pass_through.hpp"><para>TODO </para><namespace name="boost"><namespace name="proto"><struct-specialization name="is_callable"><template>
- <template-type-parameter name="Grammar"/>
- </template><specialization><template-arg>transform::pass_through< Grammar ></template-arg></specialization><inherit access="public">boost::mpl::true_</inherit></struct-specialization><namespace name="transform"><struct name="pass_through"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</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, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct-specialization></namespace></namespace></namespace></header><header name="boost/xpressive/proto/transform/pass_through.hpp"><para>TODO </para><namespace name="boost"><namespace name="proto"><namespace name="transform"><struct name="pass_through"><template>
       <template-type-parameter name="Grammar"/>
- </template><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef></struct-specialization></struct></namespace></namespace></namespace></header><header name="boost/xpressive/proto/transform/when.hpp"><para>Definition of when transform. </para><namespace name="boost"><namespace name="proto"><namespace name="transform"><struct name="when"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</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, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter></method></method-group></struct></namespace></namespace></namespace></header><header name="boost/xpressive/proto/transform/when.hpp"><para>Definition of when transform. </para><namespace name="boost"><namespace name="proto"><namespace name="transform"><struct name="when"><template>
       <template-type-parameter name="Grammar"/>
       <template-type-parameter name="Fun"/>
     </template><inherit access="public">Fun</inherit><typedef name="proto_base_expr"><type>Grammar::proto_base_expr</type></typedef></struct><struct-specialization name="when"><template>
@@ -2243,64 +2232,74 @@
     </template><inherit access="public">boost::proto::transform::when< _, Fun ></inherit></struct><struct-specialization name="when"><template>
       <template-type-parameter name="Grammar"/>
       <template-type-parameter name="Return"/>
- </template><specialization><template-arg>Grammar</template-arg><template-arg>Return()</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Grammar</template-arg><template-arg>Return()</template-arg></specialization><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type>mpl::if_< <classname>is_callable</classname>< Return >, <classname>call</classname>< Return() >, <classname>make</classname>< Return() > >::type</type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><typedef name="proto_base_expr"><type>Grammar::proto_base_expr</type></typedef></struct-specialization><struct-specialization name="when"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type>mpl::if_< <classname>is_callable</classname>< Return >, <classname>call</classname>< Return() >, <classname>make</classname>< Return() > >::type</type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::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, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter><description><para>Function call operator </para></description></method></method-group></struct-specialization><struct-specialization name="when"><template>
       <template-type-parameter name="Grammar"/>
       <template-type-parameter name="Return"/>
       <template-type-parameter name="A0"/>
- </template><specialization><template-arg>Grammar</template-arg><template-arg>Return(A0)</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Grammar</template-arg><template-arg>Return(A0)</template-arg></specialization><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type>mpl::if_< <classname>is_callable</classname>< Return >, <classname>call</classname>< Return(A0) >, <classname>make</classname>< Return(A0) > >::type</type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><typedef name="proto_base_expr"><type>Grammar::proto_base_expr</type></typedef></struct-specialization><struct-specialization name="when"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type>mpl::if_< <classname>is_callable</classname>< Return >, <classname>call</classname>< Return(A0) >, <classname>make</classname>< Return(A0) > >::type</type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::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, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter><description><para>Function call operator </para></description></method></method-group></struct-specialization><struct-specialization name="when"><template>
       <template-type-parameter name="Grammar"/>
       <template-type-parameter name="Return"/>
       <template-type-parameter name="A0"/>
       <template-type-parameter name="A1"/>
- </template><specialization><template-arg>Grammar</template-arg><template-arg>Return(A0</template-arg><template-arg>A1)</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Grammar</template-arg><template-arg>Return(A0</template-arg><template-arg>A1)</template-arg></specialization><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type>mpl::if_< <classname>is_callable</classname>< Return >, <classname>call</classname>< Return(A0, A1) >, <classname>make</classname>< Return(A0, A1) > >::type</type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><typedef name="proto_base_expr"><type>Grammar::proto_base_expr</type></typedef></struct-specialization><struct-specialization name="when"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type>mpl::if_< <classname>is_callable</classname>< Return >, <classname>call</classname>< Return(A0, A1) >, <classname>make</classname>< Return(A0, A1) > >::type</type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::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, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter><description><para>Function call operator </para></description></method></method-group></struct-specialization><struct-specialization name="when"><template>
       <template-type-parameter name="Grammar"/>
       <template-type-parameter name="Return"/>
       <template-type-parameter name="A0"/>
       <template-type-parameter name="A1"/>
       <template-type-parameter name="A2"/>
- </template><specialization><template-arg>Grammar</template-arg><template-arg>Return(A0</template-arg><template-arg>A1</template-arg><template-arg>A2)</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Grammar</template-arg><template-arg>Return(A0</template-arg><template-arg>A1</template-arg><template-arg>A2)</template-arg></specialization><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type>mpl::if_< <classname>is_callable</classname>< Return >, <classname>call</classname>< Return(A0, A1, A2) >, <classname>make</classname>< Return(A0, A1, A2) > >::type</type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><typedef name="proto_base_expr"><type>Grammar::proto_base_expr</type></typedef></struct-specialization><struct-specialization name="when"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type>mpl::if_< <classname>is_callable</classname>< Return >, <classname>call</classname>< Return(A0, A1, A2) >, <classname>make</classname>< Return(A0, A1, A2) > >::type</type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::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, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter><description><para>Function call operator </para></description></method></method-group></struct-specialization><struct-specialization name="when"><template>
       <template-type-parameter name="Grammar"/>
       <template-type-parameter name="Return"/>
       <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>Return(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3)</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Grammar</template-arg><template-arg>Return(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3)</template-arg></specialization><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type>mpl::if_< <classname>is_callable</classname>< Return >, <classname>call</classname>< Return(A0, A1, A2, A3) >, <classname>make</classname>< Return(A0, A1, A2, A3) > >::type</type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><typedef name="proto_base_expr"><type>Grammar::proto_base_expr</type></typedef></struct-specialization><struct-specialization name="when"><template>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type>mpl::if_< <classname>is_callable</classname>< Return >, <classname>call</classname>< Return(A0, A1, A2, A3) >, <classname>make</classname>< Return(A0, A1, A2, A3) > >::type</type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::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, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter><description><para>Function call operator </para></description></method></method-group></struct-specialization><struct-specialization name="when"><template>
       <template-type-parameter name="Grammar"/>
       <template-type-parameter name="Return"/>
       <template-type-parameter name="A0"/>
@@ -2308,11 +2307,13 @@
       <template-type-parameter name="A2"/>
       <template-type-parameter name="A3"/>
       <template-type-parameter name="A4"/>
- </template><specialization><template-arg>Grammar</template-arg><template-arg>Return(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3</template-arg><template-arg>A4)</template-arg></specialization><struct name="result"><template>
- <template-type-parameter name="Sig"/>
- </template></struct><struct-specialization name="result"><template>
+ </template><specialization><template-arg>Grammar</template-arg><template-arg>Return(A0</template-arg><template-arg>A1</template-arg><template-arg>A2</template-arg><template-arg>A3</template-arg><template-arg>A4)</template-arg></specialization><struct-specialization name="result"><template>
       <template-type-parameter name="This"/>
       <template-type-parameter name="Expr"/>
       <template-type-parameter name="State"/>
       <template-type-parameter name="Visitor"/>
- </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type>mpl::if_< <classname>is_callable</classname>< Return >, <classname>call</classname>< Return(A0, A1, A2, A3, A4) >, <classname>make</classname>< Return(A0, A1, A2, A3, A4) > >::type</type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::type</type></typedef></struct-specialization><typedef name="proto_base_expr"><type>Grammar::proto_base_expr</type></typedef></struct-specialization></namespace></namespace></namespace></header></library-reference>
+ </template><specialization><template-arg>This(Expr</template-arg><template-arg>State</template-arg><template-arg>Visitor)</template-arg></specialization><typedef name="impl"><type>mpl::if_< <classname>is_callable</classname>< Return >, <classname>call</classname>< Return(A0, A1, A2, A3, A4) >, <classname>make</classname>< Return(A0, A1, A2, A3, A4) > >::type</type></typedef><typedef name="type"><type>impl::template result< void(Expr, State, Visitor) >::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, Visitor) >::type</type><template>
+ <template-type-parameter name="Expr"/>
+ <template-type-parameter name="State"/>
+ <template-type-parameter name="Visitor"/>
+ </template><parameter name="expr"><paramtype>Expr const &</paramtype></parameter><parameter name="state"><paramtype>State const &</paramtype></parameter><parameter name="visitor"><paramtype>Visitor &</paramtype></parameter><description><para>Function call operator </para></description></method></method-group></struct-specialization></namespace></namespace></namespace></header></library-reference>

Next message: nesotto_at_[hidden]: "[Boost-commit] svn:boost r43139 - in branches/release/libs/range: doc test"
Previous message: JakeVoytko_at_[hidden]: "[Boost-commit] svn:boost r43137 - sandbox/SOC/2007/visualization/boost/svg_plot/detail"

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