Index: convert.hpp
===================================================================
--- convert.hpp	(revision 83330)
+++ convert.hpp	(working copy)
@@ -9,6 +9,33 @@
 
 #include <boost/fusion/container/map/map.hpp>
 
+namespace boost { namespace fusion { namespace detail
+{
+    template <typename It, bool is_assoc>
+    struct pair_from
+    {
+        typedef typename result_of::value_of<It>::type type;
+
+        static inline type call(It const& it)
+        {
+            return *it;
+        }
+    };
+
+    template <typename It>
+    struct pair_from<It, true>
+    {
+        typedef typename result_of::key_of<It>::type key_type;
+        typedef typename result_of::value_of_data<It>::type data_type;
+        typedef typename fusion::pair<key_type, data_type> type;
+
+        static inline type call(It const& it)
+        {
+            return type(deref_data(it));
+        }
+    };
+}}}
+
 ///////////////////////////////////////////////////////////////////////////////
 // Without variadics, we will use the PP version
 ///////////////////////////////////////////////////////////////////////////////
@@ -30,6 +57,9 @@
             detail::build_map<
                 typename result_of::begin<Sequence>::type
               , typename result_of::end<Sequence>::type
+              , is_base_of<
+                    associative_tag
+                  , typename traits::category_of<Sequence>::type>::value
             >
         {
         };
Index: detail/build_map.hpp
===================================================================
--- detail/build_map.hpp	(revision 83330)
+++ detail/build_map.hpp	(working copy)
@@ -18,12 +18,13 @@
 
 namespace boost { namespace fusion { namespace detail
 {
-    template <typename First, typename Last
-      , bool is_empty = result_of::equal_to<First, Last>::value>
+    template <typename First, typename Last, bool is_assoc
+      , bool is_empty = result_of::equal_to<First, Last>::value
+    >
     struct build_map;
 
-    template <typename First, typename Last>
-    struct build_map<First, Last, true>
+    template <typename First, typename Last, bool is_assoc>
+    struct build_map<First, Last, is_assoc, true>
     {
         typedef map<> type;
         static type
@@ -48,15 +49,15 @@
         }
     };
 
-    template <typename First, typename Last>
-    struct build_map<First, Last, false>
+    template <typename First, typename Last, bool is_assoc>
+    struct build_map<First, Last, is_assoc, false>
     {
         typedef
-            build_map<typename result_of::next<First>::type, Last>
+            build_map<typename result_of::next<First>::type, Last, is_assoc>
         next_build_map;
 
         typedef push_front_map<
-            typename result_of::value_of<First>::type
+            typename pair_from<First, is_assoc>::type
           , typename next_build_map::type>
         push_front;
 
@@ -65,9 +66,9 @@
         static type
         call(First const& f, Last const& l)
         {
-            typename result_of::value_of<First>::type v = *f;
             return push_front::call(
-                v, next_build_map::call(fusion::next(f), l));
+                pair_from<First, is_assoc>::call(f)
+              , next_build_map::call(fusion::next(f), l));
         }
     };
 }}}
Index: detail/cpp03/as_map.hpp
===================================================================
--- detail/cpp03/as_map.hpp	(revision 83330)
+++ detail/cpp03/as_map.hpp	(working copy)
@@ -22,11 +22,11 @@
 
 namespace boost { namespace fusion { namespace detail
 {
-    template <int size>
+    template <int size, bool is_assoc>
     struct as_map;
 
-    template <>
-    struct as_map<0>
+    template <bool is_assoc>
+    struct as_map<0, is_assoc>
     {
         template <typename Iterator>
         struct apply
@@ -73,17 +73,21 @@
     typename gen::BOOST_PP_CAT(I, BOOST_PP_INC(n))                              \
         BOOST_PP_CAT(i, BOOST_PP_INC(n)) = fusion::next(BOOST_PP_CAT(i, n));
 
-#define BOOST_FUSION_VALUE_OF_ITERATOR(z, n, data)                              \
-    typedef typename fusion::result_of::value_of<BOOST_PP_CAT(I, n)>::type      \
-        BOOST_PP_CAT(T, n);
+#define BOOST_FUSION_PAIR_FROM_ITERATOR(z, n, data)                             \
+    typedef pair_from<BOOST_PP_CAT(I, n), is_assoc> BOOST_PP_CAT(D, n);         \
+    typedef typename BOOST_PP_CAT(D, n)::type BOOST_PP_CAT(T, n);
 
+#define BOOST_FUSION_DREF_CALL_ITERATOR(z, n, data)                             \
+    gen::BOOST_PP_CAT(D, n)::call(BOOST_PP_CAT(i, n))
+
 #define BOOST_PP_FILENAME_1 <boost/fusion/container/map/detail/cpp03/as_map.hpp>
 #define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_MAP_SIZE)
 #include BOOST_PP_ITERATE()
 
 #undef BOOST_FUSION_NEXT_ITERATOR
 #undef BOOST_FUSION_NEXT_CALL_ITERATOR
-#undef BOOST_FUSION_VALUE_OF_ITERATOR
+#undef BOOST_FUSION_PAIR_FROM_ITERATOR
+#undef BOOST_FUSION_DREF_CALL_ITERATOR
 
 }}}
 
@@ -103,14 +107,14 @@
 
 #define N BOOST_PP_ITERATION()
 
-    template <>
-    struct as_map<N>
+    template <bool is_assoc>
+    struct as_map<N, is_assoc>
     {
         template <typename I0>
         struct apply
         {
-            BOOST_PP_REPEAT(N, BOOST_FUSION_NEXT_ITERATOR, _)
-            BOOST_PP_REPEAT(N, BOOST_FUSION_VALUE_OF_ITERATOR, _)
+            BOOST_PP_REPEAT(BOOST_PP_DEC(N), BOOST_FUSION_NEXT_ITERATOR, _)
+            BOOST_PP_REPEAT(N, BOOST_FUSION_PAIR_FROM_ITERATOR, _)
             typedef map<BOOST_PP_ENUM_PARAMS(N, T)> type;
         };
 
@@ -121,7 +125,7 @@
             typedef apply<Iterator> gen;
             typedef typename gen::type result;
             BOOST_PP_REPEAT(BOOST_PP_DEC(N), BOOST_FUSION_NEXT_CALL_ITERATOR, _)
-            return result(BOOST_PP_ENUM_PARAMS(N, *i));
+            return result(BOOST_PP_ENUM(N, BOOST_FUSION_DREF_CALL_ITERATOR, _));
         }
     };
 
Index: detail/cpp03/convert.hpp
===================================================================
--- detail/cpp03/convert.hpp	(revision 83330)
+++ detail/cpp03/convert.hpp	(working copy)
@@ -20,7 +20,14 @@
         template <typename Sequence>
         struct as_map
         {
-            typedef typename detail::as_map<result_of::size<Sequence>::value> gen;
+            typedef typename
+                detail::as_map<
+                    result_of::size<Sequence>::value
+                  , is_base_of<
+                        associative_tag
+                      , typename traits::category_of<Sequence>::type>::value
+                >
+            gen;
             typedef typename gen::
                 template apply<typename result_of::begin<Sequence>::type>::type
             type;
Index: detail/cpp03/convert_impl.hpp
===================================================================
--- detail/cpp03/convert_impl.hpp	(revision 83330)
+++ detail/cpp03/convert_impl.hpp	(working copy)
@@ -28,7 +28,14 @@
             template <typename Sequence>
             struct apply
             {
-                typedef typename detail::as_map<result_of::size<Sequence>::value> gen;
+                typedef typename
+                    detail::as_map<
+                        result_of::size<Sequence>::value
+                      , is_base_of<
+                            associative_tag
+                          , typename traits::category_of<Sequence>::type>::value
+                    >
+                gen;
                 typedef typename gen::
                     template apply<typename result_of::begin<Sequence>::type>::type
                 type;