Index: boost/proto/proto_fwd.hpp
===================================================================
--- boost/proto/proto_fwd.hpp	(revision 74374)
+++ boost/proto/proto_fwd.hpp	(working copy)
@@ -269,6 +269,9 @@
 
     using namespace tagns_;
 
+    template<typename Expr>
+    struct tag_of;
+
     ////////////////////////////////////////////////////////////////////////////////////////////////
     struct _;
 
@@ -359,7 +362,7 @@
     template<typename Condition, typename Then = _, typename Else = not_<_> >
     struct if_;
 
-    template<typename Cases>
+    template<typename Cases, typename Transform = tag_of<_>() >
     struct switch_;
 
     template<typename T>
@@ -462,9 +465,6 @@
     struct is_sub_domain_of;
 
     template<typename Expr>
-    struct tag_of;
-
-    template<typename Expr>
     struct arity_of;
 
     template<typename T, typename Void = void>
@@ -741,7 +741,7 @@
     template<typename Grammar>
     struct pass_through;
 
-    template<typename Grammar = detail::_default>
+    template<typename Grammar = detail::_default >
     struct _default;
 
     struct _expr;
Index: boost/proto/matches.hpp
===================================================================
--- boost/proto/matches.hpp	(revision 74374)
+++ boost/proto/matches.hpp	(working copy)
@@ -10,6 +10,7 @@
 #ifndef BOOST_PROTO_MATCHES_HPP_EAN_11_03_2006
 #define BOOST_PROTO_MATCHES_HPP_EAN_11_03_2006
 
+
 #include <boost/config.hpp>
 #include <boost/detail/workaround.hpp>
 #include <boost/preprocessor/cat.hpp>
@@ -402,14 +403,26 @@
         {};
 
         // handle proto::switch_
-        template<typename Expr, typename Tag, typename Args, long Arity, typename Cases>
-        struct matches_<Expr, proto::basic_expr<Tag, Args, Arity>, switch_<Cases> >
-          : matches_<
-                Expr
-              , proto::basic_expr<Tag, Args, Arity>
-              , typename Cases::template case_<Tag>::proto_grammar
-            >
+        template< typename Expr, typename Tag, typename Args, long Arity, typename Cases, typename Transform>
+        struct matches_ < Expr, proto::basic_expr<Tag, Args, Arity>, switch_<Cases,Transform> >
+          : matches_< Expr, proto::basic_expr<Tag, Args, Arity>
+                    , typename Cases::template case_<typename
+                      when<_,Transform>::template impl<Expr,int,int>::result_type
+                          >::proto_grammar
+                    >
         {
+            typedef when<_,Transform> applicant;
+            typedef typename applicant::template impl<Expr,int,int>::result_type selected_type;
+            typedef typename Cases::template case_<selected_type> which;
+        };
+
+        template< typename Expr, typename Tag, typename Args, long Arity, typename Cases >
+        struct matches_ < Expr, proto::basic_expr<Tag, Args, Arity> , switch_<Cases> >
+          : matches_< Expr, proto::basic_expr<Tag, Args, Arity>
+                    , typename  Cases::template
+                      case_<Tag>::proto_grammar
+                    >
+        {
             typedef typename Cases::template case_<Tag> which;
         };
     }
@@ -449,6 +462,9 @@
     ///     not match \c T.
     /// \li An expression \c E matches <tt>switch_\<C\></tt> if
     ///     \c E matches <tt>C::case_\<E::proto_tag\></tt>.
+    /// \li An expression \c E matches <tt>switch_\<C,T\></tt> if
+    ///     the result type of the transform \c T on \c E matches
+    ///     <tt>C::case_\<boost::result_of\<T(E)\>::type\></tt>.
     ///
     /// A terminal expression <tt>expr\<AT,term\<A\> \></tt> matches
     /// a grammar <tt>expr\<BT,term\<B\> \></tt> if \c BT is \c AT or
@@ -784,26 +800,31 @@
     /// When applying <tt>switch_\<C\></tt> as a transform with an
     /// expression \c e of type \c E, state \c s and data \c d, it is
     /// equivalent to <tt>C::case_\<E::proto_tag\>()(e, s, d)</tt>.
-    template<typename Cases>
-    struct switch_ : transform<switch_<Cases> >
+    template<typename Cases, typename Transform>
+    struct switch_ : transform< switch_<Cases,Transform> >
     {
         typedef switch_ proto_grammar;
+        typedef when<_,Transform> applicant;
 
         /// \param e An expression
         /// \param s The current state
         /// \param d A data of arbitrary type
         /// \pre <tt>matches\<Expr,switch_\>::value</tt> is \c true.
         /// \return <tt>which()(e, s, d)</tt>, where <tt>which</tt> is
-        /// <tt>Cases::case_<typename Expr::proto_tag></tt>
+        /// <tt>Cases::case_< typename boost::result_of< Transform(Expr) >::type ></tt>
 
         template<typename Expr, typename State, typename Data>
         struct impl
-          : Cases::template case_<typename Expr::proto_tag>::template impl<Expr, State, Data>
+        : Cases::template
+            case_ < typename applicant::template impl<Expr,State,Data>::result_type
+            >::template impl<Expr, State, Data>
         {};
 
         template<typename Expr, typename State, typename Data>
         struct impl<Expr &, State, Data>
-          : Cases::template case_<typename Expr::proto_tag>::template impl<Expr &, State, Data>
+        : Cases::template
+            case_ <typename applicant::template impl<Expr,State,Data>::result_type
+            >::template impl<Expr &, State, Data>
         {};
     };
 
@@ -901,8 +922,8 @@
 
     /// INTERNAL ONLY
     ///
-    template<typename Cases>
-    struct is_callable<switch_<Cases> >
+    template<typename Cases, typename Transform>
+    struct is_callable<switch_<Cases,Transform> >
       : mpl::true_
     {};
 
Index: libs/proto/test/new_switch.cpp
===================================================================
--- libs/proto/test/new_switch.cpp	(revision 0)
+++ libs/proto/test/new_switch.cpp	(revision 0)
@@ -0,0 +1,94 @@
+///////////////////////////////////////////////////////////////////////////////
+// new_switch.cpp
+//
+//  Copyright 2011 Eric Niebler
+//  Copyright Pierre Esterie & Joel Falcou.
+//  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/core.hpp>
+#include <boost/proto/transform.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/proto/debug.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/mpl/long.hpp>
+#include <boost/mpl/bool.hpp>
+
+using namespace boost;
+using namespace proto;
+
+struct MyCases
+{
+    template<typename Tag>
+    struct case_
+    : proto::not_<proto::_>
+    {};
+};
+
+template<>
+struct MyCases::case_<proto::tag::shift_right>
+: proto::_
+{};
+
+template<>
+struct MyCases::case_<proto::tag::plus>
+: proto::_
+{};
+
+struct ArityOf;
+
+struct ArityOfCases
+{
+    template<typename ArityOf>
+    struct  case_
+    :  proto::not_<proto::_> {};
+};
+
+
+template<>
+struct  ArityOfCases::case_< boost::mpl::long_<1> >
+: boost::proto::when<boost::proto::_,boost::mpl::false_() >
+{};
+
+template<>
+struct  ArityOfCases::case_< boost::mpl::long_<2> >
+: boost::proto::when<boost::proto::_, boost::mpl::true_() >
+{};
+
+struct ArityOf
+: boost::proto::switch_ < ArityOfCases
+                        , proto::arity_of<proto::_>()
+                        >
+{};
+
+void test_switch()
+{
+    // Tests for backward compatibility
+    assert_matches< proto::switch_<MyCases> >( lit(1) >> 'a' );
+    assert_matches< proto::switch_<MyCases> >( lit(1) + 'a' );
+    assert_matches_not< proto::switch_<MyCases> >( lit(1) << 'a' );
+
+    //Test new matching on the Transform result type
+    ArityOf ar;
+
+    assert_matches_not< ArityOf >( lit(1) );
+    assert_matches< ArityOf >( lit(1) + 2 );
+    assert_matches< ArityOf >( !lit(1));
+    BOOST_CHECK_EQUAL( ar( !lit(1) ), false);
+    BOOST_CHECK_EQUAL( ar( lit(1) + 2 ), true);
+}
+
+using namespace unit_test;
+///////////////////////////////////////////////////////////////////////////////
+// init_unit_test_suite
+//
+test_suite* init_unit_test_suite( int argc, char* argv[] )
+{
+    test_suite *test = BOOST_TEST_SUITE("test proto::switch_<>");
+
+    test->add(BOOST_TEST_CASE(&test_switch));
+
+    return test;
+}
+
Index: libs/proto/test/Jamfile.v2
===================================================================
--- libs/proto/test/Jamfile.v2	(revision 74374)
+++ libs/proto/test/Jamfile.v2	(working copy)
@@ -31,6 +31,7 @@
         [ run make_expr.cpp ]
         [ run matches.cpp ]
         [ run flatten.cpp ]
+        [ run new_switch.cpp ]
         [ run toy_spirit.cpp ]
         [ run toy_spirit2.cpp ]
         [ run make.cpp ]
Index: libs/proto/doc/reference/matches.xml
===================================================================
--- libs/proto/doc/reference/matches.xml	(revision 74374)
+++ libs/proto/doc/reference/matches.xml	(working copy)
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <header name="boost/proto/matches.hpp">
   <para>
     Contains definition of the
@@ -427,10 +427,13 @@
       <struct name="switch_">
         <template>
           <template-type-parameter name="Cases"/>
+	  <template-type-parameter name="Transform"/>
         </template>
-        <inherit><classname>proto::transform</classname>&lt;switch_&lt;Cases&gt; &gt;</inherit>
-        <purpose>For matching one of a set of alternate grammars, which are looked up based on an
-          expression's tag type. When used as a transform,
+        <inherit><classname>proto::transform</classname>&lt;switch_&lt;Cases, Transform&gt; &gt;</inherit>
+        <purpose>For matching one of a set of alternate grammars, which are looked up based on
+          the result type of the transform passed in second template parameter. 
+	  If no transform is passed, the default one is <computeroutput>proto::tag_of()</computeroutput>
+	  so the default matching is based on the expression's tag type. When used as a transform,
           <computeroutput>proto::switch_&lt;&gt;</computeroutput> applies the transform associated
           with the sub-grammar that matches the expression.</purpose>
         <description>
@@ -439,6 +442,13 @@
             <computeroutput>proto::switch_&lt;C&gt;</computeroutput> if
             <computeroutput>E</computeroutput> matches
             <computeroutput>C::case_&lt;E::proto_tag&gt;</computeroutput>.
+	  </para>
+	  <para>
+	    An expression type <computeroutput>E</computeroutput> matches
+            <computeroutput>proto::switch_&lt;C,T&gt;</computeroutput> if
+            the result type of the transform <computeroutput>T</computeroutput> 
+	    on <computeroutput>E</computeroutput> matches
+            <computeroutput>C::case_&lt;boost::result_of&lt;T(E)&gt; &gt;</computeroutput>.
           </para>
           <para>
             When applying <computeroutput>proto::switch_&lt;C&gt;</computeroutput> as a transform
@@ -446,6 +456,13 @@
             <computeroutput>E</computeroutput>, state <computeroutput>s</computeroutput> and
             data <computeroutput>d</computeroutput>, it is equivalent to
             <computeroutput>C::case_&lt;E::proto_tag&gt;()(e, s, d)</computeroutput>.
+	  </para>
+	  <para>
+	    When applying <computeroutput>proto::switch_&lt;C,T&gt;</computeroutput> as a transform
+            with an expression <computeroutput>e</computeroutput> of type
+            <computeroutput>E</computeroutput>, state <computeroutput>s</computeroutput> and
+            data <computeroutput>d</computeroutput>, it is equivalent to
+            <computeroutput>C::case_&lt;boost::result_of&lt;T(E)&gt; &gt;()(e, s, d)</computeroutput>.
           </para>
         </description>
         <struct name="impl">
@@ -455,11 +472,16 @@
             <template-type-parameter name="Data"/>
           </template>
           <inherit><type>
-    Cases::template case_&lt;typename Expr::tag_type&gt;::template impl&lt;Expr, State, Data&gt;</type></inherit>
+  Cases::template case_&lt; typename applicant::template impl&lt;Expr, State, Data&gt;::result_type 
+	               &gt;::template impl&lt;Expr, State, Data&gt;</type>
+	  </inherit>
         </struct>
         <typedef name="proto_grammar">
           <type>switch_</type>
         </typedef>
+	<typedef name="applicant">
+          <type>when&lt;_, Transform&gt;</type>
+        </typedef>
       </struct>
 
       <!-- proto::exact -->