[Boost-commit] svn:boost r79461 - in trunk: boost/proto boost/proto/detail boost/proto/transform boost/proto/transform/detail boost/proto/transform/detail/preprocessed libs/proto/preprocess libs/proto/test

Subject: [Boost-commit] svn:boost r79461 - in trunk: boost/proto boost/proto/detail boost/proto/transform boost/proto/transform/detail boost/proto/transform/detail/preprocessed libs/proto/preprocess libs/proto/test
From: eric_at_[hidden]
Date: 2012-07-12 17:54:33

Author: eric_niebler
Date: 2012-07-12 17:54:30 EDT (Thu, 12 Jul 2012)
New Revision: 79461
URL: http://svn.boost.org/trac/boost/changeset/79461

Log:
transforms get pseudo-parameter pack expansion support for unpacking expressions
Added:
   trunk/boost/proto/transform/detail/expand_pack.hpp   (contents, props changed)
   trunk/boost/proto/transform/detail/pack.hpp   (contents, props changed)
   trunk/boost/proto/transform/detail/pack_impl.hpp   (contents, props changed)
   trunk/boost/proto/transform/detail/preprocessed/expand_pack.hpp   (contents, props changed)
   trunk/boost/proto/transform/detail/preprocessed/pack_impl.hpp   (contents, props changed)
   trunk/libs/proto/test/pack_expansion.cpp   (contents, props changed)
Text files modified: 
   trunk/boost/proto/detail/deduce_domain.hpp               |     1                                         
   trunk/boost/proto/fusion.hpp                             |    21                                         
   trunk/boost/proto/proto_fwd.hpp                          |     2                                         
   trunk/boost/proto/transform/call.hpp                     |    24 +                                       
   trunk/boost/proto/transform/detail/call.hpp              |    29 +                                       
   trunk/boost/proto/transform/detail/lazy.hpp              |    21 +                                       
   trunk/boost/proto/transform/detail/make.hpp              |    24 +                                       
   trunk/boost/proto/transform/detail/preprocessed/call.hpp |   200 ++++++++++                              
   trunk/boost/proto/transform/detail/preprocessed/lazy.hpp |   180 +++++++++                               
   trunk/boost/proto/transform/detail/preprocessed/make.hpp |   220 +++++++++++                             
   trunk/boost/proto/transform/detail/preprocessed/when.hpp |   762 ++++++++++++++++----------------------- 
   trunk/boost/proto/transform/detail/when.hpp              |    77 +--                                     
   trunk/boost/proto/transform/lazy.hpp                     |     7                                         
   trunk/boost/proto/transform/make.hpp                     |     7                                         
   trunk/boost/proto/transform/when.hpp                     |    50 ++                                      
   trunk/libs/proto/preprocess/Jamfile.v2                   |     2                                         
   trunk/libs/proto/preprocess/wave.cfg                     |     3                                         
   trunk/libs/proto/test/Jamfile.v2                         |     3                                         
   18 files changed, 1134 insertions(+), 499 deletions(-)

Modified: trunk/boost/proto/detail/deduce_domain.hpp
==============================================================================
--- trunk/boost/proto/detail/deduce_domain.hpp	(original)
+++ trunk/boost/proto/detail/deduce_domain.hpp	2012-07-12 17:54:30 EDT (Thu, 12 Jul 2012)
@@ -19,6 +19,7 @@
 #include <boost/preprocessor/cat.hpp>
 #include <boost/preprocessor/facilities/intercept.hpp>
 #include <boost/preprocessor/iteration/local.hpp>
+#include <boost/preprocessor/iteration/iterate.hpp>
 #include <boost/preprocessor/repetition/enum_params.hpp>
 #include <boost/preprocessor/repetition/enum_binary_params.hpp>
 #include <boost/preprocessor/repetition/repeat_from_to.hpp>

Modified: trunk/boost/proto/fusion.hpp
==============================================================================
--- trunk/boost/proto/fusion.hpp	(original)
+++ trunk/boost/proto/fusion.hpp	2012-07-12 17:54:30 EDT (Thu, 12 Jul 2012)
@@ -44,12 +44,11 @@
           : fusion::iterator_base<expr_iterator<Expr, Pos> >
         {
             typedef Expr expr_type;
-            typedef typename Expr::proto_tag proto_tag;
             static const long index = Pos;
             typedef fusion::random_access_traversal_tag category;
             typedef tag::proto_expr_iterator fusion_tag;
 
-            expr_iterator(Expr &e)
+            explicit expr_iterator(Expr &e)
               : expr(e)
             {}
 
@@ -60,7 +59,6 @@
         struct flat_view
         {
             typedef Expr expr_type;
-            typedef typename Expr::proto_tag proto_tag;
             typedef fusion::forward_traversal_tag category;
             typedef tag::proto_flat_view fusion_tag;
 
@@ -373,7 +371,7 @@
             struct apply
             {
                 typedef
-                    typename proto::detail::expr_iterator<
+                    proto::detail::expr_iterator<
                         typename Iterator::expr_type
                       , Iterator::index + N::value
                     >
@@ -583,12 +581,14 @@
             template<typename Sequence>
             struct apply
             {
-                typedef typename Sequence::proto_tag proto_tag;
+                typedef typename Sequence::expr_type::proto_tag proto_tag;
 
-                typedef fusion::transform_view<
-                    typename Sequence::expr_type
-                  , proto::detail::as_element<proto_tag>
-                > type;
+                typedef
+                    fusion::transform_view<
+                        typename Sequence::expr_type
+                      , proto::detail::as_element<proto_tag>
+                    >
+                type;
 
                 static type call(Sequence &sequence)
                 {
@@ -639,7 +639,6 @@
           : mpl::false_
         {};
     }
-
 }}
 
 namespace boost { namespace mpl
@@ -655,7 +654,7 @@
     {
         typedef fusion::fusion_sequence_tag type;
     };
-}} 
+}}
 
 #ifdef BOOST_MSVC
 #pragma warning(pop)

Modified: trunk/boost/proto/proto_fwd.hpp
==============================================================================
--- trunk/boost/proto/proto_fwd.hpp	(original)
+++ trunk/boost/proto/proto_fwd.hpp	2012-07-12 17:54:30 EDT (Thu, 12 Jul 2012)
@@ -404,6 +404,8 @@
     template<typename Grammar>
     struct vararg;
 
+    struct pack;
+
     // Boost bug https://svn.boost.org/trac/boost/ticket/4602
     //int const N = INT_MAX;
     int const N = (INT_MAX >> 10);

Modified: trunk/boost/proto/transform/call.hpp
==============================================================================
--- trunk/boost/proto/transform/call.hpp	(original)
+++ trunk/boost/proto/transform/call.hpp	2012-07-12 17:54:30 EDT (Thu, 12 Jul 2012)
@@ -29,6 +29,7 @@
 #include <boost/proto/transform/impl.hpp>
 #include <boost/proto/detail/as_lvalue.hpp>
 #include <boost/proto/detail/poly_function.hpp>
+#include <boost/proto/transform/detail/pack.hpp>
 
 namespace boost { namespace proto
 {
@@ -84,6 +85,29 @@
       : PrimitiveTransform
     {};
 
+    /// \brief A specialization that treats function pointer Transforms as
+    /// if they were function type Transforms.
+    ///
+    /// This specialization requires that \c Fun is actually a function type.
+    ///
+    /// This specialization is required for nested transforms such as
+    /// <tt>call\<T0(T1(_))\></tt>. In C++, functions that are used as
+    /// parameters to other functions automatically decay to funtion
+    /// pointer types. In other words, the type <tt>T0(T1(_))</tt> is
+    /// indistinguishable from <tt>T0(T1(*)(_))</tt>. This specialization
+    /// is required to handle these nested function pointer type transforms
+    /// properly.
+    template<typename Fun>
+    struct call<Fun *>
+      : call<Fun>
+    {};
+
+    /// INTERNAL ONLY
+    template<typename Fun>
+    struct call<detail::msvc_fun_workaround<Fun> >
+      : call<Fun>
+    {};
+
     /// \brief Either call the PolymorphicFunctionObject with 0
     /// arguments, or invoke the PrimitiveTransform with 3
     /// arguments.

Modified: trunk/boost/proto/transform/detail/call.hpp
==============================================================================
--- trunk/boost/proto/transform/detail/call.hpp	(original)
+++ trunk/boost/proto/transform/detail/call.hpp	2012-07-12 17:54:30 EDT (Thu, 12 Jul 2012)
@@ -31,11 +31,9 @@
         #pragma wave option(preserve: 1)
     #endif
 
-    #if BOOST_PROTO_MAX_ARITY > 3
     #define BOOST_PP_ITERATION_PARAMS_1                                                             \
-        (3, (4, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/detail/call.hpp>))
+        (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/detail/call.hpp>))
     #include BOOST_PP_ITERATE()
-    #endif
 
     #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
         #pragma wave option(output: null)
@@ -48,6 +46,7 @@
 
     #define N BOOST_PP_ITERATION()
 
+    #if N > 3
     /// \brief Call the PolymorphicFunctionObject \c Fun with the
     /// current expression, state and data, transformed according
     /// to \c A0 through \c AN.
@@ -81,6 +80,30 @@
             }
         };
     };
+    #endif
+
+    #if N > 0
+    /// \brief Call the PolymorphicFunctionObject \c Fun with the
+    /// current expression, state and data, transformed according
+    /// to \c A0 through \c AN.
+    template<typename Fun BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
+    struct call<Fun(BOOST_PP_ENUM_PARAMS(N, A)...)> : transform<call<Fun(BOOST_PP_ENUM_PARAMS(N, A)...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : call<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , BOOST_PP_CAT(A, BOOST_PP_DEC(N))
+                  , detail::BOOST_PP_CAT(expand_pattern_rest_, BOOST_PP_DEC(N))<
+                        Fun
+                        BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_DEC(N), A)
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    #endif
 
     #undef N
 

Added: trunk/boost/proto/transform/detail/expand_pack.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/proto/transform/detail/expand_pack.hpp	2012-07-12 17:54:30 EDT (Thu, 12 Jul 2012)
@@ -0,0 +1,46 @@
+#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
+
+    #include <boost/proto/transform/detail/preprocessed/expand_pack.hpp>
+
+#elif !defined(BOOST_PP_IS_ITERATING)
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(preserve: 2, line: 0, output: "preprocessed/expand_pack.hpp")
+    #endif
+
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file expand_pack.hpp
+    /// Contains helpers for pseudo-pack expansion.
+    //
+    //  Copyright 2012 Eric Niebler. Distributed under the Boost
+    //  Software License, Version 1.0. (See accompanying file
+    //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(preserve: 1)
+    #endif
+
+    #define BOOST_PP_ITERATION_PARAMS_1                                                             \
+        (3, (0, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/detail/expand_pack.hpp>))
+    #include BOOST_PP_ITERATE()
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(output: null)
+    #endif
+
+#else
+    #define N BOOST_PP_ITERATION()
+    #define M0(Z, X, DATA) typename expand_pattern_helper<Tfx, BOOST_PP_CAT(A, X)>::type
+    #define M1(Z, X, DATA) expand_pattern_helper<Tfx, BOOST_PP_CAT(A, X)>::applied::value ||
+
+        template<typename Tfx, typename Ret BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
+        struct expand_pattern_helper<Tfx, Ret(BOOST_PP_ENUM_PARAMS(N, A))>
+        {
+            typedef Ret (*type)(BOOST_PP_ENUM(N, M0, ~));
+            typedef mpl::bool_<BOOST_PP_REPEAT(N, M1, ~) false> applied;
+        };
+
+    #undef M1
+    #undef M0
+    #undef N
+#endif

Modified: trunk/boost/proto/transform/detail/lazy.hpp
==============================================================================
--- trunk/boost/proto/transform/detail/lazy.hpp	(original)
+++ trunk/boost/proto/transform/detail/lazy.hpp	2012-07-12 17:54:30 EDT (Thu, 12 Jul 2012)
@@ -53,6 +53,27 @@
         {};
     };
 
+    #if N > 0
+    template<typename Object BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
+    struct lazy<Object(BOOST_PP_ENUM_PARAMS(N, A)...)>
+      : transform<lazy<Object(BOOST_PP_ENUM_PARAMS(N, A)...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : lazy<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , BOOST_PP_CAT(A, BOOST_PP_DEC(N))
+                  , detail::BOOST_PP_CAT(expand_pattern_rest_, BOOST_PP_DEC(N))<
+                        Object
+                        BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_DEC(N), A)
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    #endif
+
     #undef N
 
 #endif

Modified: trunk/boost/proto/transform/detail/make.hpp
==============================================================================
--- trunk/boost/proto/transform/detail/make.hpp	(original)
+++ trunk/boost/proto/transform/detail/make.hpp	2012-07-12 17:54:30 EDT (Thu, 12 Jul 2012)
@@ -173,6 +173,30 @@
         };
     };
 
+    #if N > 0
+    /// \brief A PrimitiveTransform which computes a type by evaluating any
+    /// nested transforms and then constructs an object of that type with the
+    /// current expression, state and data, transformed according
+    /// to \c A0 through \c AN.
+    template<typename Object BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
+    struct make<Object(BOOST_PP_ENUM_PARAMS(N, A)...)>
+      : transform<make<Object(BOOST_PP_ENUM_PARAMS(N, A)...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : make<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , BOOST_PP_CAT(A, BOOST_PP_DEC(N))
+                  , detail::BOOST_PP_CAT(expand_pattern_rest_, BOOST_PP_DEC(N))<
+                        Object
+                        BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_DEC(N), A)
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    #endif
     #undef N
 
 #endif

Added: trunk/boost/proto/transform/detail/pack.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/proto/transform/detail/pack.hpp	2012-07-12 17:54:30 EDT (Thu, 12 Jul 2012)
@@ -0,0 +1,90 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file pack.hpp
+/// Contains helpers for pseudo-pack expansion.
+//
+//  Copyright 2012 Eric Niebler. Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PROTO_TRANSFORM_DETAIL_PACK_HPP_EAN_2012_07_11
+#define BOOST_PROTO_TRANSFORM_DETAIL_PACK_HPP_EAN_2012_07_11
+
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/arithmetic/inc.hpp>
+#include <boost/preprocessor/arithmetic/dec.hpp>
+#include <boost/preprocessor/arithmetic/sub.hpp>
+#include <boost/preprocessor/punctuation/comma_if.hpp>
+#include <boost/preprocessor/repetition/enum.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
+#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
+#include <boost/preprocessor/repetition/repeat.hpp>
+#include <boost/preprocessor/iteration/local.hpp>
+#include <boost/preprocessor/iteration/iterate.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/proto/proto_fwd.hpp>
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma warning(push)
+# pragma warning(disable: 4348) // redefinition of default parameter
+#endif
+
+namespace boost { namespace proto
+{
+    namespace detail
+    {
+        template<typename Fun>
+        struct msvc_fun_workaround;
+
+        template<typename Tfx, typename T>
+        struct expand_pattern_helper
+        {
+            typedef T type;
+            typedef mpl::false_ applied;
+        };
+
+        template<typename Tfx, typename Fun>
+        struct expand_pattern_helper<Tfx, Fun *>
+          : expand_pattern_helper<Tfx, Fun>
+        {};
+
+        template<typename Tfx, typename T>
+        struct expand_pattern_helper<Tfx, pack(T)>
+        {
+            typedef Tfx type(T);
+            typedef mpl::true_ applied;
+        };
+
+        template<typename Tfx>
+        struct expand_pattern_helper<Tfx, pack(_)>
+        {
+            typedef Tfx type;
+            typedef mpl::true_ applied;
+        };
+
+        #include <boost/proto/transform/detail/expand_pack.hpp>
+
+        template<long Arity, typename Fun, typename Cont>
+        struct expand_pattern;
+
+        template<typename Fun, typename Cont>
+        struct expand_pattern<0, Fun, Cont>
+          : Cont::template cat<typename expand_pattern_helper<proto::_value, Fun>::type>
+        {
+            BOOST_MPL_ASSERT_MSG(
+                (expand_pattern_helper<proto::_value, Fun>::applied::value)
+              , NO_PACK_EXPRESSION_FOUND_IN_PACK_EXPANSION
+              , (Fun)
+            );
+        };
+
+        #include <boost/proto/transform/detail/pack_impl.hpp>
+    }
+}}
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma warning(pop)
+#endif
+
+#endif

Added: trunk/boost/proto/transform/detail/pack_impl.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/proto/transform/detail/pack_impl.hpp	2012-07-12 17:54:30 EDT (Thu, 12 Jul 2012)
@@ -0,0 +1,72 @@
+#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
+
+    #include <boost/proto/transform/detail/preprocessed/pack_impl.hpp>
+
+#elif !defined(BOOST_PP_IS_ITERATING)
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(preserve: 2, line: 0, output: "preprocessed/pack_impl.hpp")
+    #endif
+
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file pack_impl.hpp
+    /// Contains helpers for pseudo-pack expansion.
+    //
+    //  Copyright 2012 Eric Niebler. Distributed under the Boost
+    //  Software License, Version 1.0. (See accompanying file
+    //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(preserve: 1)
+    #endif
+
+    #define BOOST_PP_ITERATION_PARAMS_1                                                             \
+        (3, (0, BOOST_PP_DEC(BOOST_PROTO_MAX_ARITY), <boost/proto/transform/detail/pack_impl.hpp>))
+    #include BOOST_PP_ITERATE()
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(output: null)
+    #endif
+
+#else
+    #if BOOST_PP_ITERATION_DEPTH() == 1
+        #define N BOOST_PP_ITERATION()
+        #define M BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N)
+        #define M0(Z, X, D)  typename expand_pattern_helper<proto::_child_c<X>, Fun>::type
+
+        template<typename Fun, typename Cont>
+        struct expand_pattern<BOOST_PP_INC(N), Fun, Cont>
+          : Cont::template cat<BOOST_PP_ENUM(BOOST_PP_INC(N), M0, ~)>
+        {
+            BOOST_MPL_ASSERT_MSG(
+                (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value)
+              , NO_PACK_EXPRESSION_FOUND_IN_PACK_EXPANSION
+              , (Fun)
+            );
+        };
+
+        template<typename Ret BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
+        struct BOOST_PP_CAT(expand_pattern_rest_, N)
+        {
+            template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PP_INC(M), typename B, void)>
+            struct cat;
+
+            #define BOOST_PP_ITERATION_PARAMS_2                                                             \
+                (3, (1, M, <boost/proto/transform/detail/pack_impl.hpp>))
+            #include BOOST_PP_ITERATE()
+        };
+        #undef M0
+        #undef M
+        #undef N
+    #else
+        #define I BOOST_PP_ITERATION()
+        #define J BOOST_PP_RELATIVE_ITERATION(1)
+            template<BOOST_PP_ENUM_PARAMS(I, typename B)>
+            struct cat<BOOST_PP_ENUM_PARAMS(I, B)>
+            {
+                typedef msvc_fun_workaround<Ret(BOOST_PP_ENUM_PARAMS(J, A) BOOST_PP_COMMA_IF(J) BOOST_PP_ENUM_PARAMS(I, B))> type;
+            };
+        #undef J
+        #undef I
+    #endif
+#endif

Modified: trunk/boost/proto/transform/detail/preprocessed/call.hpp
==============================================================================
--- trunk/boost/proto/transform/detail/preprocessed/call.hpp	(original)
+++ trunk/boost/proto/transform/detail/preprocessed/call.hpp	2012-07-12 17:54:30 EDT (Thu, 12 Jul 2012)
@@ -8,6 +8,66 @@
     
     
     
+    template<typename Fun , typename A0>
+    struct call<Fun(A0...)> : transform<call<Fun(A0...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : call<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , A0
+                  , detail::expand_pattern_rest_0<
+                        Fun
+                        
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    
+    
+    
+    template<typename Fun , typename A0 , typename A1>
+    struct call<Fun(A0 , A1...)> : transform<call<Fun(A0 , A1...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : call<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , A1
+                  , detail::expand_pattern_rest_1<
+                        Fun
+                        , A0
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    
+    
+    
+    template<typename Fun , typename A0 , typename A1 , typename A2>
+    struct call<Fun(A0 , A1 , A2...)> : transform<call<Fun(A0 , A1 , A2...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : call<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , A2
+                  , detail::expand_pattern_rest_2<
+                        Fun
+                        , A0 , A1
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    
+    
+    
     template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3>
     struct call<Fun(A0 , A1 , A2 , A3)> : transform<call<Fun(A0 , A1 , A2 , A3)> >
     {
@@ -39,6 +99,26 @@
     
     
     
+    template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3>
+    struct call<Fun(A0 , A1 , A2 , A3...)> : transform<call<Fun(A0 , A1 , A2 , A3...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : call<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , A3
+                  , detail::expand_pattern_rest_3<
+                        Fun
+                        , A0 , A1 , A2
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    
+    
+    
     template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
     struct call<Fun(A0 , A1 , A2 , A3 , A4)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4)> >
     {
@@ -70,6 +150,26 @@
     
     
     
+    template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    struct call<Fun(A0 , A1 , A2 , A3 , A4...)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : call<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , A4
+                  , detail::expand_pattern_rest_4<
+                        Fun
+                        , A0 , A1 , A2 , A3
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    
+    
+    
     template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
     struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5)> >
     {
@@ -101,6 +201,26 @@
     
     
     
+    template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5...)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : call<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , A5
+                  , detail::expand_pattern_rest_5<
+                        Fun
+                        , A0 , A1 , A2 , A3 , A4
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    
+    
+    
     template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
     struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6)> >
     {
@@ -132,6 +252,26 @@
     
     
     
+    template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6...)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : call<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , A6
+                  , detail::expand_pattern_rest_6<
+                        Fun
+                        , A0 , A1 , A2 , A3 , A4 , A5
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    
+    
+    
     template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
     struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> >
     {
@@ -163,6 +303,26 @@
     
     
     
+    template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : call<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , A7
+                  , detail::expand_pattern_rest_7<
+                        Fun
+                        , A0 , A1 , A2 , A3 , A4 , A5 , A6
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    
+    
+    
     template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
     struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> >
     {
@@ -194,6 +354,26 @@
     
     
     
+    template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : call<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , A8
+                  , detail::expand_pattern_rest_8<
+                        Fun
+                        , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    
+    
+    
     template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
     struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> >
     {
@@ -222,3 +402,23 @@
             }
         };
     };
+    
+    
+    
+    template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : call<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , A9
+                  , detail::expand_pattern_rest_9<
+                        Fun
+                        , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };

Added: trunk/boost/proto/transform/detail/preprocessed/expand_pack.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/proto/transform/detail/preprocessed/expand_pack.hpp	2012-07-12 17:54:30 EDT (Thu, 12 Jul 2012)
@@ -0,0 +1,73 @@
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file expand_pack.hpp
+    /// Contains helpers for pseudo-pack expansion.
+    //
+    //  Copyright 2012 Eric Niebler. Distributed under the Boost
+    //  Software License, Version 1.0. (See accompanying file
+    //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+        template<typename Tfx, typename Ret >
+        struct expand_pattern_helper<Tfx, Ret()>
+        {
+            typedef Ret (*type)();
+            typedef mpl::bool_< false> applied;
+        };
+        template<typename Tfx, typename Ret , typename A0>
+        struct expand_pattern_helper<Tfx, Ret(A0)>
+        {
+            typedef Ret (*type)(typename expand_pattern_helper<Tfx, A0>::type);
+            typedef mpl::bool_<expand_pattern_helper<Tfx, A0>::applied::value || false> applied;
+        };
+        template<typename Tfx, typename Ret , typename A0 , typename A1>
+        struct expand_pattern_helper<Tfx, Ret(A0 , A1)>
+        {
+            typedef Ret (*type)(typename expand_pattern_helper<Tfx, A0>::type , typename expand_pattern_helper<Tfx, A1>::type);
+            typedef mpl::bool_<expand_pattern_helper<Tfx, A0>::applied::value || expand_pattern_helper<Tfx, A1>::applied::value || false> applied;
+        };
+        template<typename Tfx, typename Ret , typename A0 , typename A1 , typename A2>
+        struct expand_pattern_helper<Tfx, Ret(A0 , A1 , A2)>
+        {
+            typedef Ret (*type)(typename expand_pattern_helper<Tfx, A0>::type , typename expand_pattern_helper<Tfx, A1>::type , typename expand_pattern_helper<Tfx, A2>::type);
+            typedef mpl::bool_<expand_pattern_helper<Tfx, A0>::applied::value || expand_pattern_helper<Tfx, A1>::applied::value || expand_pattern_helper<Tfx, A2>::applied::value || false> applied;
+        };
+        template<typename Tfx, typename Ret , typename A0 , typename A1 , typename A2 , typename A3>
+        struct expand_pattern_helper<Tfx, Ret(A0 , A1 , A2 , A3)>
+        {
+            typedef Ret (*type)(typename expand_pattern_helper<Tfx, A0>::type , typename expand_pattern_helper<Tfx, A1>::type , typename expand_pattern_helper<Tfx, A2>::type , typename expand_pattern_helper<Tfx, A3>::type);
+            typedef mpl::bool_<expand_pattern_helper<Tfx, A0>::applied::value || expand_pattern_helper<Tfx, A1>::applied::value || expand_pattern_helper<Tfx, A2>::applied::value || expand_pattern_helper<Tfx, A3>::applied::value || false> applied;
+        };
+        template<typename Tfx, typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+        struct expand_pattern_helper<Tfx, Ret(A0 , A1 , A2 , A3 , A4)>
+        {
+            typedef Ret (*type)(typename expand_pattern_helper<Tfx, A0>::type , typename expand_pattern_helper<Tfx, A1>::type , typename expand_pattern_helper<Tfx, A2>::type , typename expand_pattern_helper<Tfx, A3>::type , typename expand_pattern_helper<Tfx, A4>::type);
+            typedef mpl::bool_<expand_pattern_helper<Tfx, A0>::applied::value || expand_pattern_helper<Tfx, A1>::applied::value || expand_pattern_helper<Tfx, A2>::applied::value || expand_pattern_helper<Tfx, A3>::applied::value || expand_pattern_helper<Tfx, A4>::applied::value || false> applied;
+        };
+        template<typename Tfx, typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+        struct expand_pattern_helper<Tfx, Ret(A0 , A1 , A2 , A3 , A4 , A5)>
+        {
+            typedef Ret (*type)(typename expand_pattern_helper<Tfx, A0>::type , typename expand_pattern_helper<Tfx, A1>::type , typename expand_pattern_helper<Tfx, A2>::type , typename expand_pattern_helper<Tfx, A3>::type , typename expand_pattern_helper<Tfx, A4>::type , typename expand_pattern_helper<Tfx, A5>::type);
+            typedef mpl::bool_<expand_pattern_helper<Tfx, A0>::applied::value || expand_pattern_helper<Tfx, A1>::applied::value || expand_pattern_helper<Tfx, A2>::applied::value || expand_pattern_helper<Tfx, A3>::applied::value || expand_pattern_helper<Tfx, A4>::applied::value || expand_pattern_helper<Tfx, A5>::applied::value || false> applied;
+        };
+        template<typename Tfx, typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+        struct expand_pattern_helper<Tfx, Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
+        {
+            typedef Ret (*type)(typename expand_pattern_helper<Tfx, A0>::type , typename expand_pattern_helper<Tfx, A1>::type , typename expand_pattern_helper<Tfx, A2>::type , typename expand_pattern_helper<Tfx, A3>::type , typename expand_pattern_helper<Tfx, A4>::type , typename expand_pattern_helper<Tfx, A5>::type , typename expand_pattern_helper<Tfx, A6>::type);
+            typedef mpl::bool_<expand_pattern_helper<Tfx, A0>::applied::value || expand_pattern_helper<Tfx, A1>::applied::value || expand_pattern_helper<Tfx, A2>::applied::value || expand_pattern_helper<Tfx, A3>::applied::value || expand_pattern_helper<Tfx, A4>::applied::value || expand_pattern_helper<Tfx, A5>::applied::value || expand_pattern_helper<Tfx, A6>::applied::value || false> applied;
+        };
+        template<typename Tfx, typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+        struct expand_pattern_helper<Tfx, Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
+        {
+            typedef Ret (*type)(typename expand_pattern_helper<Tfx, A0>::type , typename expand_pattern_helper<Tfx, A1>::type , typename expand_pattern_helper<Tfx, A2>::type , typename expand_pattern_helper<Tfx, A3>::type , typename expand_pattern_helper<Tfx, A4>::type , typename expand_pattern_helper<Tfx, A5>::type , typename expand_pattern_helper<Tfx, A6>::type , typename expand_pattern_helper<Tfx, A7>::type);
+            typedef mpl::bool_<expand_pattern_helper<Tfx, A0>::applied::value || expand_pattern_helper<Tfx, A1>::applied::value || expand_pattern_helper<Tfx, A2>::applied::value || expand_pattern_helper<Tfx, A3>::applied::value || expand_pattern_helper<Tfx, A4>::applied::value || expand_pattern_helper<Tfx, A5>::applied::value || expand_pattern_helper<Tfx, A6>::applied::value || expand_pattern_helper<Tfx, A7>::applied::value || false> applied;
+        };
+        template<typename Tfx, typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+        struct expand_pattern_helper<Tfx, Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
+        {
+            typedef Ret (*type)(typename expand_pattern_helper<Tfx, A0>::type , typename expand_pattern_helper<Tfx, A1>::type , typename expand_pattern_helper<Tfx, A2>::type , typename expand_pattern_helper<Tfx, A3>::type , typename expand_pattern_helper<Tfx, A4>::type , typename expand_pattern_helper<Tfx, A5>::type , typename expand_pattern_helper<Tfx, A6>::type , typename expand_pattern_helper<Tfx, A7>::type , typename expand_pattern_helper<Tfx, A8>::type);
+            typedef mpl::bool_<expand_pattern_helper<Tfx, A0>::applied::value || expand_pattern_helper<Tfx, A1>::applied::value || expand_pattern_helper<Tfx, A2>::applied::value || expand_pattern_helper<Tfx, A3>::applied::value || expand_pattern_helper<Tfx, A4>::applied::value || expand_pattern_helper<Tfx, A5>::applied::value || expand_pattern_helper<Tfx, A6>::applied::value || expand_pattern_helper<Tfx, A7>::applied::value || expand_pattern_helper<Tfx, A8>::applied::value || false> applied;
+        };
+        template<typename Tfx, typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+        struct expand_pattern_helper<Tfx, Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
+        {
+            typedef Ret (*type)(typename expand_pattern_helper<Tfx, A0>::type , typename expand_pattern_helper<Tfx, A1>::type , typename expand_pattern_helper<Tfx, A2>::type , typename expand_pattern_helper<Tfx, A3>::type , typename expand_pattern_helper<Tfx, A4>::type , typename expand_pattern_helper<Tfx, A5>::type , typename expand_pattern_helper<Tfx, A6>::type , typename expand_pattern_helper<Tfx, A7>::type , typename expand_pattern_helper<Tfx, A8>::type , typename expand_pattern_helper<Tfx, A9>::type);
+            typedef mpl::bool_<expand_pattern_helper<Tfx, A0>::applied::value || expand_pattern_helper<Tfx, A1>::applied::value || expand_pattern_helper<Tfx, A2>::applied::value || expand_pattern_helper<Tfx, A3>::applied::value || expand_pattern_helper<Tfx, A4>::applied::value || expand_pattern_helper<Tfx, A5>::applied::value || expand_pattern_helper<Tfx, A6>::applied::value || expand_pattern_helper<Tfx, A7>::applied::value || expand_pattern_helper<Tfx, A8>::applied::value || expand_pattern_helper<Tfx, A9>::applied::value || false> applied;
+        };

Modified: trunk/boost/proto/transform/detail/preprocessed/lazy.hpp
==============================================================================
--- trunk/boost/proto/transform/detail/preprocessed/lazy.hpp	(original)
+++ trunk/boost/proto/transform/detail/preprocessed/lazy.hpp	2012-07-12 17:54:30 EDT (Thu, 12 Jul 2012)
@@ -45,6 +45,24 @@
             >::template impl<Expr, State, Data>
         {};
     };
+    template<typename Object , typename A0>
+    struct lazy<Object(A0...)>
+      : transform<lazy<Object(A0...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : lazy<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , A0
+                  , detail::expand_pattern_rest_0<
+                        Object
+                        
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };
     
     
     
@@ -65,6 +83,24 @@
             >::template impl<Expr, State, Data>
         {};
     };
+    template<typename Object , typename A0 , typename A1>
+    struct lazy<Object(A0 , A1...)>
+      : transform<lazy<Object(A0 , A1...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : lazy<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , A1
+                  , detail::expand_pattern_rest_1<
+                        Object
+                        , A0
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };
     
     
     
@@ -85,6 +121,24 @@
             >::template impl<Expr, State, Data>
         {};
     };
+    template<typename Object , typename A0 , typename A1 , typename A2>
+    struct lazy<Object(A0 , A1 , A2...)>
+      : transform<lazy<Object(A0 , A1 , A2...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : lazy<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , A2
+                  , detail::expand_pattern_rest_2<
+                        Object
+                        , A0 , A1
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };
     
     
     
@@ -105,6 +159,24 @@
             >::template impl<Expr, State, Data>
         {};
     };
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3>
+    struct lazy<Object(A0 , A1 , A2 , A3...)>
+      : transform<lazy<Object(A0 , A1 , A2 , A3...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : lazy<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , A3
+                  , detail::expand_pattern_rest_3<
+                        Object
+                        , A0 , A1 , A2
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };
     
     
     
@@ -125,6 +197,24 @@
             >::template impl<Expr, State, Data>
         {};
     };
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    struct lazy<Object(A0 , A1 , A2 , A3 , A4...)>
+      : transform<lazy<Object(A0 , A1 , A2 , A3 , A4...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : lazy<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , A4
+                  , detail::expand_pattern_rest_4<
+                        Object
+                        , A0 , A1 , A2 , A3
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };
     
     
     
@@ -145,6 +235,24 @@
             >::template impl<Expr, State, Data>
         {};
     };
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5...)>
+      : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : lazy<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , A5
+                  , detail::expand_pattern_rest_5<
+                        Object
+                        , A0 , A1 , A2 , A3 , A4
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };
     
     
     
@@ -165,6 +273,24 @@
             >::template impl<Expr, State, Data>
         {};
     };
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6...)>
+      : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : lazy<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , A6
+                  , detail::expand_pattern_rest_6<
+                        Object
+                        , A0 , A1 , A2 , A3 , A4 , A5
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };
     
     
     
@@ -185,6 +311,24 @@
             >::template impl<Expr, State, Data>
         {};
     };
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)>
+      : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : lazy<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , A7
+                  , detail::expand_pattern_rest_7<
+                        Object
+                        , A0 , A1 , A2 , A3 , A4 , A5 , A6
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };
     
     
     
@@ -205,6 +349,24 @@
             >::template impl<Expr, State, Data>
         {};
     };
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)>
+      : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : lazy<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , A8
+                  , detail::expand_pattern_rest_8<
+                        Object
+                        , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };
     
     
     
@@ -225,3 +387,21 @@
             >::template impl<Expr, State, Data>
         {};
     };
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)>
+      : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : lazy<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , A9
+                  , detail::expand_pattern_rest_9<
+                        Object
+                        , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };

Modified: trunk/boost/proto/transform/detail/preprocessed/make.hpp
==============================================================================
--- trunk/boost/proto/transform/detail/preprocessed/make.hpp	(original)
+++ trunk/boost/proto/transform/detail/preprocessed/make.hpp	2012-07-12 17:54:30 EDT (Thu, 12 Jul 2012)
@@ -180,6 +180,28 @@
             }
         };
     };
+    
+    
+    
+    
+    template<typename Object , typename A0>
+    struct make<Object(A0...)>
+      : transform<make<Object(A0...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : make<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , A0
+                  , detail::expand_pattern_rest_0<
+                        Object
+                        
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };
     namespace detail
     {
         template<
@@ -282,6 +304,28 @@
             }
         };
     };
+    
+    
+    
+    
+    template<typename Object , typename A0 , typename A1>
+    struct make<Object(A0 , A1...)>
+      : transform<make<Object(A0 , A1...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : make<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , A1
+                  , detail::expand_pattern_rest_1<
+                        Object
+                        , A0
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };
     namespace detail
     {
         template<
@@ -384,6 +428,28 @@
             }
         };
     };
+    
+    
+    
+    
+    template<typename Object , typename A0 , typename A1 , typename A2>
+    struct make<Object(A0 , A1 , A2...)>
+      : transform<make<Object(A0 , A1 , A2...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : make<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , A2
+                  , detail::expand_pattern_rest_2<
+                        Object
+                        , A0 , A1
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };
     namespace detail
     {
         template<
@@ -486,6 +552,28 @@
             }
         };
     };
+    
+    
+    
+    
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3>
+    struct make<Object(A0 , A1 , A2 , A3...)>
+      : transform<make<Object(A0 , A1 , A2 , A3...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : make<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , A3
+                  , detail::expand_pattern_rest_3<
+                        Object
+                        , A0 , A1 , A2
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };
     namespace detail
     {
         template<
@@ -588,6 +676,28 @@
             }
         };
     };
+    
+    
+    
+    
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    struct make<Object(A0 , A1 , A2 , A3 , A4...)>
+      : transform<make<Object(A0 , A1 , A2 , A3 , A4...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : make<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , A4
+                  , detail::expand_pattern_rest_4<
+                        Object
+                        , A0 , A1 , A2 , A3
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };
     namespace detail
     {
         template<
@@ -690,6 +800,28 @@
             }
         };
     };
+    
+    
+    
+    
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    struct make<Object(A0 , A1 , A2 , A3 , A4 , A5...)>
+      : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : make<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , A5
+                  , detail::expand_pattern_rest_5<
+                        Object
+                        , A0 , A1 , A2 , A3 , A4
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };
     namespace detail
     {
         template<
@@ -792,6 +924,28 @@
             }
         };
     };
+    
+    
+    
+    
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6...)>
+      : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : make<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , A6
+                  , detail::expand_pattern_rest_6<
+                        Object
+                        , A0 , A1 , A2 , A3 , A4 , A5
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };
     namespace detail
     {
         template<
@@ -894,6 +1048,28 @@
             }
         };
     };
+    
+    
+    
+    
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)>
+      : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : make<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , A7
+                  , detail::expand_pattern_rest_7<
+                        Object
+                        , A0 , A1 , A2 , A3 , A4 , A5 , A6
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };
     namespace detail
     {
         template<
@@ -996,6 +1172,28 @@
             }
         };
     };
+    
+    
+    
+    
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)>
+      : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : make<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , A8
+                  , detail::expand_pattern_rest_8<
+                        Object
+                        , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };
     namespace detail
     {
         template<
@@ -1098,3 +1296,25 @@
             }
         };
     };
+    
+    
+    
+    
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)>
+      : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : make<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , A9
+                  , detail::expand_pattern_rest_9<
+                        Object
+                        , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };

Added: trunk/boost/proto/transform/detail/preprocessed/pack_impl.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/proto/transform/detail/preprocessed/pack_impl.hpp	2012-07-12 17:54:30 EDT (Thu, 12 Jul 2012)
@@ -0,0 +1,442 @@
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file pack_impl.hpp
+    /// Contains helpers for pseudo-pack expansion.
+    //
+    //  Copyright 2012 Eric Niebler. Distributed under the Boost
+    //  Software License, Version 1.0. (See accompanying file
+    //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+        template<typename Fun, typename Cont>
+        struct expand_pattern<1, Fun, Cont>
+          : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type>
+        {
+            BOOST_MPL_ASSERT_MSG(
+                (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value)
+              , NO_PACK_EXPRESSION_FOUND_IN_PACK_EXPANSION
+              , (Fun)
+            );
+        };
+        template<typename Ret >
+        struct expand_pattern_rest_0
+        {
+            template<typename B0 = void , typename B1 = void , typename B2 = void , typename B3 = void , typename B4 = void , typename B5 = void , typename B6 = void , typename B7 = void , typename B8 = void , typename B9 = void , typename B10 = void>
+            struct cat;
+            template<typename B0>
+            struct cat<B0>
+            {
+                typedef msvc_fun_workaround<Ret( B0)> type;
+            };
+            template<typename B0 , typename B1>
+            struct cat<B0 , B1>
+            {
+                typedef msvc_fun_workaround<Ret( B0 , B1)> type;
+            };
+            template<typename B0 , typename B1 , typename B2>
+            struct cat<B0 , B1 , B2>
+            {
+                typedef msvc_fun_workaround<Ret( B0 , B1 , B2)> type;
+            };
+            template<typename B0 , typename B1 , typename B2 , typename B3>
+            struct cat<B0 , B1 , B2 , B3>
+            {
+                typedef msvc_fun_workaround<Ret( B0 , B1 , B2 , B3)> type;
+            };
+            template<typename B0 , typename B1 , typename B2 , typename B3 , typename B4>
+            struct cat<B0 , B1 , B2 , B3 , B4>
+            {
+                typedef msvc_fun_workaround<Ret( B0 , B1 , B2 , B3 , B4)> type;
+            };
+            template<typename B0 , typename B1 , typename B2 , typename B3 , typename B4 , typename B5>
+            struct cat<B0 , B1 , B2 , B3 , B4 , B5>
+            {
+                typedef msvc_fun_workaround<Ret( B0 , B1 , B2 , B3 , B4 , B5)> type;
+            };
+            template<typename B0 , typename B1 , typename B2 , typename B3 , typename B4 , typename B5 , typename B6>
+            struct cat<B0 , B1 , B2 , B3 , B4 , B5 , B6>
+            {
+                typedef msvc_fun_workaround<Ret( B0 , B1 , B2 , B3 , B4 , B5 , B6)> type;
+            };
+            template<typename B0 , typename B1 , typename B2 , typename B3 , typename B4 , typename B5 , typename B6 , typename B7>
+            struct cat<B0 , B1 , B2 , B3 , B4 , B5 , B6 , B7>
+            {
+                typedef msvc_fun_workaround<Ret( B0 , B1 , B2 , B3 , B4 , B5 , B6 , B7)> type;
+            };
+            template<typename B0 , typename B1 , typename B2 , typename B3 , typename B4 , typename B5 , typename B6 , typename B7 , typename B8>
+            struct cat<B0 , B1 , B2 , B3 , B4 , B5 , B6 , B7 , B8>
+            {
+                typedef msvc_fun_workaround<Ret( B0 , B1 , B2 , B3 , B4 , B5 , B6 , B7 , B8)> type;
+            };
+            template<typename B0 , typename B1 , typename B2 , typename B3 , typename B4 , typename B5 , typename B6 , typename B7 , typename B8 , typename B9>
+            struct cat<B0 , B1 , B2 , B3 , B4 , B5 , B6 , B7 , B8 , B9>
+            {
+                typedef msvc_fun_workaround<Ret( B0 , B1 , B2 , B3 , B4 , B5 , B6 , B7 , B8 , B9)> type;
+            };
+        };
+        template<typename Fun, typename Cont>
+        struct expand_pattern<2, Fun, Cont>
+          : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type>
+        {
+            BOOST_MPL_ASSERT_MSG(
+                (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value)
+              , NO_PACK_EXPRESSION_FOUND_IN_PACK_EXPANSION
+              , (Fun)
+            );
+        };
+        template<typename Ret , typename A0>
+        struct expand_pattern_rest_1
+        {
+            template<typename B0 = void , typename B1 = void , typename B2 = void , typename B3 = void , typename B4 = void , typename B5 = void , typename B6 = void , typename B7 = void , typename B8 = void , typename B9 = void>
+            struct cat;
+            template<typename B0>
+            struct cat<B0>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , B0)> type;
+            };
+            template<typename B0 , typename B1>
+            struct cat<B0 , B1>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , B0 , B1)> type;
+            };
+            template<typename B0 , typename B1 , typename B2>
+            struct cat<B0 , B1 , B2>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , B0 , B1 , B2)> type;
+            };
+            template<typename B0 , typename B1 , typename B2 , typename B3>
+            struct cat<B0 , B1 , B2 , B3>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , B0 , B1 , B2 , B3)> type;
+            };
+            template<typename B0 , typename B1 , typename B2 , typename B3 , typename B4>
+            struct cat<B0 , B1 , B2 , B3 , B4>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , B0 , B1 , B2 , B3 , B4)> type;
+            };
+            template<typename B0 , typename B1 , typename B2 , typename B3 , typename B4 , typename B5>
+            struct cat<B0 , B1 , B2 , B3 , B4 , B5>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , B0 , B1 , B2 , B3 , B4 , B5)> type;
+            };
+            template<typename B0 , typename B1 , typename B2 , typename B3 , typename B4 , typename B5 , typename B6>
+            struct cat<B0 , B1 , B2 , B3 , B4 , B5 , B6>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , B0 , B1 , B2 , B3 , B4 , B5 , B6)> type;
+            };
+            template<typename B0 , typename B1 , typename B2 , typename B3 , typename B4 , typename B5 , typename B6 , typename B7>
+            struct cat<B0 , B1 , B2 , B3 , B4 , B5 , B6 , B7>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , B0 , B1 , B2 , B3 , B4 , B5 , B6 , B7)> type;
+            };
+            template<typename B0 , typename B1 , typename B2 , typename B3 , typename B4 , typename B5 , typename B6 , typename B7 , typename B8>
+            struct cat<B0 , B1 , B2 , B3 , B4 , B5 , B6 , B7 , B8>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , B0 , B1 , B2 , B3 , B4 , B5 , B6 , B7 , B8)> type;
+            };
+        };
+        template<typename Fun, typename Cont>
+        struct expand_pattern<3, Fun, Cont>
+          : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 2>, Fun>::type>
+        {
+            BOOST_MPL_ASSERT_MSG(
+                (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value)
+              , NO_PACK_EXPRESSION_FOUND_IN_PACK_EXPANSION
+              , (Fun)
+            );
+        };
+        template<typename Ret , typename A0 , typename A1>
+        struct expand_pattern_rest_2
+        {
+            template<typename B0 = void , typename B1 = void , typename B2 = void , typename B3 = void , typename B4 = void , typename B5 = void , typename B6 = void , typename B7 = void , typename B8 = void>
+            struct cat;
+            template<typename B0>
+            struct cat<B0>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , A1 , B0)> type;
+            };
+            template<typename B0 , typename B1>
+            struct cat<B0 , B1>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , A1 , B0 , B1)> type;
+            };
+            template<typename B0 , typename B1 , typename B2>
+            struct cat<B0 , B1 , B2>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , A1 , B0 , B1 , B2)> type;
+            };
+            template<typename B0 , typename B1 , typename B2 , typename B3>
+            struct cat<B0 , B1 , B2 , B3>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , A1 , B0 , B1 , B2 , B3)> type;
+            };
+            template<typename B0 , typename B1 , typename B2 , typename B3 , typename B4>
+            struct cat<B0 , B1 , B2 , B3 , B4>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , A1 , B0 , B1 , B2 , B3 , B4)> type;
+            };
+            template<typename B0 , typename B1 , typename B2 , typename B3 , typename B4 , typename B5>
+            struct cat<B0 , B1 , B2 , B3 , B4 , B5>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , A1 , B0 , B1 , B2 , B3 , B4 , B5)> type;
+            };
+            template<typename B0 , typename B1 , typename B2 , typename B3 , typename B4 , typename B5 , typename B6>
+            struct cat<B0 , B1 , B2 , B3 , B4 , B5 , B6>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , A1 , B0 , B1 , B2 , B3 , B4 , B5 , B6)> type;
+            };
+            template<typename B0 , typename B1 , typename B2 , typename B3 , typename B4 , typename B5 , typename B6 , typename B7>
+            struct cat<B0 , B1 , B2 , B3 , B4 , B5 , B6 , B7>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , A1 , B0 , B1 , B2 , B3 , B4 , B5 , B6 , B7)> type;
+            };
+        };
+        template<typename Fun, typename Cont>
+        struct expand_pattern<4, Fun, Cont>
+          : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 2>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 3>, Fun>::type>
+        {
+            BOOST_MPL_ASSERT_MSG(
+                (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value)
+              , NO_PACK_EXPRESSION_FOUND_IN_PACK_EXPANSION
+              , (Fun)
+            );
+        };
+        template<typename Ret , typename A0 , typename A1 , typename A2>
+        struct expand_pattern_rest_3
+        {
+            template<typename B0 = void , typename B1 = void , typename B2 = void , typename B3 = void , typename B4 = void , typename B5 = void , typename B6 = void , typename B7 = void>
+            struct cat;
+            template<typename B0>
+            struct cat<B0>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , B0)> type;
+            };
+            template<typename B0 , typename B1>
+            struct cat<B0 , B1>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , B0 , B1)> type;
+            };
+            template<typename B0 , typename B1 , typename B2>
+            struct cat<B0 , B1 , B2>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , B0 , B1 , B2)> type;
+            };
+            template<typename B0 , typename B1 , typename B2 , typename B3>
+            struct cat<B0 , B1 , B2 , B3>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , B0 , B1 , B2 , B3)> type;
+            };
+            template<typename B0 , typename B1 , typename B2 , typename B3 , typename B4>
+            struct cat<B0 , B1 , B2 , B3 , B4>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , B0 , B1 , B2 , B3 , B4)> type;
+            };
+            template<typename B0 , typename B1 , typename B2 , typename B3 , typename B4 , typename B5>
+            struct cat<B0 , B1 , B2 , B3 , B4 , B5>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , B0 , B1 , B2 , B3 , B4 , B5)> type;
+            };
+            template<typename B0 , typename B1 , typename B2 , typename B3 , typename B4 , typename B5 , typename B6>
+            struct cat<B0 , B1 , B2 , B3 , B4 , B5 , B6>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , B0 , B1 , B2 , B3 , B4 , B5 , B6)> type;
+            };
+        };
+        template<typename Fun, typename Cont>
+        struct expand_pattern<5, Fun, Cont>
+          : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 2>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 3>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 4>, Fun>::type>
+        {
+            BOOST_MPL_ASSERT_MSG(
+                (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value)
+              , NO_PACK_EXPRESSION_FOUND_IN_PACK_EXPANSION
+              , (Fun)
+            );
+        };
+        template<typename Ret , typename A0 , typename A1 , typename A2 , typename A3>
+        struct expand_pattern_rest_4
+        {
+            template<typename B0 = void , typename B1 = void , typename B2 = void , typename B3 = void , typename B4 = void , typename B5 = void , typename B6 = void>
+            struct cat;
+            template<typename B0>
+            struct cat<B0>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , B0)> type;
+            };
+            template<typename B0 , typename B1>
+            struct cat<B0 , B1>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , B0 , B1)> type;
+            };
+            template<typename B0 , typename B1 , typename B2>
+            struct cat<B0 , B1 , B2>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , B0 , B1 , B2)> type;
+            };
+            template<typename B0 , typename B1 , typename B2 , typename B3>
+            struct cat<B0 , B1 , B2 , B3>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , B0 , B1 , B2 , B3)> type;
+            };
+            template<typename B0 , typename B1 , typename B2 , typename B3 , typename B4>
+            struct cat<B0 , B1 , B2 , B3 , B4>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , B0 , B1 , B2 , B3 , B4)> type;
+            };
+            template<typename B0 , typename B1 , typename B2 , typename B3 , typename B4 , typename B5>
+            struct cat<B0 , B1 , B2 , B3 , B4 , B5>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , B0 , B1 , B2 , B3 , B4 , B5)> type;
+            };
+        };
+        template<typename Fun, typename Cont>
+        struct expand_pattern<6, Fun, Cont>
+          : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 2>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 3>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 4>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 5>, Fun>::type>
+        {
+            BOOST_MPL_ASSERT_MSG(
+                (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value)
+              , NO_PACK_EXPRESSION_FOUND_IN_PACK_EXPANSION
+              , (Fun)
+            );
+        };
+        template<typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+        struct expand_pattern_rest_5
+        {
+            template<typename B0 = void , typename B1 = void , typename B2 = void , typename B3 = void , typename B4 = void , typename B5 = void>
+            struct cat;
+            template<typename B0>
+            struct cat<B0>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , B0)> type;
+            };
+            template<typename B0 , typename B1>
+            struct cat<B0 , B1>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , B0 , B1)> type;
+            };
+            template<typename B0 , typename B1 , typename B2>
+            struct cat<B0 , B1 , B2>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , B0 , B1 , B2)> type;
+            };
+            template<typename B0 , typename B1 , typename B2 , typename B3>
+            struct cat<B0 , B1 , B2 , B3>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , B0 , B1 , B2 , B3)> type;
+            };
+            template<typename B0 , typename B1 , typename B2 , typename B3 , typename B4>
+            struct cat<B0 , B1 , B2 , B3 , B4>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , B0 , B1 , B2 , B3 , B4)> type;
+            };
+        };
+        template<typename Fun, typename Cont>
+        struct expand_pattern<7, Fun, Cont>
+          : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 2>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 3>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 4>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 5>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 6>, Fun>::type>
+        {
+            BOOST_MPL_ASSERT_MSG(
+                (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value)
+              , NO_PACK_EXPRESSION_FOUND_IN_PACK_EXPANSION
+              , (Fun)
+            );
+        };
+        template<typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+        struct expand_pattern_rest_6
+        {
+            template<typename B0 = void , typename B1 = void , typename B2 = void , typename B3 = void , typename B4 = void>
+            struct cat;
+            template<typename B0>
+            struct cat<B0>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , B0)> type;
+            };
+            template<typename B0 , typename B1>
+            struct cat<B0 , B1>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , B0 , B1)> type;
+            };
+            template<typename B0 , typename B1 , typename B2>
+            struct cat<B0 , B1 , B2>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , B0 , B1 , B2)> type;
+            };
+            template<typename B0 , typename B1 , typename B2 , typename B3>
+            struct cat<B0 , B1 , B2 , B3>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , B0 , B1 , B2 , B3)> type;
+            };
+        };
+        template<typename Fun, typename Cont>
+        struct expand_pattern<8, Fun, Cont>
+          : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 2>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 3>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 4>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 5>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 6>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 7>, Fun>::type>
+        {
+            BOOST_MPL_ASSERT_MSG(
+                (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value)
+              , NO_PACK_EXPRESSION_FOUND_IN_PACK_EXPANSION
+              , (Fun)
+            );
+        };
+        template<typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+        struct expand_pattern_rest_7
+        {
+            template<typename B0 = void , typename B1 = void , typename B2 = void , typename B3 = void>
+            struct cat;
+            template<typename B0>
+            struct cat<B0>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , B0)> type;
+            };
+            template<typename B0 , typename B1>
+            struct cat<B0 , B1>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , B0 , B1)> type;
+            };
+            template<typename B0 , typename B1 , typename B2>
+            struct cat<B0 , B1 , B2>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , B0 , B1 , B2)> type;
+            };
+        };
+        template<typename Fun, typename Cont>
+        struct expand_pattern<9, Fun, Cont>
+          : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 2>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 3>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 4>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 5>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 6>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 7>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 8>, Fun>::type>
+        {
+            BOOST_MPL_ASSERT_MSG(
+                (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value)
+              , NO_PACK_EXPRESSION_FOUND_IN_PACK_EXPANSION
+              , (Fun)
+            );
+        };
+        template<typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+        struct expand_pattern_rest_8
+        {
+            template<typename B0 = void , typename B1 = void , typename B2 = void>
+            struct cat;
+            template<typename B0>
+            struct cat<B0>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , B0)> type;
+            };
+            template<typename B0 , typename B1>
+            struct cat<B0 , B1>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , B0 , B1)> type;
+            };
+        };
+        template<typename Fun, typename Cont>
+        struct expand_pattern<10, Fun, Cont>
+          : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 2>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 3>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 4>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 5>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 6>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 7>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 8>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 9>, Fun>::type>
+        {
+            BOOST_MPL_ASSERT_MSG(
+                (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value)
+              , NO_PACK_EXPRESSION_FOUND_IN_PACK_EXPANSION
+              , (Fun)
+            );
+        };
+        template<typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+        struct expand_pattern_rest_9
+        {
+            template<typename B0 = void , typename B1 = void>
+            struct cat;
+            template<typename B0>
+            struct cat<B0>
+            {
+                typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , B0)> type;
+            };
+        };

Modified: trunk/boost/proto/transform/detail/preprocessed/when.hpp
==============================================================================
--- trunk/boost/proto/transform/detail/preprocessed/when.hpp	(original)
+++ trunk/boost/proto/transform/detail/preprocessed/when.hpp	2012-07-12 17:54:30 EDT (Thu, 12 Jul 2012)
@@ -33,46 +33,8 @@
     
     template<typename Grammar, typename R >
     struct when<Grammar, R()>
-      : transform<when<Grammar, R()> >
-    {
-        typedef Grammar first;
-        typedef R second();
-        typedef typename Grammar::proto_grammar proto_grammar;
-        
-        
-        template<typename Expr, typename State, typename Data>
-        struct impl : transform_impl<Expr, State, Data>
-        {
-            
-            typedef
-                typename mpl::if_c<
-                    is_callable<R>::value
-                  , call<R()> 
-                  , make<R()> 
-                >::type
-            which;
-            typedef typename which::template impl<Expr, State, Data>::result_type result_type;
-            
-            
-            
-            
-            
-            
-            
-            
-            
-            
-            BOOST_FORCEINLINE
-            result_type operator ()(
-                typename impl::expr_param e
-              , typename impl::state_param s
-              , typename impl::data_param d
-            ) const
-            {
-                return typename which::template impl<Expr, State, Data>()(e, s, d);
-            }
-        };
-    };
+      : detail::when_impl<Grammar, R, R()>
+    {};
     
     
     
@@ -101,46 +63,38 @@
     
     template<typename Grammar, typename R , typename A0>
     struct when<Grammar, R(A0)>
-      : transform<when<Grammar, R(A0)> >
-    {
-        typedef Grammar first;
-        typedef R second(A0);
-        typedef typename Grammar::proto_grammar proto_grammar;
-        
-        
-        template<typename Expr, typename State, typename Data>
-        struct impl : transform_impl<Expr, State, Data>
-        {
-            
-            typedef
-                typename mpl::if_c<
-                    is_callable<R>::value
-                  , call<R(A0)> 
-                  , make<R(A0)> 
-                >::type
-            which;
-            typedef typename which::template impl<Expr, State, Data>::result_type result_type;
-            
-            
-            
-            
-            
-            
-            
-            
-            
-            
-            BOOST_FORCEINLINE
-            result_type operator ()(
-                typename impl::expr_param e
-              , typename impl::state_param s
-              , typename impl::data_param d
-            ) const
-            {
-                return typename which::template impl<Expr, State, Data>()(e, s, d);
-            }
-        };
-    };
+      : detail::when_impl<Grammar, R, R(A0)>
+    {};
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    template<typename Grammar, typename R , typename A0>
+    struct when<Grammar, R(A0...)>
+      : detail::when_impl<Grammar, R, R(A0...)>
+    {};
     
     
     
@@ -169,46 +123,38 @@
     
     template<typename Grammar, typename R , typename A0 , typename A1>
     struct when<Grammar, R(A0 , A1)>
-      : transform<when<Grammar, R(A0 , A1)> >
-    {
-        typedef Grammar first;
-        typedef R second(A0 , A1);
-        typedef typename Grammar::proto_grammar proto_grammar;
-        
-        
-        template<typename Expr, typename State, typename Data>
-        struct impl : transform_impl<Expr, State, Data>
-        {
-            
-            typedef
-                typename mpl::if_c<
-                    is_callable<R>::value
-                  , call<R(A0 , A1)> 
-                  , make<R(A0 , A1)> 
-                >::type
-            which;
-            typedef typename which::template impl<Expr, State, Data>::result_type result_type;
-            
-            
-            
-            
-            
-            
-            
-            
-            
-            
-            BOOST_FORCEINLINE
-            result_type operator ()(
-                typename impl::expr_param e
-              , typename impl::state_param s
-              , typename impl::data_param d
-            ) const
-            {
-                return typename which::template impl<Expr, State, Data>()(e, s, d);
-            }
-        };
-    };
+      : detail::when_impl<Grammar, R, R(A0 , A1)>
+    {};
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    template<typename Grammar, typename R , typename A0 , typename A1>
+    struct when<Grammar, R(A0 , A1...)>
+      : detail::when_impl<Grammar, R, R(A0 , A1...)>
+    {};
     
     
     
@@ -237,46 +183,38 @@
     
     template<typename Grammar, typename R , typename A0 , typename A1 , typename A2>
     struct when<Grammar, R(A0 , A1 , A2)>
-      : transform<when<Grammar, R(A0 , A1 , A2)> >
-    {
-        typedef Grammar first;
-        typedef R second(A0 , A1 , A2);
-        typedef typename Grammar::proto_grammar proto_grammar;
-        
-        
-        template<typename Expr, typename State, typename Data>
-        struct impl : transform_impl<Expr, State, Data>
-        {
-            
-            typedef
-                typename mpl::if_c<
-                    is_callable<R>::value
-                  , call<R(A0 , A1 , A2)> 
-                  , make<R(A0 , A1 , A2)> 
-                >::type
-            which;
-            typedef typename which::template impl<Expr, State, Data>::result_type result_type;
-            
-            
-            
-            
-            
-            
-            
-            
-            
-            
-            BOOST_FORCEINLINE
-            result_type operator ()(
-                typename impl::expr_param e
-              , typename impl::state_param s
-              , typename impl::data_param d
-            ) const
-            {
-                return typename which::template impl<Expr, State, Data>()(e, s, d);
-            }
-        };
-    };
+      : detail::when_impl<Grammar, R, R(A0 , A1 , A2)>
+    {};
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    template<typename Grammar, typename R , typename A0 , typename A1 , typename A2>
+    struct when<Grammar, R(A0 , A1 , A2...)>
+      : detail::when_impl<Grammar, R, R(A0 , A1 , A2...)>
+    {};
     
     
     
@@ -305,46 +243,38 @@
     
     template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3>
     struct when<Grammar, R(A0 , A1 , A2 , A3)>
-      : transform<when<Grammar, R(A0 , A1 , A2 , A3)> >
-    {
-        typedef Grammar first;
-        typedef R second(A0 , A1 , A2 , A3);
-        typedef typename Grammar::proto_grammar proto_grammar;
-        
-        
-        template<typename Expr, typename State, typename Data>
-        struct impl : transform_impl<Expr, State, Data>
-        {
-            
-            typedef
-                typename mpl::if_c<
-                    is_callable<R>::value
-                  , call<R(A0 , A1 , A2 , A3)> 
-                  , make<R(A0 , A1 , A2 , A3)> 
-                >::type
-            which;
-            typedef typename which::template impl<Expr, State, Data>::result_type result_type;
-            
-            
-            
-            
-            
-            
-            
-            
-            
-            
-            BOOST_FORCEINLINE
-            result_type operator ()(
-                typename impl::expr_param e
-              , typename impl::state_param s
-              , typename impl::data_param d
-            ) const
-            {
-                return typename which::template impl<Expr, State, Data>()(e, s, d);
-            }
-        };
-    };
+      : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3)>
+    {};
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3>
+    struct when<Grammar, R(A0 , A1 , A2 , A3...)>
+      : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3...)>
+    {};
     
     
     
@@ -373,46 +303,38 @@
     
     template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
     struct when<Grammar, R(A0 , A1 , A2 , A3 , A4)>
-      : transform<when<Grammar, R(A0 , A1 , A2 , A3 , A4)> >
-    {
-        typedef Grammar first;
-        typedef R second(A0 , A1 , A2 , A3 , A4);
-        typedef typename Grammar::proto_grammar proto_grammar;
-        
-        
-        template<typename Expr, typename State, typename Data>
-        struct impl : transform_impl<Expr, State, Data>
-        {
-            
-            typedef
-                typename mpl::if_c<
-                    is_callable<R>::value
-                  , call<R(A0 , A1 , A2 , A3 , A4)> 
-                  , make<R(A0 , A1 , A2 , A3 , A4)> 
-                >::type
-            which;
-            typedef typename which::template impl<Expr, State, Data>::result_type result_type;
-            
-            
-            
-            
-            
-            
-            
-            
-            
-            
-            BOOST_FORCEINLINE
-            result_type operator ()(
-                typename impl::expr_param e
-              , typename impl::state_param s
-              , typename impl::data_param d
-            ) const
-            {
-                return typename which::template impl<Expr, State, Data>()(e, s, d);
-            }
-        };
-    };
+      : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4)>
+    {};
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    struct when<Grammar, R(A0 , A1 , A2 , A3 , A4...)>
+      : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4...)>
+    {};
     
     
     
@@ -441,46 +363,38 @@
     
     template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
     struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5)>
-      : transform<when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5)> >
-    {
-        typedef Grammar first;
-        typedef R second(A0 , A1 , A2 , A3 , A4 , A5);
-        typedef typename Grammar::proto_grammar proto_grammar;
-        
-        
-        template<typename Expr, typename State, typename Data>
-        struct impl : transform_impl<Expr, State, Data>
-        {
-            
-            typedef
-                typename mpl::if_c<
-                    is_callable<R>::value
-                  , call<R(A0 , A1 , A2 , A3 , A4 , A5)> 
-                  , make<R(A0 , A1 , A2 , A3 , A4 , A5)> 
-                >::type
-            which;
-            typedef typename which::template impl<Expr, State, Data>::result_type result_type;
-            
-            
-            
-            
-            
-            
-            
-            
-            
-            
-            BOOST_FORCEINLINE
-            result_type operator ()(
-                typename impl::expr_param e
-              , typename impl::state_param s
-              , typename impl::data_param d
-            ) const
-            {
-                return typename which::template impl<Expr, State, Data>()(e, s, d);
-            }
-        };
-    };
+      : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4 , A5)>
+    {};
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5...)>
+      : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4 , A5...)>
+    {};
     
     
     
@@ -509,46 +423,38 @@
     
     template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
     struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
-      : transform<when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6)> >
-    {
-        typedef Grammar first;
-        typedef R second(A0 , A1 , A2 , A3 , A4 , A5 , A6);
-        typedef typename Grammar::proto_grammar proto_grammar;
-        
-        
-        template<typename Expr, typename State, typename Data>
-        struct impl : transform_impl<Expr, State, Data>
-        {
-            
-            typedef
-                typename mpl::if_c<
-                    is_callable<R>::value
-                  , call<R(A0 , A1 , A2 , A3 , A4 , A5 , A6)> 
-                  , make<R(A0 , A1 , A2 , A3 , A4 , A5 , A6)> 
-                >::type
-            which;
-            typedef typename which::template impl<Expr, State, Data>::result_type result_type;
-            
-            
-            
-            
-            
-            
-            
-            
-            
-            
-            BOOST_FORCEINLINE
-            result_type operator ()(
-                typename impl::expr_param e
-              , typename impl::state_param s
-              , typename impl::data_param d
-            ) const
-            {
-                return typename which::template impl<Expr, State, Data>()(e, s, d);
-            }
-        };
-    };
+      : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
+    {};
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6...)>
+      : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4 , A5 , A6...)>
+    {};
     
     
     
@@ -577,46 +483,38 @@
     
     template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
     struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
-      : transform<when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> >
-    {
-        typedef Grammar first;
-        typedef R second(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7);
-        typedef typename Grammar::proto_grammar proto_grammar;
-        
-        
-        template<typename Expr, typename State, typename Data>
-        struct impl : transform_impl<Expr, State, Data>
-        {
-            
-            typedef
-                typename mpl::if_c<
-                    is_callable<R>::value
-                  , call<R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> 
-                  , make<R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> 
-                >::type
-            which;
-            typedef typename which::template impl<Expr, State, Data>::result_type result_type;
-            
-            
-            
-            
-            
-            
-            
-            
-            
-            
-            BOOST_FORCEINLINE
-            result_type operator ()(
-                typename impl::expr_param e
-              , typename impl::state_param s
-              , typename impl::data_param d
-            ) const
-            {
-                return typename which::template impl<Expr, State, Data>()(e, s, d);
-            }
-        };
-    };
+      : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
+    {};
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)>
+      : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)>
+    {};
     
     
     
@@ -645,46 +543,38 @@
     
     template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
     struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
-      : transform<when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> >
-    {
-        typedef Grammar first;
-        typedef R second(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8);
-        typedef typename Grammar::proto_grammar proto_grammar;
-        
-        
-        template<typename Expr, typename State, typename Data>
-        struct impl : transform_impl<Expr, State, Data>
-        {
-            
-            typedef
-                typename mpl::if_c<
-                    is_callable<R>::value
-                  , call<R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> 
-                  , make<R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> 
-                >::type
-            which;
-            typedef typename which::template impl<Expr, State, Data>::result_type result_type;
-            
-            
-            
-            
-            
-            
-            
-            
-            
-            
-            BOOST_FORCEINLINE
-            result_type operator ()(
-                typename impl::expr_param e
-              , typename impl::state_param s
-              , typename impl::data_param d
-            ) const
-            {
-                return typename which::template impl<Expr, State, Data>()(e, s, d);
-            }
-        };
-    };
+      : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
+    {};
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)>
+      : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)>
+    {};
     
     
     
@@ -713,43 +603,35 @@
     
     template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
     struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
-      : transform<when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> >
-    {
-        typedef Grammar first;
-        typedef R second(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9);
-        typedef typename Grammar::proto_grammar proto_grammar;
-        
-        
-        template<typename Expr, typename State, typename Data>
-        struct impl : transform_impl<Expr, State, Data>
-        {
-            
-            typedef
-                typename mpl::if_c<
-                    is_callable<R>::value
-                  , call<R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> 
-                  , make<R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> 
-                >::type
-            which;
-            typedef typename which::template impl<Expr, State, Data>::result_type result_type;
-            
-            
-            
-            
-            
-            
-            
-            
-            
-            
-            BOOST_FORCEINLINE
-            result_type operator ()(
-                typename impl::expr_param e
-              , typename impl::state_param s
-              , typename impl::data_param d
-            ) const
-            {
-                return typename which::template impl<Expr, State, Data>()(e, s, d);
-            }
-        };
-    };
+      : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
+    {};
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)>
+      : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)>
+    {};

Modified: trunk/boost/proto/transform/detail/when.hpp
==============================================================================
--- trunk/boost/proto/transform/detail/when.hpp	(original)
+++ trunk/boost/proto/transform/detail/when.hpp	2012-07-12 17:54:30 EDT (Thu, 12 Jul 2012)
@@ -60,50 +60,41 @@
     /// ObjectTransforms.
     template<typename Grammar, typename R BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
     struct when<Grammar, R(BOOST_PP_ENUM_PARAMS(N, A))>
-      : transform<when<Grammar, R(BOOST_PP_ENUM_PARAMS(N, A))> >
-    {
-        typedef Grammar first;
-        typedef R second(BOOST_PP_ENUM_PARAMS(N, A));
-        typedef typename Grammar::proto_grammar proto_grammar;
+      : detail::when_impl<Grammar, R, R(BOOST_PP_ENUM_PARAMS(N, A))>
+    {};
 
-        // Note: do not evaluate is_callable<R> in this scope.
-        // R may be an incomplete type at this point.
-
-        template<typename Expr, typename State, typename Data>
-        struct impl : transform_impl<Expr, State, Data>
-        {
-            // OK to evaluate is_callable<R> here. R should be compete by now.
-            typedef
-                typename mpl::if_c<
-                    is_callable<R>::value
-                  , call<R(BOOST_PP_ENUM_PARAMS(N, A))> // "R" is a function to call
-                  , make<R(BOOST_PP_ENUM_PARAMS(N, A))> // "R" is an object to construct
-                >::type
-            which;
-
-            typedef typename which::template impl<Expr, State, Data>::result_type result_type;
-
-            /// Evaluate <tt>R(A0,A1,...)</tt> as a transform either with
-            /// <tt>call\<\></tt> or with <tt>make\<\></tt> depending on
-            /// whether <tt>is_callable\<R\>::value</tt> is \c true or
-            /// \c false.
-            ///
-            /// \param e The current expression
-            /// \param s The current state
-            /// \param d An arbitrary data
-            /// \pre <tt>matches\<Expr, Grammar\>::value</tt> is \c true
-            /// \return <tt>which()(e, s, d)</tt>
-            BOOST_FORCEINLINE
-            result_type operator ()(
-                typename impl::expr_param   e
-              , typename impl::state_param  s
-              , typename impl::data_param   d
-            ) const
-            {
-                return typename which::template impl<Expr, State, Data>()(e, s, d);
-            }
-        };
-    };
+    #if N > 0
+    /// \brief A grammar element and a PrimitiveTransform that associates
+    /// a transform with the grammar.
+    ///
+    /// Use <tt>when\<\></tt> to override a grammar's default transform
+    /// with a custom transform. It is for used when composing larger
+    /// transforms by associating smaller transforms with individual
+    /// rules in your grammar, as in the following transform which
+    /// counts the number of terminals in an expression.
+    ///
+    /// \code
+    /// // Count the terminals in an expression tree.
+    /// // Must be invoked with initial state == mpl::int_<0>().
+    /// struct CountLeaves
+    ///   : or_<
+    ///         when<terminal<_>, mpl::next<_state>()>
+    ///       , otherwise<fold<_, _state, CountLeaves> >
+    ///     >
+    /// {};
+    /// \endcode
+    ///
+    /// The <tt>when\<G, R(A0,A1,...)\></tt> form accepts either a
+    /// CallableTransform or an ObjectTransform as its second parameter.
+    /// <tt>when\<\></tt> uses <tt>is_callable\<R\>::value</tt> to
+    /// distinguish between the two, and uses <tt>call\<\></tt> to
+    /// evaluate CallableTransforms and <tt>make\<\></tt> to evaluate
+    /// ObjectTransforms.
+    template<typename Grammar, typename R BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
+    struct when<Grammar, R(BOOST_PP_ENUM_PARAMS(N, A)...)>
+      : detail::when_impl<Grammar, R, R(BOOST_PP_ENUM_PARAMS(N, A)...)>
+    {};
+    #endif
 
     #undef N
 

Modified: trunk/boost/proto/transform/lazy.hpp
==============================================================================
--- trunk/boost/proto/transform/lazy.hpp	(original)
+++ trunk/boost/proto/transform/lazy.hpp	2012-07-12 17:54:30 EDT (Thu, 12 Jul 2012)
@@ -16,6 +16,7 @@
 #include <boost/proto/transform/make.hpp>
 #include <boost/proto/transform/call.hpp>
 #include <boost/proto/transform/impl.hpp>
+#include <boost/proto/transform/detail/pack.hpp>
 
 namespace boost { namespace proto
 {
@@ -38,6 +39,12 @@
         {};
     };
 
+    /// INTERNAL ONLY
+    template<typename Fun>
+    struct lazy<detail::msvc_fun_workaround<Fun> >
+      : lazy<Fun>
+    {};
+
     #include <boost/proto/transform/detail/lazy.hpp>
 
     /// INTERNAL ONLY

Modified: trunk/boost/proto/transform/make.hpp
==============================================================================
--- trunk/boost/proto/transform/make.hpp	(original)
+++ trunk/boost/proto/transform/make.hpp	2012-07-12 17:54:30 EDT (Thu, 12 Jul 2012)
@@ -29,6 +29,7 @@
 #include <boost/proto/traits.hpp>
 #include <boost/proto/args.hpp>
 #include <boost/proto/transform/impl.hpp>
+#include <boost/proto/transform/detail/pack.hpp>
 #include <boost/proto/detail/as_lvalue.hpp>
 #include <boost/proto/detail/ignore_unused.hpp>
 
@@ -250,6 +251,12 @@
         };
     };
 
+    /// INTERNAL ONLY
+    template<typename Fun>
+    struct make<detail::msvc_fun_workaround<Fun> >
+      : make<Fun>
+    {};
+
     // Other specializations generated by the preprocessor.
     #include <boost/proto/transform/detail/make.hpp>
     #include <boost/proto/transform/detail/make_gcc_workaround.hpp>

Modified: trunk/boost/proto/transform/when.hpp
==============================================================================
--- trunk/boost/proto/transform/when.hpp	(original)
+++ trunk/boost/proto/transform/when.hpp	2012-07-12 17:54:30 EDT (Thu, 12 Jul 2012)
@@ -29,6 +29,56 @@
 
 namespace boost { namespace proto
 {
+    namespace detail
+    {
+        template<typename Grammar, typename R, typename Fun>
+        struct when_impl
+          : transform<when<Grammar, Fun> >
+        {
+            typedef Grammar first;
+            typedef Fun second;
+            typedef typename Grammar::proto_grammar proto_grammar;
+
+            // Note: do not evaluate is_callable<R> in this scope.
+            // R may be an incomplete type at this point.
+
+            template<typename Expr, typename State, typename Data>
+            struct impl : transform_impl<Expr, State, Data>
+            {
+                // OK to evaluate is_callable<R> here. R should be compete by now.
+                typedef
+                    typename mpl::if_c<
+                        is_callable<R>::value
+                      , proto::call<Fun> // "R" is a function to call
+                      , proto::make<Fun> // "R" is an object to construct
+                    >::type
+                which;
+
+                typedef typename which::template impl<Expr, State, Data>::result_type result_type;
+
+                /// Evaluate <tt>R(A0,A1,...)</tt> as a transform either with
+                /// <tt>call\<\></tt> or with <tt>make\<\></tt> depending on
+                /// whether <tt>is_callable\<R\>::value</tt> is \c true or
+                /// \c false.
+                ///
+                /// \param e The current expression
+                /// \param s The current state
+                /// \param d An arbitrary data
+                /// \pre <tt>matches\<Expr, Grammar\>::value</tt> is \c true
+                /// \return <tt>which()(e, s, d)</tt>
+                BOOST_FORCEINLINE
+                result_type operator ()(
+                    typename impl::expr_param   e
+                  , typename impl::state_param  s
+                  , typename impl::data_param   d
+                ) const
+                {
+                    return typename which::template impl<Expr, State, Data>()(e, s, d);
+                }
+            };
+        };
+    }
+
     /// \brief A grammar element and a PrimitiveTransform that associates
     /// a transform with the grammar.
     ///

Modified: trunk/libs/proto/preprocess/Jamfile.v2
==============================================================================
--- trunk/libs/proto/preprocess/Jamfile.v2	(original)
+++ trunk/libs/proto/preprocess/Jamfile.v2	2012-07-12 17:54:30 EDT (Thu, 12 Jul 2012)
@@ -6,7 +6,7 @@
 
 actions wave
 {
-  $(>[2]) -o- -DBOOST_PROTO_MAX_ARITY=5 --config-file wave.cfg $(>[1])
+  $(>[2]) -o- -DBOOST_PROTO_MAX_ARITY=10 --config-file wave.cfg $(>[1])
 }
 
 W = ../../../tools/wave/build//wave ;

Modified: trunk/libs/proto/preprocess/wave.cfg
==============================================================================
--- trunk/libs/proto/preprocess/wave.cfg	(original)
+++ trunk/libs/proto/preprocess/wave.cfg	2012-07-12 17:54:30 EDT (Thu, 12 Jul 2012)
@@ -16,6 +16,9 @@
 -NBOOST_PROTO_GET_POINTER
 -NBOOST_PROTO_ASSERT_VALID_DOMAIN
 -NBOOST_FORCEINLINE
+-NBOOST_MPL_ASSERT
+-NBOOST_MPL_ASSERT_MSG
+-NBOOST_MPL_ASSERT_RELATION
 -S../../..
 -S"C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\include"
 -S.

Modified: trunk/libs/proto/test/Jamfile.v2
==============================================================================
--- trunk/libs/proto/test/Jamfile.v2	(original)
+++ trunk/libs/proto/test/Jamfile.v2	2012-07-12 17:54:30 EDT (Thu, 12 Jul 2012)
@@ -35,8 +35,9 @@
         [ run toy_spirit.cpp ]
         [ run toy_spirit2.cpp ]
         [ run make.cpp ]
-        [ run noinvoke.cpp ]
         [ run mem_ptr.cpp : : : <toolset>msvc:<cxxflags>/wd4355 ]
+        [ run noinvoke.cpp ]
+        [ run pack_expansion.cpp ]
         [ compile bug2407.cpp ]
     ;
 

Added: trunk/libs/proto/test/pack_expansion.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/proto/test/pack_expansion.cpp	2012-07-12 17:54:30 EDT (Thu, 12 Jul 2012)
@@ -0,0 +1,109 @@
+///////////////////////////////////////////////////////////////////////////////
+// pack_expansion.hpp
+//
+//  Copyright 2008 Eric Niebler. Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/proto/proto.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/typeof/typeof.hpp>
+
+namespace mpl = boost::mpl;
+namespace proto = boost::proto;
+using proto::_;
+
+template<typename T> T declval();
+
+struct eval_ : proto::callable
+{
+    template<typename Sig>
+    struct result;
+
+    template<typename This, typename Left, typename Right>
+    struct result<This(proto::tag::plus, Left, Right)>
+    {
+        typedef BOOST_TYPEOF_TPL(declval<Left>() + declval<Right>()) type;
+    };
+
+    template<typename This, typename Left, typename Right>
+    struct result<This(proto::tag::multiplies, Left, Right)>
+    {
+        typedef BOOST_TYPEOF_TPL(declval<Left>() * declval<Right>()) type;
+    };
+
+    template<typename Left, typename Right>
+    typename result<eval_(proto::tag::plus, Left, Right)>::type
+    operator()(proto::tag::plus, Left left, Right right) const
+    {
+        return left + right;
+    }
+
+    template<typename Left, typename Right>
+    typename result<eval_(proto::tag::multiplies, Left, Right)>::type
+    operator()(proto::tag::multiplies, Left left, Right right) const
+    {
+        return left * right;
+    }
+};
+
+struct eval1
+  : proto::or_<
+        proto::when<proto::terminal<_>, proto::_value>
+      , proto::otherwise<eval_(proto::tag_of<_>(), eval1(proto::pack(_))...)>
+    >
+{};
+
+struct eval2
+  : proto::or_<
+        proto::when<proto::terminal<_>, proto::_value>
+      , proto::otherwise<proto::call<eval_(proto::tag_of<_>(), eval2(proto::pack(_))...)> >
+    >
+{};
+
+void test_call_pack()
+{
+    proto::terminal<int>::type i = {42};
+    int res = eval1()(i + 2);
+    BOOST_CHECK_EQUAL(res, 44);
+    res = eval1()(i * 2);
+    BOOST_CHECK_EQUAL(res, 84);
+    res = eval1()(i * 2 + 4);
+    BOOST_CHECK_EQUAL(res, 88);
+
+    res = eval2()(i + 2);
+    BOOST_CHECK_EQUAL(res, 44);
+    res = eval2()(i * 2);
+    BOOST_CHECK_EQUAL(res, 84);
+    res = eval2()(i * 2 + 4);
+    BOOST_CHECK_EQUAL(res, 88);
+}
+
+struct make_pair
+  : proto::when<
+        proto::binary_expr<_, proto::terminal<int>, proto::terminal<int> >
+      , std::pair<int, int>(proto::_value(proto::pack(_))...)
+    >
+{};
+
+void test_make_pack()
+{
+    proto::terminal<int>::type i = {42};
+    std::pair<int, int> p = make_pair()(i + 43);
+    BOOST_CHECK_EQUAL(p.first, 42);
+    BOOST_CHECK_EQUAL(p.second, 43);
+}
+
+using namespace boost::unit_test;
+///////////////////////////////////////////////////////////////////////////////
+// init_unit_test_suite
+//
+test_suite* init_unit_test_suite( int argc, char* argv[] )
+{
+    test_suite *test = BOOST_TEST_SUITE("test immediate evaluation of proto parse trees");
+
+    test->add(BOOST_TEST_CASE(&test_call_pack));
+    test->add(BOOST_TEST_CASE(&test_make_pack));
+
+    return test;
+}