Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r54379 - in branches/release: . boost/proto boost/proto/transform libs/proto/example
From: eric_at_[hidden]
Date: 2009-06-26 12:09:47


Author: eric_niebler
Date: 2009-06-26 12:09:44 EDT (Fri, 26 Jun 2009)
New Revision: 54379
URL: http://svn.boost.org/trac/boost/changeset/54379

Log:
Merged revisions 54364 via svnmerge from
https://svn.boost.org/svn/boost/trunk

........
  r54364 | eric_niebler | 2009-06-25 23:09:05 -0700 (Thu, 25 Jun 2009) | 1 line
  
  fix some bugs with use of Transform::result<void(E,S,V)>, which is no longer valid. Make lambda.hpp example work again
........

Properties modified:
   branches/release/ (props changed)
Text files modified:
   branches/release/boost/proto/deep_copy.hpp | 6
   branches/release/boost/proto/generate.hpp | 10
   branches/release/boost/proto/make_expr.hpp | 4
   branches/release/boost/proto/matches.hpp | 49 ++++---
   branches/release/boost/proto/operators.hpp | 35 ++--
   branches/release/boost/proto/traits.hpp | 10
   branches/release/boost/proto/transform/fold.hpp | 2
   branches/release/boost/proto/transform/make.hpp | 11
   branches/release/boost/proto/transform/pass_through.hpp | 4
   branches/release/boost/proto/transform/when.hpp | 6
   branches/release/libs/proto/example/lambda.hpp | 254 +++++++++++++++++++++++++++------------
   11 files changed, 249 insertions(+), 142 deletions(-)

Modified: branches/release/boost/proto/deep_copy.hpp
==============================================================================
--- branches/release/boost/proto/deep_copy.hpp (original)
+++ branches/release/boost/proto/deep_copy.hpp 2009-06-26 12:09:44 EDT (Fri, 26 Jun 2009)
@@ -41,7 +41,8 @@
>::type
                 actual_terminal_type;
                 typedef typename terminal<actual_terminal_type>::type expr_type;
- typedef typename Expr::proto_domain::template result<void(expr_type)>::type type;
+ typedef typename Expr::proto_domain proto_domain;
+ typedef typename proto_domain::template result<proto_domain(expr_type)>::type type;
 
                 template<typename Expr2>
                 static type call(Expr2 const &expr)
@@ -174,7 +175,8 @@
>
                 expr_type;
 
- typedef typename Expr::proto_domain::template result<void(expr_type)>::type type;
+ typedef typename Expr::proto_domain proto_domain;
+ typedef typename proto_domain::template result<proto_domain(expr_type)>::type type;
 
                 template<typename Expr2>
                 static type call(Expr2 const &expr)

Modified: branches/release/boost/proto/generate.hpp
==============================================================================
--- branches/release/boost/proto/generate.hpp (original)
+++ branches/release/boost/proto/generate.hpp 2009-06-26 12:09:44 EDT (Fri, 26 Jun 2009)
@@ -247,7 +247,7 @@
             /// \param expr The expression to modify.
             /// \return <tt>deep_copy(expr)</tt>
             template<typename Expr>
- typename result<void(Expr)>::type operator ()(Expr const &expr) const
+ typename result<by_value_generator(Expr)>::type operator ()(Expr const &expr) const
             {
                 return detail::by_value_generator_<Expr>::make(expr);
             }
@@ -276,7 +276,7 @@
             {
                 typedef
                     typename Second::template result<
- void(typename First::template result<void(Expr)>::type)
+ Second(typename First::template result<First(Expr)>::type)
>::type
                 type;
             };
@@ -286,7 +286,7 @@
             {
                 typedef
                     typename Second::template result<
- void(typename First::template result<void(Expr)>::type)
+ Second(typename First::template result<First(Expr)>::type)
>::type
                 type;
             };
@@ -296,7 +296,7 @@
             {
                 typedef
                     typename Second::template result<
- void(typename First::template result<void(Expr)>::type)
+ Second(typename First::template result<First(Expr)>::type)
>::type
                 type;
             };
@@ -304,7 +304,7 @@
             /// \param expr The expression to modify.
             /// \return Second()(First()(expr))
             template<typename Expr>
- typename result<void(Expr)>::type operator ()(Expr const &expr) const
+ typename result<compose_generators(Expr)>::type operator ()(Expr const &expr) const
             {
                 return Second()(First()(expr));
             }

Modified: branches/release/boost/proto/make_expr.hpp
==============================================================================
--- branches/release/boost/proto/make_expr.hpp (original)
+++ branches/release/boost/proto/make_expr.hpp 2009-06-26 12:09:44 EDT (Fri, 26 Jun 2009)
@@ -979,7 +979,7 @@
               , N
> expr_type;
 
- typedef typename Domain::template result<void(expr_type)>::type result_type;
+ typedef typename Domain::template result<Domain(expr_type)>::type result_type;
 
             result_type operator()(BOOST_PP_ENUM_BINARY_PARAMS(N, typename add_reference<A, >::type a)) const
             {
@@ -1013,7 +1013,7 @@
               , N
> expr_type;
 
- typedef typename Domain::template result<void(expr_type)>::type type;
+ typedef typename Domain::template result<Domain(expr_type)>::type type;
 
             static type const call(Sequence const &sequence)
             {

Modified: branches/release/boost/proto/matches.hpp
==============================================================================
--- branches/release/boost/proto/matches.hpp (original)
+++ branches/release/boost/proto/matches.hpp 2009-06-26 12:09:44 EDT (Fri, 26 Jun 2009)
@@ -70,19 +70,6 @@
             template<typename Expr, typename Grammar>
             struct matches_;
 
- // and_ and or_ implementation
- template<bool B, typename Expr, typename G0>
- struct or_1
- : mpl::bool_<B>
- {
- typedef G0 which;
- };
-
- template<bool B>
- struct and_1
- : mpl::bool_<B>
- {};
-
             template<bool B, typename Pred>
             struct and_2;
 
@@ -475,9 +462,9 @@
             /// \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,U,V\></tt> if
- /// <tt>when\<_,T\>::::result\<void(E,int,int)\>::::type::value</tt>
+ /// <tt>boost::result_of\<when\<_,T\>(E,int,int)\>::::type::value</tt>
             /// is \c true and \c E matches \c U; or, if
- /// <tt>when\<_,T\>::::result\<void(E,int,int)\>::::type::value</tt>
+ /// <tt>boost::result_of\<when\<_,T\>(E,int,int)\>::::type::value</tt>
             /// is \c false and \c E matches \c V. (Note: \c U defaults to \c _
             /// and \c V defaults to \c not_\<_\>.)
             /// \li An expression \c E matches <tt>not_\<T\></tt> if \c E does
@@ -647,15 +634,15 @@
             /// When <tt>if_\<If,Then,Else\></tt> is used as a grammar, \c If
             /// must be a Proto transform and \c Then and \c Else must be grammars.
             /// An expression type \c E matches <tt>if_\<If,Then,Else\></tt> if
- /// <tt>when\<_,If\>::::result\<void(E,int,int)\>::::type::value</tt>
+ /// <tt>boost::result_of\<when\<_,If\>(E,int,int)\>::::type::value</tt>
             /// is \c true and \c E matches \c U; or, if
- /// <tt>when\<_,If\>::::result\<void(E,int,int)\>::::type::value</tt>
+ /// <tt>boost::result_of\<when\<_,If\>(E,int,int)\>::::type::value</tt>
             /// is \c false and \c E matches \c V.
             ///
             /// The template parameter \c Then defaults to \c _
             /// and \c Else defaults to \c not\<_\>, so an expression type \c E
             /// will match <tt>if_\<If\></tt> if and only if
- /// <tt>when\<_,If\>::::result\<void(E,int,int)\>::::type::value</tt>
+ /// <tt>boost::result_of\<when\<_,If\>(E,int,int)\>::::type::value</tt>
             /// is \c true.
             ///
             /// \code
@@ -672,7 +659,7 @@
             /// When <tt>if_\<If,Then,Else\></tt> is used as a transform, \c If,
             /// \c Then and \c Else must be Proto transforms. When applying
             /// the transform to an expression \c E, state \c S and data \c V,
- /// if <tt>when\<_,If\>::::result\<void(E,S,V)\>::::type::value</tt>
+ /// if <tt>boost::result_of\<when\<_,If\>(E,S,V)\>::::type::value</tt>
             /// is \c true then the \c Then transform is applied; otherwise
             /// the \c Else transform is applied.
             ///
@@ -752,7 +739,8 @@
                 /// \param s The current state
                 /// \param d A data of arbitrary type
                 /// \pre <tt>matches\<Expr,or_\>::::value</tt> is \c true.
- /// \return <tt>result\<void(Expr, State, Data)\>::::which()(e, s, d)</tt>
+ /// \return <tt>which()(e, s, d)</tt>, where <tt>which</tt> is the
+ /// sub-grammar that matched <tt>Expr</tt>.
 
                 template<typename Expr, typename State, typename Data>
                 struct impl
@@ -790,7 +778,8 @@
                     /// \param s The current state
                     /// \param d A data of arbitrary type
                     /// \pre <tt>matches\<Expr,and_\>::::value</tt> is \c true.
- /// \return <tt>result\<void(Expr, State, Data)\>::::which()(e, s, d)</tt>
+ /// \return <tt>which()(e, s, d)</tt>, where <tt>which</tt> is
+ /// the last non-void sub-grammar in the <tt>and_\<\></tt>.
                 };
             };
 
@@ -819,7 +808,8 @@
                 /// \param s The current state
                 /// \param d A data of arbitrary type
                 /// \pre <tt>matches\<Expr,switch_\>::::value</tt> is \c true.
- /// \return <tt>result\<void(Expr, State, Data)\>::::which()(e, s, d)</tt>
+ /// \return <tt>which()(e, s, d)</tt>, where <tt>which</tt> is
+ /// <tt>Cases::case_<typename Expr::proto_tag></tt>
 
                 template<typename Expr, typename State, typename Data>
                 struct impl
@@ -937,13 +927,21 @@
 
     #define N BOOST_PP_ITERATION()
 
+ // Assymetry here between the handling of and_N and or_N because
+ // and_N is used by lambda_matches up to BOOST_PROTO_MAX_ARITY,
+ // regardless of how low BOOST_PROTO_MAX_LOGICAL_ARITY is.
             template<bool B, BOOST_PP_ENUM_PARAMS(BOOST_PP_DEC(N), typename P)>
             struct BOOST_PP_CAT(and_, N)
+ #if 2 == N
+ : mpl::bool_<P0::value>
+ {};
+ #else
               : BOOST_PP_CAT(and_, BOOST_PP_DEC(N))<
                     P0::value BOOST_PP_COMMA_IF(BOOST_PP_SUB(N,2))
                     BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_DEC(N), P)
>
             {};
+ #endif
 
             template<BOOST_PP_ENUM_PARAMS(BOOST_PP_DEC(N), typename P)>
             struct BOOST_PP_CAT(and_, N)<false, BOOST_PP_ENUM_PARAMS(BOOST_PP_DEC(N), P)>
@@ -959,11 +957,18 @@
 
             template<bool B, typename Expr, BOOST_PP_ENUM_PARAMS(N, typename G)>
             struct BOOST_PP_CAT(or_, N)
+ #if 2 == N
+ : mpl::bool_<matches_<Expr, typename G1::proto_base_expr>::value>
+ {
+ typedef G1 which;
+ };
+ #else
               : BOOST_PP_CAT(or_, BOOST_PP_DEC(N))<
                     matches_<Expr, typename G1::proto_base_expr>::value
                   , Expr, BOOST_PP_ENUM_SHIFTED_PARAMS(N, G)
>
             {};
+ #endif
 
             template<typename Expr BOOST_PP_ENUM_TRAILING_PARAMS(N, typename G)>
             struct BOOST_PP_CAT(or_, N)<true, Expr, BOOST_PP_ENUM_PARAMS(N, G)>

Modified: branches/release/boost/proto/operators.hpp
==============================================================================
--- branches/release/boost/proto/operators.hpp (original)
+++ branches/release/boost/proto/operators.hpp 2009-06-26 12:09:44 EDT (Fri, 26 Jun 2009)
@@ -32,7 +32,7 @@
         struct generate_if
           : lazy_enable_if_c<
                 matches<Expr, typename Domain::proto_grammar>::value
- , typename Domain::template result<void(Expr)>
+ , typename Domain::template result<Domain(Expr)>
>
         {};
 
@@ -47,8 +47,8 @@
         struct generate_if_left
           : lazy_enable_if_c<
                 matches<proto::expr<Tag, proto::list2<Left &, Right>, 2>, typename Domain::proto_grammar>::value
- , typename Domain::template result<void(
- proto::expr<Tag, proto::list2<Left &, typename Domain::template result<void(Right)>::type>, 2>
+ , typename Domain::template result<Domain(
+ proto::expr<Tag, proto::list2<Left &, typename Domain::template result<Domain(Right)>::type>, 2>
                 )>
>
         {};
@@ -64,8 +64,8 @@
         struct generate_if_right
           : lazy_enable_if_c<
                 matches<proto::expr<Tag, proto::list2<Left, Right &>, 2>, typename Domain::proto_grammar>::value
- , typename Domain::template result<void(
- proto::expr<Tag, proto::list2<typename Domain::template result<void(Left)>::type, Right &>, 2>
+ , typename Domain::template result<Domain(
+ proto::expr<Tag, proto::list2<typename Domain::template result<Domain(Left)>::type, Right &>, 2>
                 )>
>
         {};
@@ -91,14 +91,15 @@
>
         {
             typedef proto::expr<tag::terminal, term<Right &>, 0> term_type;
- typedef proto::expr<Tag, list2<Left &, typename Left::proto_domain::template result<void(term_type)>::type>, 2> expr_type;
+ typedef typename Left::proto_domain proto_domain;
+ typedef proto::expr<Tag, list2<Left &, typename proto_domain::template result<proto_domain(term_type)>::type>, 2> expr_type;
 
- static typename Left::proto_domain::template result<void(expr_type)>::type
+ static typename proto_domain::template result<proto_domain(expr_type)>::type
             make(Left &left, Right &right)
             {
                 term_type term = {right};
- expr_type that = {left, typename Left::proto_domain()(term)};
- return typename Left::proto_domain()(that);
+ expr_type that = {left, proto_domain()(term)};
+ return proto_domain()(that);
             }
         };
 
@@ -112,14 +113,15 @@
>
         {
             typedef proto::expr<tag::terminal, term<Left &>, 0> term_type;
- typedef proto::expr<Tag, list2<typename Right::proto_domain::template result<void(term_type)>::type, Right &>, 2> expr_type;
+ typedef typename Right::proto_domain proto_domain;
+ typedef proto::expr<Tag, list2<typename proto_domain::template result<proto_domain(term_type)>::type, Right &>, 2> expr_type;
 
- static typename Right::proto_domain::template result<void(expr_type)>::type
+ static typename proto_domain::template result<proto_domain(expr_type)>::type
             make(Left &left, Right &right)
             {
                 term_type term = {left};
- expr_type that = {typename Right::proto_domain()(term), right};
- return typename Right::proto_domain()(that);
+ expr_type that = {proto_domain()(term), right};
+ return proto_domain()(that);
             }
         };
 
@@ -136,13 +138,14 @@
>
         {
             typedef proto::expr<Tag, list2<Left &, Right &>, 2> expr_type;
- BOOST_MPL_ASSERT((is_same<typename Left::proto_domain, typename Right::proto_domain>));
+ typedef typename Left::proto_domain proto_domain;
+ BOOST_MPL_ASSERT((is_same<proto_domain, typename Right::proto_domain>));
 
- static typename Left::proto_domain::template result<void(expr_type)>::type
+ static typename proto_domain::template result<proto_domain(expr_type)>::type
             make(Left &left, Right &right)
             {
                 expr_type that = {left, right};
- return typename Left::proto_domain()(that);
+ return proto_domain()(that);
             }
         };
 

Modified: branches/release/boost/proto/traits.hpp
==============================================================================
--- branches/release/boost/proto/traits.hpp (original)
+++ branches/release/boost/proto/traits.hpp 2009-06-26 12:09:44 EDT (Fri, 26 Jun 2009)
@@ -258,7 +258,7 @@
>::type
                 arg0_;
                 typedef proto::expr<proto::tag::terminal, term<arg0_>, 0> expr_;
- typedef typename Domain::template result<void(expr_)>::type type;
+ typedef typename Domain::template result<Domain(expr_)>::type type;
                 typedef type const reference;
 
                 /// INTERNAL ONLY
@@ -291,7 +291,7 @@
>
             {
                 typedef typename T::proto_derived_expr expr_; // removes the const
- typedef typename Domain::template result<void(expr_)>::type type;
+ typedef typename Domain::template result<Domain(expr_)>::type type;
                 typedef type const reference;
 
                 /// INTERNAL ONLY
@@ -346,7 +346,7 @@
             struct as_child
             {
                 typedef proto::expr<proto::tag::terminal, term<T &>, 0> expr_;
- typedef typename Domain::template result<void(expr_)>::type type;
+ typedef typename Domain::template result<Domain(expr_)>::type type;
 
                 /// INTERNAL ONLY
                 ///
@@ -382,9 +382,9 @@
                     BOOST_WORKAROUND(BOOST_INTEL, BOOST_TESTED_AT(1010))
                 // These compilers don't strip top-level cv qualifiers
                 // on arguments in function types
- typedef typename Domain::template result<void(typename T::proto_derived_expr)>::type type;
+ typedef typename Domain::template result<Domain(typename T::proto_derived_expr)>::type type;
                 #else
- typedef typename Domain::template result<void(T)>::type type;
+ typedef typename Domain::template result<Domain(T)>::type type;
                 #endif
 
                 /// INTERNAL ONLY

Modified: branches/release/boost/proto/transform/fold.hpp
==============================================================================
--- branches/release/boost/proto/transform/fold.hpp (original)
+++ branches/release/boost/proto/transform/fold.hpp 2009-06-26 12:09:44 EDT (Fri, 26 Jun 2009)
@@ -54,7 +54,7 @@
                 #if BOOST_VERSION < 103500
                 template<typename Expr, typename State>
                 struct apply
- : result<void(Expr, State)>
+ : result<as_callable(Expr, State)>
                 {};
                 #endif
 

Modified: branches/release/boost/proto/transform/make.hpp
==============================================================================
--- branches/release/boost/proto/transform/make.hpp (original)
+++ branches/release/boost/proto/transform/make.hpp 2009-06-26 12:09:44 EDT (Fri, 26 Jun 2009)
@@ -217,15 +217,15 @@
         /// \li Function pointer types
         /// \li Types for which <tt>proto::is_callable\< type \>::::value</tt> is \c true
         ///
- /// <tt>make\<T\<X0,X1,...\> \>::::result\<void(Expr, State, Data)\>::::type</tt>
+ /// <tt>boost::result_of\<make\<T\<X0,X1,...\> \>(Expr, State, Data)\>::::type</tt>
         /// is evaluated as follows. For each \c X in <tt>X0,X1,...</tt>, do:
         ///
         /// \li If \c X is a template like <tt>U\<Y0,Y1,...\></tt>, then let <tt>X'</tt>
- /// be <tt>make\<U\<Y0,Y1,...\> \>::::result\<void(Expr, State, Data)\>::::type</tt>
+ /// be <tt>boost::result_of\<make\<U\<Y0,Y1,...\> \>(Expr, State, Data)\>::::type</tt>
         /// (which evaluates this procedure recursively). Note whether any
         /// substitutions took place during this operation.
         /// \li Otherwise, if \c X is a transform, then let <tt>X'</tt> be
- /// <tt>when\<_, X\>::::result\<void(Expr, State, Data)\>::::type</tt>.
+ /// <tt>boost::result_of\<when\<_, X\>(Expr, State, Data)\>::::type</tt>.
         /// Note that a substitution took place.
         /// \li Otherwise, let <tt>X'</tt> be \c X, and note that no substitution
         /// took place.
@@ -387,14 +387,13 @@
             template<typename Expr, typename State, typename Data>
             struct impl : transform_impl<Expr, State, Data>
             {
- /// \brief <tt>make\<Object\>::::result\<void(Expr, State, Data)\>::::type</tt>
+ /// \brief <tt>boost::result_of\<make\<Object\>(Expr, State, Data)\>::::type</tt>
                 typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
                 //typedef typename detail::make_<Object, Expr, State, Data>::type result_type;
 
                 /// Let \c ax be <tt>when\<_, Ax\>()(e, s, d)</tt>
                 /// for each \c x in <tt>[0,N]</tt>.
- /// Let \c T be <tt>result\<void(Expr, State, Data)\>::::type</tt>.
- /// Return <tt>T(a0, a1,... aN)</tt>.
+ /// Return <tt>result_type(a0, a1,... aN)</tt>.
                 ///
                 /// \param e The current expression
                 /// \param s The current state

Modified: branches/release/boost/proto/transform/pass_through.hpp
==============================================================================
--- branches/release/boost/proto/transform/pass_through.hpp (original)
+++ branches/release/boost/proto/transform/pass_through.hpp 2009-06-26 12:09:44 EDT (Fri, 26 Jun 2009)
@@ -97,8 +97,8 @@
         ///
         /// \code
         /// plus<
- /// T0::result<void(E0, S, V)>::type
- /// , T1::result<void(E1, S, V)>::type
+ /// T0::result<T0(E0, S, V)>::type
+ /// , T1::result<T1(E1, S, V)>::type
         /// >::type
         /// \endcode
         ///

Modified: branches/release/boost/proto/transform/when.hpp
==============================================================================
--- branches/release/boost/proto/transform/when.hpp (original)
+++ branches/release/boost/proto/transform/when.hpp 2009-06-26 12:09:44 EDT (Fri, 26 Jun 2009)
@@ -48,8 +48,8 @@
         /// In <tt>when\<G, T\></tt>, when \c T is a class type it is a
         /// PrimitiveTransform and the following equivalencies hold:
         ///
- /// <tt>when\<G,T\>::::result\<void(E,S,V)\>::::type</tt> is the same as
- /// <tt>T::result\<void(E,S,V)\>::::type</tt>.
+ /// <tt>boost::result_of\<when\<G,T\>(E,S,V)\>::::type</tt> is the same as
+ /// <tt>boost::result_of\<T(E,S,V)\>::::type</tt>.
         ///
         /// <tt>when\<G,T\>()(e,s,v)</tt> is the same as
         /// <tt>T()(e,s,v)</tt>.
@@ -172,7 +172,7 @@
                 /// \param s The current state
                 /// \param d An arbitrary data
                 /// \pre <tt>matches\<Expr, Grammar\>::::value</tt> is \c true
- /// \return <tt>result\<void(Expr, State, Data)\>::::impl()(e, s, d)</tt>
+ /// \return <tt>which()(e, s, d)</tt>
                 result_type operator ()(
                     typename impl::expr_param e
                   , typename impl::state_param s

Modified: branches/release/libs/proto/example/lambda.hpp
==============================================================================
--- branches/release/libs/proto/example/lambda.hpp (original)
+++ branches/release/libs/proto/example/lambda.hpp 2009-06-26 12:09:44 EDT (Fri, 26 Jun 2009)
@@ -583,7 +583,7 @@
               : llresult<Sig>
             {};
 
- typename result<Expr const()>::type
+ typename result<llexpr const()>::type
             operator()() const
             {
                 fusion::vector0 args;
@@ -596,7 +596,7 @@
 
             #define M3(R, SIZE, PRODUCT) \
                 template<BOOST_PP_ENUM_PARAMS(SIZE, typename A)> \
- typename result<Expr const(BOOST_PP_SEQ_FOR_EACH_I_R(R, M5, ~, PRODUCT))>::type \
+ typename result<llexpr const(BOOST_PP_SEQ_FOR_EACH_I_R(R, M5, ~, PRODUCT))>::type \
                 operator ()(BOOST_PP_SEQ_FOR_EACH_I_R(R, M4, ~, PRODUCT)) const \
                 { \
                     BOOST_MPL_ASSERT_RELATION(result_of<Arity(Expr const &)>::type::value, <=, SIZE); \
@@ -622,7 +622,7 @@
 
             #define C1 const
 
- #define BOOST_PP_ITERATION_PARAMS_1 (3, (1, BOOST_LAMBDA_MAX_ARITY, <boost/lambda2/lambda.hpp>))
+ #define BOOST_PP_ITERATION_PARAMS_1 (3, (1, BOOST_LAMBDA_MAX_ARITY, "./lambda.hpp"))
             #include BOOST_PP_ITERATE()
 
             #undef C0
@@ -650,22 +650,54 @@
         typedef llexpr<proto::terminal<exception_placeholder>::type> placeholderE_type;
         placeholderE_type const _e = {{{}}};
 
- template<typename T>
         struct byref
         {
- typedef llexpr<typename proto::terminal<T &>::type> type;
- };
+ template<typename Sig>
+ struct result;
+
+ template<typename This, typename T>
+ struct result<This(T &)>
+ {
+ typedef llexpr<typename proto::terminal<T &>::type> type;
+ };
 
- template<typename T>
- struct byref<llexpr<T> >
- {
- typedef llexpr<T> &type;
- };
+ template<typename This, typename T>
+ struct result<This(llexpr<T> &)>
+ {
+ typedef boost::reference_wrapper<llexpr<T> > type;
+ };
 
- template<typename T>
- struct byref<llexpr<T> const>
- {
- typedef llexpr<T> const &type;
+ template<typename This, typename T>
+ struct result<This(llexpr<T> const &)>
+ {
+ typedef boost::reference_wrapper<llexpr<T> const> type;
+ };
+
+ template<typename T>
+ typename result<byref(T &)>::type operator()(T &t) const
+ {
+ typename result<byref(T &)>::type that = {{t}};
+ return that;
+ }
+
+ template<typename T>
+ typename result<byref(T const &)>::type operator()(T const &t) const
+ {
+ typename result<byref(T const &)>::type that = {{t}};
+ return that;
+ }
+
+ template<typename T>
+ boost::reference_wrapper<llexpr<T> > operator()(llexpr<T> &t) const
+ {
+ return boost::ref(t);
+ }
+
+ template<typename T>
+ boost::reference_wrapper<llexpr<T> const> operator()(llexpr<T> const &t) const
+ {
+ return boost::ref(t);
+ }
         };
 
         namespace exprns_
@@ -677,23 +709,23 @@
             typename proto::result_of::make_expr< \
                 TAG \
               , lldomain \
- , typename byref<T>::type \
+ , typename boost::result_of<byref(T &)>::type \
               , U & \
>::type const \
             operator OP(T &t, U &u) \
             { \
- return proto::implicit_expr(t, u); \
+ return proto::make_expr<TAG, lldomain>(byref()(t), boost::ref(u)); \
             } \
             template<typename T, typename U> \
             typename proto::result_of::make_expr< \
                 TAG \
               , lldomain \
- , typename byref<T>::type \
+ , typename boost::result_of<byref(T &)>::type \
               , U const & \
>::type const \
             operator OP(T &t, U const &u) \
             { \
- return proto::implicit_expr(t, u); \
+ return proto::make_expr<TAG, lldomain>(byref()(t), boost::ref(u)); \
             } \
             /**/
 
@@ -719,7 +751,8 @@
         llexpr<typename proto::terminal<T &>::type> const
         var(T &t)
         {
- return proto::implicit_expr(t);
+ llexpr<typename proto::terminal<T &>::type> that = {{t}};
+ return that;
         }
 
         template<typename T>
@@ -735,7 +768,8 @@
         typename constant_type<T>::type const
         constant(T const &t)
         {
- return proto::implicit_expr(t);
+ typename constant_type<T>::type that = {{t}};
+ return that;
         }
 
         template<typename T>
@@ -748,7 +782,8 @@
         llexpr<typename proto::terminal<T const &>::type> const
         constant_ref(T const &t)
         {
- return proto::implicit_expr(t);
+ llexpr<typename proto::terminal<T const &>::type> that = {{t}};
+ return that;
         }
 
         template<typename Cond>
@@ -767,7 +802,10 @@
>::type const
             operator[](Body const &body) const
             {
- return proto::implicit_expr(this->cond, body);
+ return proto::make_expr<tag::while_, lldomain>(
+ boost::ref(this->cond)
+ , boost::ref(body)
+ );
             }
 
         private:
@@ -800,7 +838,11 @@
>::type const
             operator[](Body2 const &body2) const
             {
- return proto::implicit_expr(proto::left(this->if_), proto::right(this->if_), body2);
+ return proto::make_expr<tag::if_else_, lldomain>(
+ boost::ref(proto::left(this->if_))
+ , boost::ref(proto::right(this->if_))
+ , boost::ref(body2)
+ );
             }
 
         private:
@@ -837,7 +879,10 @@
> const
             operator[](Body const &body) const
             {
- return proto::implicit_expr(this->cond, body);
+ return proto::make_expr<tag::if_, lldomain>(
+ boost::ref(this->cond)
+ , boost::ref(body)
+ );
             }
 
         private:
@@ -870,7 +915,12 @@
>::type const
             operator[](Body const &body) const
             {
- return proto::implicit_expr(this->init, this->cond, this->oper, body);
+ return proto::make_expr<tag::for_, lldomain>(
+ boost::ref(this->init)
+ , boost::ref(this->cond)
+ , boost::ref(this->oper)
+ , boost::ref(body)
+ );
             }
 
         private:
@@ -901,7 +951,10 @@
>::type const
             operator()(Cond const &cond) const
             {
- return proto::implicit_expr(this->body, cond);
+ return proto::make_expr<tag::do_while_, lldomain>(
+ boost::ref(this->body)
+ , boost::ref(cond)
+ );
             }
 
         private:
@@ -949,7 +1002,12 @@
>::type const
         for_loop(Init const &init, Cond const &cond, Oper const &oper)
         {
- return proto::implicit_expr(init, cond, oper, noop);
+ return proto::make_expr<tag::for_, lldomain>(
+ boost::ref(init)
+ , boost::ref(cond)
+ , boost::ref(oper)
+ , boost::ref(noop)
+ );
         }
 
         template<typename Init, typename Cond, typename Oper, typename Body>
@@ -963,7 +1021,12 @@
>::type const
         for_loop(Init const &init, Cond const &cond, Oper const &oper, Body const &body)
         {
- return proto::implicit_expr(init, cond, oper, body);
+ return proto::make_expr<tag::for_>(
+ boost::ref(init)
+ , boost::ref(cond)
+ , boost::ref(oper)
+ , boost::ref(body)
+ );
         }
 
         template<typename Cond, typename Body>
@@ -975,7 +1038,10 @@
>::type const
         while_loop(Cond const &cond, Body const &body)
         {
- return proto::implicit_expr(cond, body);
+ return proto::make_expr<tag::while_, lldomain>(
+ boost::ref(cond)
+ , boost::ref(body)
+ );
         }
 
         template<typename Cond>
@@ -987,7 +1053,10 @@
>::type const
         while_loop(Cond const &cond)
         {
- return proto::implicit_expr(cond, noop);
+ return proto::make_expr<tag::while_, lldomain>(
+ boost::ref(cond)
+ , boost::ref(noop)
+ );
         }
 
         template<typename Cond, typename Body>
@@ -999,7 +1068,10 @@
>::type const
         do_while_loop(Cond const &cond, Body const &body)
         {
- return proto::implicit_expr(body, cond);
+ return proto::make_expr<tag::do_while_, lldomain>(
+ boost::ref(body)
+ , boost::ref(cond)
+ );
         }
 
         template<typename Cond>
@@ -1011,7 +1083,10 @@
>::type const
         do_while_loop(Cond const &cond)
         {
- return proto::implicit_expr(noop, cond);
+ return proto::make_expr<tag::do_while_, lldomain>(
+ boost::ref(noop)
+ , boost::ref(cond)
+ );
         }
 
         template<typename Cond, typename Body1>
@@ -1023,7 +1098,10 @@
>::type const
         if_then(Cond const &cond, Body1 const &body1)
         {
- return proto::implicit_expr(cond, body1);
+ return proto::make_expr<tag::if_, lldomain>(
+ boost::ref(cond)
+ , boost::ref(body1)
+ );
         }
 
         template<typename Cond, typename Body1, typename Body2>
@@ -1036,7 +1114,11 @@
>::type const
         if_then_else(Cond const &cond, Body1 const &body1, Body2 const &body2)
         {
- return proto::implicit_expr(cond, body1, body2);
+ return proto::make_expr<tag::if_else_, lldomain>(
+ boost::ref(cond)
+ , boost::ref(body1)
+ , boost::ref(body2)
+ );
         }
 
         template<typename Cond, typename Body1, typename Body2>
@@ -1049,7 +1131,11 @@
>::type const
         if_then_else_return(Cond const &cond, Body1 const &body1, Body2 const &body2)
         {
- return proto::implicit_expr(cond, body1, body2);
+ return proto::make_expr<proto::tag::if_else_, lldomain>(
+ boost::ref(cond)
+ , boost::ref(body1)
+ , boost::ref(body2)
+ );
         }
 
         template<typename T>
@@ -1057,31 +1143,31 @@
         {
             return t;
         }
-
- #define M1(Z, N, DATA) \
- template<BOOST_PP_ENUM_PARAMS_Z(Z, N, typename A)> \
+
+ #define M1(N, typename_A, A_const_ref, A_const_ref_a, ref_a) \
+ template<typename_A(N)> \
         typename proto::result_of::make_expr< \
             proto::tag::function \
           , lldomain \
- BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(Z, N, A, const & BOOST_PP_INTERCEPT) \
+ , A_const_ref(N) \
>::type const \
- bind(BOOST_PP_ENUM_BINARY_PARAMS_Z(Z, N, A, const &a)) \
+ bind(A_const_ref_a(N)) \
         { \
- return proto::implicit_expr(BOOST_PP_ENUM_PARAMS_Z(Z, N, a)); \
+ return proto::make_expr<proto::tag::function, lldomain>(ref_a(N)); \
         } \
                                                                                                     \
- template<typename Ret BOOST_PP_ENUM_TRAILING_PARAMS_Z(Z, N, typename A)> \
+ template<typename Ret, typename_A(N)> \
         typename proto::result_of::make_expr< \
             proto::tag::function \
           , lldomain \
- BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(Z, N, A, const & BOOST_PP_INTERCEPT) \
+ , A_const_ref(N) \
>::type const \
- bind(BOOST_PP_ENUM_BINARY_PARAMS_Z(Z, N, A, const &a)) \
+ bind(A_const_ref_a(N)) \
         { \
- return proto::implicit_expr(BOOST_PP_ENUM_PARAMS_Z(Z, N, a)); \
+ return proto::make_expr<proto::tag::function, lldomain>(ref_a(N)); \
         } \
         /**/
- BOOST_PP_REPEAT_FROM_TO(1, BOOST_PP_INC(BOOST_PROTO_MAX_ARITY), M1, ~)
+ BOOST_PROTO_REPEAT_FROM_TO(1, BOOST_PP_INC(BOOST_PROTO_MAX_ARITY), M1)
         #undef M1
 
         template<typename Ret, typename Expr>
@@ -1117,7 +1203,7 @@
>::type const
         protect(Lambda const &lambda)
         {
- return proto::implicit_expr(lambda);
+ return proto::make_expr<tag::protect, lldomain>(boost::ref(lambda));
         }
 
         template<typename T>
@@ -1154,7 +1240,7 @@
         ll_static_cast(U const &u)
         {
             ll_static_cast_fun<T> fun;
- return proto::implicit_expr(fun, u);
+ return proto::make_expr<proto::tag::function, lldomain>(fun, boost::ref(u));
         }
 
         template<typename T>
@@ -1185,7 +1271,7 @@
         ll_const_cast(U const &u)
         {
             ll_const_cast_fun<T> fun;
- return proto::implicit_expr(fun, u);
+ return proto::make_expr<proto::tag::function, lldomain>(fun, boost::ref(u));
         }
 
         template<typename T>
@@ -1216,7 +1302,7 @@
         ll_dynamic_cast(U const &u)
         {
             ll_dynamic_cast_fun<T> fun;
- return proto::implicit_expr(fun, u);
+ return proto::make_expr<proto::tag::function, lldomain>(fun, boost::ref(u));
         }
 
         template<typename T>
@@ -1247,7 +1333,7 @@
         ll_reinterpret_cast(U const &u)
         {
             ll_reinterpret_cast_fun<T> fun;
- return proto::implicit_expr(fun, u);
+ return proto::make_expr<proto::tag::function, lldomain>(fun, boost::ref(u));
         }
 
         struct ll_sizeof_fun
@@ -1271,7 +1357,7 @@
         ll_sizeof(U const &u)
         {
             ll_sizeof_fun fun;
- return proto::implicit_expr(fun, u);
+ return proto::make_expr<proto::tag::function, lldomain>(fun, boost::ref(u));
         }
 
         struct ll_typeid_fun
@@ -1295,7 +1381,7 @@
         ll_typeid(U const &u)
         {
             ll_typeid_fun fun;
- return proto::implicit_expr(fun, u);
+ return proto::make_expr<proto::tag::function, lldomain>(fun, boost::ref(u));
         }
 
         template<typename T>
@@ -1508,14 +1594,14 @@
         typename proto::result_of::make_expr<tag::catch_<E>, lldomain, Expr const &>::type const
         catch_exception(Expr const &expr)
         {
- return proto::implicit_expr(expr);
+ return proto::make_expr<tag::catch_<E>, lldomain>(boost::ref(expr));
         }
 
         template<typename E>
         typename proto::result_of::make_expr<tag::catch_<E>, lldomain, noop_type const &>::type const
         catch_exception()
         {
- return proto::implicit_expr(noop);
+ return proto::make_expr<tag::catch_<E>, lldomain>(boost::ref(noop));
         }
 
         template<typename Expr>
@@ -1526,29 +1612,29 @@
>::type const
         catch_all(Expr const &expr)
         {
- return proto::implicit_expr(expr);
+ return proto::make_expr<tag::catch_all_, lldomain>(boost::ref(expr));
         }
 
         inline
         proto::result_of::make_expr<tag::catch_all_, lldomain, noop_type const &>::type const
         catch_all()
         {
- return proto::implicit_expr(noop);
+ return proto::make_expr<tag::catch_all_, lldomain>(boost::ref(noop));
         }
 
- #define M1(Z, N, DATA) \
- template<BOOST_PP_ENUM_PARAMS_Z(Z, N, typename A)> \
+ #define M1(N, typename_A, A_const_ref, A_const_ref_a, ref_a) \
+ template<typename_A(N)> \
         typename proto::result_of::make_expr< \
             tag::try_ \
           , lldomain \
- BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(Z, N, A, const & BOOST_PP_INTERCEPT) \
+ , A_const_ref(N) \
>::type const \
- try_catch(BOOST_PP_ENUM_BINARY_PARAMS_Z(Z, N, A, const & a)) \
+ try_catch(A_const_ref_a(N)) \
         { \
- return proto::implicit_expr(BOOST_PP_ENUM_PARAMS_Z(Z, N, a)); \
+ return proto::make_expr<tag::try_, lldomain>(ref_a(N)); \
         } \
         /**/
- BOOST_PP_REPEAT_FROM_TO(2, BOOST_PP_INC(BOOST_PROTO_MAX_ARITY), M1, ~)
+ BOOST_PROTO_REPEAT_FROM_TO(2, BOOST_PP_INC(BOOST_PROTO_MAX_ARITY), M1)
         #undef M1
 
         template<typename Expr>
@@ -1561,15 +1647,14 @@
         throw_exception(Expr const &expr)
         {
             throw_fun fun;
- return proto::implicit_expr(fun, expr);
+ return proto::make_expr<proto::tag::function, lldomain>(fun, boost::ref(expr));
         }
 
         inline
         proto::result_of::make_expr<proto::tag::function, lldomain, rethrow_fun>::type const
         rethrow()
         {
- rethrow_fun fun;
- return proto::implicit_expr(fun);
+ return proto::make_expr<proto::tag::function, lldomain>(rethrow_fun());
         }
 
         struct make_void_fun
@@ -1590,50 +1675,50 @@
         make_void(Expr const &expr)
         {
             make_void_fun fun;
- return proto::implicit_expr(fun, expr);
+ return proto::make_expr<proto::tag::function, lldomain>(fun, boost::ref(expr));
         }
 
- #define M1(Z, N, DATA) \
- template<BOOST_PP_ENUM_PARAMS_Z(Z, N, typename A)> \
+ #define M1(N, typename_A, A_const_ref, A_const_ref_a, ref_a) \
+ template<typename_A(N)> \
         typename proto::result_of::make_expr< \
             tag::switch_ \
           , lldomain \
- BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(Z, N, A, const & BOOST_PP_INTERCEPT) \
+ , A_const_ref(N) \
>::type const \
- switch_statement(BOOST_PP_ENUM_BINARY_PARAMS_Z(Z, N, A, const & a)) \
+ switch_statement(A_const_ref_a(N)) \
         { \
- return proto::implicit_expr(BOOST_PP_ENUM_PARAMS_Z(Z, N, a)); \
+ return proto::make_expr<tag::switch_, lldomain>(ref_a(N)); \
         } \
         /**/
- BOOST_PP_REPEAT_FROM_TO(2, BOOST_PP_INC(BOOST_PROTO_MAX_ARITY), M1, ~)
+ BOOST_PROTO_REPEAT_FROM_TO(2, BOOST_PP_INC(BOOST_PROTO_MAX_ARITY), M1)
         #undef M1
 
         template<int I, typename Expr>
         typename proto::result_of::make_expr<tag::case_<I>, lldomain, Expr const &>::type const
         case_statement(Expr const &expr)
         {
- return proto::implicit_expr(expr);
+ return proto::make_expr<tag::case_<I>, lldomain>(boost::ref(expr));
         }
 
         template<int I>
         typename proto::result_of::make_expr<tag::case_<I>, lldomain, noop_type const &>::type const
         case_statement()
         {
- return proto::implicit_expr(noop);
+ return proto::make_expr<tag::case_<I>, lldomain>(boost::ref(noop));
         }
 
         template<typename Expr>
         typename proto::result_of::make_expr<tag::default_, lldomain, Expr const &>::type const
         default_statement(Expr const &expr)
         {
- return proto::implicit_expr(expr);
+ return proto::make_expr<tag::default_, lldomain>(boost::ref(expr));
         }
 
         inline
         proto::result_of::make_expr<tag::default_, lldomain, noop_type const &>::type const
         default_statement()
         {
- return proto::implicit_expr(noop);
+ return proto::make_expr<tag::default_, lldomain>(boost::ref(noop));
         }
 
         namespace ll
@@ -1657,6 +1742,19 @@
         }
 
     }}
+
+ namespace boost
+ {
+ template<typename Expr>
+ struct result_of<lambda::llexpr<Expr>()>
+ : lambda::llexpr<Expr>::template result<lambda::llexpr<Expr>()>
+ {};
+
+ template<typename Expr>
+ struct result_of<lambda::llexpr<Expr> const()>
+ : lambda::llexpr<Expr>::template result<lambda::llexpr<Expr> const()>
+ {};
+ }
 
     #ifdef _MSC_VER
     # pragma warning(pop)


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