X-Git-Url: https://git.proxmox.com/?a=blobdiff_plain;f=ceph%2Fsrc%2Fboost%2Fboost%2Fmp11%2Falgorithm.hpp;h=b8719d68768f1e729aa46cf5bebc0a4c0debf992;hb=92f5a8d42d07f9929ae4fa7e01342fe8d96808a8;hp=23758f7076102bf1a962d8a772e3d8a92d165c7b;hpb=a0324939f9d0e1905d5df8f57442f09dc70af83d;p=ceph.git

diff --git a/ceph/src/boost/boost/mp11/algorithm.hpp b/ceph/src/boost/boost/mp11/algorithm.hpp
index 23758f707..b8719d687 100644
--- a/ceph/src/boost/boost/mp11/algorithm.hpp
+++ b/ceph/src/boost/boost/mp11/algorithm.hpp
@@ -1,7 +1,7 @@
 #ifndef BOOST_MP11_ALGORITHM_HPP_INCLUDED
 #define BOOST_MP11_ALGORITHM_HPP_INCLUDED
 
-//  Copyright 2015-2017 Peter Dimov.
+//  Copyright 2015-2019 Peter Dimov
 //
 //  Distributed under the Boost Software License, Version 1.0.
 //
@@ -19,10 +19,10 @@
 #include <boost/mp11/detail/mp_with_index.hpp>
 #include <boost/mp11/detail/mp_fold.hpp>
 #include <boost/mp11/detail/mp_min_element.hpp>
+#include <boost/mp11/detail/mp_copy_if.hpp>
+#include <boost/mp11/detail/mp_remove_if.hpp>
 #include <boost/mp11/detail/config.hpp>
 #include <boost/mp11/integer_sequence.hpp>
-#include <boost/config.hpp>
-#include <boost/config/workaround.hpp>
 #include <type_traits>
 #include <utility>
 
@@ -41,7 +41,7 @@ template<template<class...> class F, class... L> struct mp_transform_impl
 
 template<template<class...> class F, template<class...> class L, class... T> struct mp_transform_impl<F, L<T...>>
 {
-#if BOOST_WORKAROUND( BOOST_MSVC, < 1920 )
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
 
     template<class... U> struct f { using type = F<U...>; };
 
@@ -56,7 +56,7 @@ template<template<class...> class F, template<class...> class L, class... T> str
 
 template<template<class...> class F, template<class...> class L1, class... T1, template<class...> class L2, class... T2> struct mp_transform_impl<F, L1<T1...>, L2<T2...>>
 {
-#if BOOST_WORKAROUND( BOOST_MSVC, < 1920 )
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
 
     template<class... U> struct f { using type = F<U...>; };
 
@@ -71,7 +71,7 @@ template<template<class...> class F, template<class...> class L1, class... T1, t
 
 template<template<class...> class F, template<class...> class L1, class... T1, template<class...> class L2, class... T2, template<class...> class L3, class... T3> struct mp_transform_impl<F, L1<T1...>, L2<T2...>, L3<T3...>>
 {
-#if BOOST_WORKAROUND( BOOST_MSVC, < 1920 )
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
 
     template<class... U> struct f { using type = F<U...>; };
 
@@ -84,7 +84,7 @@ template<template<class...> class F, template<class...> class L1, class... T1, t
 #endif
 };
 
-#if BOOST_WORKAROUND( BOOST_MSVC, == 1900 ) || BOOST_WORKAROUND( BOOST_GCC, < 40800 )
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, == 1900 ) || BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, < 40800 )
 
 template<class... L> using mp_same_size_1 = mp_same<mp_size<L>...>;
 template<class... L> struct mp_same_size_2: mp_defer<mp_same_size_1, L...> {};
@@ -95,18 +95,35 @@ struct list_size_mismatch
 {
 };
 
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 )
+
+template<template<class...> class F, class... L> struct mp_transform_cuda_workaround
+{
+    using type = mp_if<mp_same<mp_size<L>...>, detail::mp_transform_impl<F, L...>, detail::list_size_mismatch>;
+};
+
+#endif
+
 } // namespace detail
 
-#if BOOST_WORKAROUND( BOOST_MSVC, == 1900 ) || BOOST_WORKAROUND( BOOST_GCC, < 40800 )
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, == 1900 ) || BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, < 40800 )
 
 template<template<class...> class F, class... L> using mp_transform = typename mp_if<typename detail::mp_same_size_2<L...>::type, detail::mp_transform_impl<F, L...>, detail::list_size_mismatch>::type;
 
 #else
 
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 )
+
+template<template<class...> class F, class... L> using mp_transform = typename detail::mp_transform_cuda_workaround< F, L...>::type::type;
+
+#else
+
 template<template<class...> class F, class... L> using mp_transform = typename mp_if<mp_same<mp_size<L>...>, detail::mp_transform_impl<F, L...>, detail::list_size_mismatch>::type;
 
 #endif
 
+#endif
+
 template<class Q, class... L> using mp_transform_q = mp_transform<Q::template fn, L...>;
 
 namespace detail
@@ -138,14 +155,14 @@ template<template<class...> class P, template<class...> class F, class... L> str
     using Qp = mp_quote<P>;
     using Qf = mp_quote<F>;
 
-#if BOOST_WORKAROUND( BOOST_MSVC, < 1920 )
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
 
-    template<class... U> struct _f_ { using type = mp_eval_if_q<mp_not<mp_invoke<Qp, U...>>, mp_first<mp_list<U...>>, Qf, U...>; };
+    template<class... U> struct _f_ { using type = mp_eval_if_q<mp_not<mp_invoke_q<Qp, U...>>, mp_first<mp_list<U...>>, Qf, U...>; };
     template<class... U> using _f = typename _f_<U...>::type;
 
 #else
 
-    template<class... U> using _f = mp_eval_if_q<mp_not<mp_invoke<Qp, U...>>, mp_first<mp_list<U...>>, Qf, U...>;
+    template<class... U> using _f = mp_eval_if_q<mp_not<mp_invoke_q<Qp, U...>>, mp_first<mp_list<U...>>, Qf, U...>;
 
 #endif
 
@@ -157,6 +174,27 @@ template<template<class...> class P, template<class...> class F, class... L> str
 template<template<class...> class P, template<class...> class F, class... L> using mp_transform_if = typename detail::mp_transform_if_impl<P, F, L...>::type;
 template<class Qp, class Qf, class... L> using mp_transform_if_q = typename detail::mp_transform_if_impl<Qp::template fn, Qf::template fn, L...>::type;
 
+// mp_filter<P, L...>
+namespace detail
+{
+
+template<template<class...> class P, class L1, class... L> struct mp_filter_impl
+{
+    using Qp = mp_quote<P>;
+
+    template<class T1, class... T> using _f = mp_if< mp_invoke_q<Qp, T1, T...>, mp_list<T1>, mp_list<> >;
+
+    using _t1 = mp_transform<_f, L1, L...>;
+    using _t2 = mp_apply<mp_append, _t1>;
+
+    using type = mp_assign<L1, _t2>;
+};
+
+} // namespace detail
+
+template<template<class...> class P, class... L> using mp_filter = typename detail::mp_filter_impl<P, L...>::type;
+template<class Q, class... L> using mp_filter_q = typename detail::mp_filter_impl<Q::template fn, L...>::type;
+
 // mp_fill<L, V>
 namespace detail
 {
@@ -165,7 +203,7 @@ template<class L, class V> struct mp_fill_impl;
 
 template<template<class...> class L, class... T, class V> struct mp_fill_impl<L<T...>, V>
 {
-#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, <= 1900 )
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1900 )
 
     template<class...> struct _f { using type = V; };
     using type = L<typename _f<T>::type...>;
@@ -297,57 +335,119 @@ template<template<class...> class L, class... T, std::size_t I> struct mp_at_c_i
 
 template<class L, std::size_t I> struct mp_at_c_impl
 {
-    using _map = mp_transform<mp_list, mp_iota<mp_size<L>>, L>;
-    using type = mp_second<mp_map_find<_map, mp_size_t<I>>>;
+    using _map = mp_transform<mp_list, mp_iota<mp_size<L> >, L>;
+    using type = mp_second<mp_map_find<_map, mp_size_t<I> > >;
+};
+
+#endif
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 )
+
+template<class L, std::size_t I> struct mp_at_c_cuda_workaround
+{
+    using type = mp_if_c<(I < mp_size<L>::value), detail::mp_at_c_impl<L, I>, void>;
 };
 
 #endif
 
 } // namespace detail
 
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 )
+
+template<class L, std::size_t I> using mp_at_c = typename detail::mp_at_c_cuda_workaround< L, I >::type::type;
+
+#else
+
 template<class L, std::size_t I> using mp_at_c = typename mp_if_c<(I < mp_size<L>::value), detail::mp_at_c_impl<L, I>, void>::type;
+
+#endif
+
 template<class L, class I> using mp_at = mp_at_c<L, std::size_t{ I::value }>;
 
 // mp_take(_c)<L, N>
 namespace detail
 {
 
-template<class L, std::size_t N, class E = void> struct mp_take_c_impl;
+template<std::size_t N, class L, class E = void> struct mp_take_c_impl
+{
+};
 
-template<template<class...> class L, class... T> struct mp_take_c_impl<L<T...>, 0>
+template<template<class...> class L, class... T>
+struct mp_take_c_impl<0, L<T...>>
 {
     using type = L<>;
 };
 
-template<template<class...> class L, class T1, class... T> struct mp_take_c_impl<L<T1, T...>, 1>
+template<template<class...> class L, class T1, class... T>
+struct mp_take_c_impl<1, L<T1, T...>>
 {
     using type = L<T1>;
 };
 
-template<template<class...> class L, class T1, class T2, class... T> struct mp_take_c_impl<L<T1, T2, T...>, 2>
+template<template<class...> class L, class T1, class T2, class... T>
+struct mp_take_c_impl<2, L<T1, T2, T...>>
 {
     using type = L<T1, T2>;
 };
 
-template<template<class...> class L, class T1, class T2, class T3, class... T> struct mp_take_c_impl<L<T1, T2, T3, T...>, 3>
+template<template<class...> class L, class T1, class T2, class T3, class... T>
+struct mp_take_c_impl<3, L<T1, T2, T3, T...>>
 {
     using type = L<T1, T2, T3>;
 };
 
-template<template<class...> class L, class T1, class T2, class T3, class T4, class... T> struct mp_take_c_impl<L<T1, T2, T3, T4, T...>, 4>
+template<template<class...> class L, class T1, class T2, class T3, class T4, class... T>
+struct mp_take_c_impl<4, L<T1, T2, T3, T4, T...>>
 {
     using type = L<T1, T2, T3, T4>;
 };
 
-template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class... T, std::size_t N> struct mp_take_c_impl<L<T1, T2, T3, T4, T5, T...>, N, typename std::enable_if<N >= 5>::type>
+template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class... T>
+struct mp_take_c_impl<5, L<T1, T2, T3, T4, T5, T...>>
 {
-    using type = mp_append<L<T1, T2, T3, T4, T5>, typename mp_take_c_impl<L<T...>, N-5>::type>;
+	using type = L<T1, T2, T3, T4, T5>;
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class... T>
+struct mp_take_c_impl<6, L<T1, T2, T3, T4, T5, T6, T...>>
+{
+	using type = L<T1, T2, T3, T4, T5, T6>;
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class... T>
+struct mp_take_c_impl<7, L<T1, T2, T3, T4, T5, T6, T7, T...>>
+{
+	using type = L<T1, T2, T3, T4, T5, T6, T7>;
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class... T>
+struct mp_take_c_impl<8, L<T1, T2, T3, T4, T5, T6, T7, T8, T...>>
+{
+	using type = L<T1, T2, T3, T4, T5, T6, T7, T8>;
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class... T>
+struct mp_take_c_impl<9, L<T1, T2, T3, T4, T5, T6, T7, T8, T9, T...>>
+{
+	using type = L<T1, T2, T3, T4, T5, T6, T7, T8, T9>;
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class... T, std::size_t N>
+struct mp_take_c_impl<N, L<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T...>, typename std::enable_if<N >= 10>::type>
+{
+    using type = mp_append<L<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, typename mp_take_c_impl<N-10, L<T...>>::type>;
 };
 
 } // namespace detail
 
-template<class L, std::size_t N> using mp_take_c = typename detail::mp_take_c_impl<L, N>::type;
-template<class L, class N> using mp_take = typename detail::mp_take_c_impl<L, std::size_t{ N::value }>::type;
+template<class L, std::size_t N> using mp_take_c = typename detail::mp_take_c_impl<N, L>::type;
+template<class L, class N> using mp_take = typename detail::mp_take_c_impl<std::size_t{ N::value }, L>::type;
+
+// mp_back<L>
+template<class L> using mp_back = mp_at_c<L, mp_size<L>::value - 1>;
+
+// mp_pop_back<L>
+template<class L> using mp_pop_back = mp_take_c<L, mp_size<L>::value - 1>;
 
 // mp_replace<L, V, W>
 namespace detail
@@ -357,7 +457,7 @@ template<class L, class V, class W> struct mp_replace_impl;
 
 template<template<class...> class L, class... T, class V, class W> struct mp_replace_impl<L<T...>, V, W>
 {
-#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, <= 1800 )
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
     template<class A> struct _f { using type = mp_if<std::is_same<A, V>, W, A>; };
     using type = L<typename _f<T>::type...>;
 #else
@@ -378,7 +478,7 @@ template<class L, template<class...> class P, class W> struct mp_replace_if_impl
 
 template<template<class...> class L, class... T, template<class...> class P, class W> struct mp_replace_if_impl<L<T...>, P, W>
 {
-#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, < 1920 )
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
     template<class U> struct _f { using type = mp_if<P<U>, W, U>; };
     using type = L<typename _f<T>::type...>;
 #else
@@ -393,26 +493,7 @@ template<class L, template<class...> class P, class W> using mp_replace_if = typ
 template<class L, class Q, class W> using mp_replace_if_q = mp_replace_if<L, Q::template fn, W>;
 
 // mp_copy_if<L, P>
-namespace detail
-{
-
-template<class L, template<class...> class P> struct mp_copy_if_impl;
-
-template<template<class...> class L, class... T, template<class...> class P> struct mp_copy_if_impl<L<T...>, P>
-{
-#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, < 1920 )
-    template<class U> struct _f { using type = mp_if<P<U>, mp_list<U>, mp_list<>>; };
-    using type = mp_append<L<>, typename _f<T>::type...>;
-#else
-    template<class U> using _f = mp_if<P<U>, mp_list<U>, mp_list<>>;
-    using type = mp_append<L<>, _f<T>...>;
-#endif
-};
-
-} // namespace detail
-
-template<class L, template<class...> class P> using mp_copy_if = typename detail::mp_copy_if_impl<L, P>::type;
-template<class L, class Q> using mp_copy_if_q = mp_copy_if<L, Q::template fn>;
+//   in detail/mp_copy_if.hpp
 
 // mp_remove<L, V>
 namespace detail
@@ -422,7 +503,7 @@ template<class L, class V> struct mp_remove_impl;
 
 template<template<class...> class L, class... T, class V> struct mp_remove_impl<L<T...>, V>
 {
-#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, < 1920 )
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
     template<class U> struct _f { using type = mp_if<std::is_same<U, V>, mp_list<>, mp_list<U>>; };
     using type = mp_append<L<>, typename _f<T>::type...>;
 #else
@@ -436,26 +517,7 @@ template<template<class...> class L, class... T, class V> struct mp_remove_impl<
 template<class L, class V> using mp_remove = typename detail::mp_remove_impl<L, V>::type;
 
 // mp_remove_if<L, P>
-namespace detail
-{
-
-template<class L, template<class...> class P> struct mp_remove_if_impl;
-
-template<template<class...> class L, class... T, template<class...> class P> struct mp_remove_if_impl<L<T...>, P>
-{
-#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, < 1920 )
-    template<class U> struct _f { using type = mp_if<P<U>, mp_list<>, mp_list<U>>; };
-    using type = mp_append<L<>, typename _f<T>::type...>;
-#else
-    template<class U> using _f = mp_if<P<U>, mp_list<>, mp_list<U>>;
-    using type = mp_append<L<>, _f<T>...>;
-#endif
-};
-
-} // namespace detail
-
-template<class L, template<class...> class P> using mp_remove_if = typename detail::mp_remove_if_impl<L, P>::type;
-template<class L, class Q> using mp_remove_if_q = mp_remove_if<L, Q::template fn>;
+//   in detail/mp_remove_if.hpp
 
 // mp_partition<L, P>
 namespace detail
@@ -479,7 +541,7 @@ namespace detail
 
 template<class L, template<class...> class P> struct mp_sort_impl;
 
-#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, <= 1800 )
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
 
 template<template<class...> class L, class... T, template<class...> class P> struct mp_sort_impl<L<T...>, P>
 {
@@ -543,6 +605,26 @@ template<template<class...> class L, class T1, class... T, std::size_t I, templa
 
     using L2 = mp_second<part>;
 
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 )
+
+    struct detail
+    {
+        struct mp_nth_element_impl_cuda_workaround
+        {
+            using type = mp_cond<
+
+                mp_bool<(I < N1)>, mp_nth_element_impl<L1, I, P>,
+                mp_bool<(I == N1)>, mp_identity<T1>,
+                mp_true, mp_nth_element_impl<L2, I - N1 - 1, P>
+
+            >;
+        };
+    };
+
+    using type = typename detail::mp_nth_element_impl_cuda_workaround::type::type;
+
+#else
+
     using type = typename mp_cond<
 
         mp_bool<(I < N1)>, mp_nth_element_impl<L1, I, P>,
@@ -550,6 +632,8 @@ template<template<class...> class L, class T1, class... T, std::size_t I, templa
         mp_true, mp_nth_element_impl<L2, I - N1 - 1, P>
 
     >::type;
+
+#endif
 };
 
 } // namespace detail
@@ -564,7 +648,7 @@ namespace detail
 
 template<class L, class V> struct mp_find_impl;
 
-#if defined( BOOST_CLANG ) && defined( BOOST_MP11_HAS_FOLD_EXPRESSIONS )
+#if BOOST_MP11_CLANG && defined( BOOST_MP11_HAS_FOLD_EXPRESSIONS )
 
 struct mp_index_holder
 {
@@ -601,7 +685,7 @@ template<template<class...> class L, class V> struct mp_find_impl<L<>, V>
     using type = mp_size_t<0>;
 };
 
-#if !defined( BOOST_NO_CXX14_CONSTEXPR )
+#if defined( BOOST_MP11_HAS_CXX14_CONSTEXPR )
 
 constexpr std::size_t cx_find_index( bool const * first, bool const * last )
 {
@@ -633,7 +717,7 @@ template<template<class...> class L, class... T, class V> struct mp_find_impl<L<
 
 #else
 
-#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, <= 1800 )
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
 
 template<template<class...> class L, class... T, class V> struct mp_find_impl<L<T...>, V>
 {
@@ -673,7 +757,7 @@ namespace detail
 
 template<class L, template<class...> class P> struct mp_find_if_impl;
 
-#if defined( BOOST_CLANG ) && defined( BOOST_MP11_HAS_FOLD_EXPRESSIONS )
+#if BOOST_MP11_CLANG && defined( BOOST_MP11_HAS_FOLD_EXPRESSIONS )
 
 template<template<class...> class L, class... T, template<class...> class P> struct mp_find_if_impl<L<T...>, P>
 {
@@ -696,7 +780,7 @@ template<template<class...> class L, class... T, template<class...> class P> str
 
 #else
 
-#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, <= 1800 )
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
 
 template<template<class...> class L, class... T, template<class...> class P> struct mp_find_if_impl<L<T...>, P>
 {
@@ -737,7 +821,7 @@ namespace detail
 
 template<class L> struct mp_reverse_impl;
 
-#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, <= 1800 )
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
 
 template<template<class...> class L, class... T> struct mp_reverse_impl<L<T...>>
 {
@@ -817,7 +901,7 @@ namespace detail
 
 template<class L, class V, template<class...> class F> struct mp_reverse_fold_impl;
 
-#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, <= 1800 )
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
 
 template<template<class...> class L, class... T, class V, template<class...> class F> struct mp_reverse_fold_impl<L<T...>, V, F>
 {
@@ -843,7 +927,7 @@ template<template<class...> class L, class T1, class... T, class V, template<cla
 template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class... T, class V, template<class...> class F> struct mp_reverse_fold_impl<L<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T...>, V, F>
 {
     using rest = typename mp_reverse_fold_impl<L<T...>, V, F>::type;
-    using type = F<T1, F<T2, F<T3, F<T4, F<T5, F<T6, F<T7, F<T8, F<T9, F<T10, rest>>>>>>>>>>;
+    using type = F<T1, F<T2, F<T3, F<T4, F<T5, F<T6, F<T7, F<T8, F<T9, F<T10, rest> > > > > > > > > >;
 };
 
 } // namespace detail
@@ -889,7 +973,7 @@ template<class L, class I, class W> struct mp_replace_at_impl
     template<class T1, class T2> using _p = std::is_same<T2, mp_size_t<I::value>>;
     template<class T1, class T2> using _f = W;
 
-    using type = mp_transform_if<_p, _f, L, mp_iota<mp_size<L>>>;
+    using type = mp_transform_if<_p, _f, L, mp_iota<mp_size<L> > >;
 };
 
 } // namespace detail
@@ -901,24 +985,47 @@ template<class L, std::size_t I, class W> using mp_replace_at_c = typename detai
 namespace detail
 {
 
-template<class... T, class F> BOOST_CONSTEXPR F mp_for_each_impl( mp_list<T...>, F && f )
+template<class... T, class F> BOOST_MP11_CONSTEXPR F mp_for_each_impl( mp_list<T...>, F && f )
 {
     using A = int[sizeof...(T)];
     return (void)A{ ((void)f(T()), 0)... }, std::forward<F>(f);
 }
 
-template<class F> BOOST_CONSTEXPR F mp_for_each_impl( mp_list<>, F && f )
+template<class F> BOOST_MP11_CONSTEXPR F mp_for_each_impl( mp_list<>, F && f )
 {
     return std::forward<F>(f);
 }
 
 } // namespace detail
 
-template<class L, class F> BOOST_CONSTEXPR F mp_for_each( F && f )
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, >= 1900 )
+
+// msvc has a limit of 1024
+
+template<class L, class F> BOOST_MP11_CONSTEXPR mp_if_c<mp_size<L>::value <= 1024, F> mp_for_each( F && f )
 {
     return detail::mp_for_each_impl( mp_rename<L, mp_list>(), std::forward<F>(f) );
 }
 
+template<class L, class F> BOOST_MP11_CONSTEXPR mp_if_c<mp_size<L>::value >= 1025, F> mp_for_each( F && f )
+{
+    using L2 = mp_rename<L, mp_list>;
+
+    using L3 = mp_take_c<L2, 1024>;
+    using L4 = mp_drop_c<L2, 1024>;
+
+    return mp_for_each<L4>( mp_for_each<L3>( std::forward<F>(f) ) );
+}
+
+#else
+
+template<class L, class F> BOOST_MP11_CONSTEXPR F mp_for_each( F && f )
+{
+    return detail::mp_for_each_impl( mp_rename<L, mp_list>(), std::forward<F>(f) );
+}
+
+#endif
+
 // mp_insert<L, I, T...>
 template<class L, class I, class... T> using mp_insert = mp_append<mp_take<L, I>, mp_push_front<mp_drop<L, I>, T...>>;
 
@@ -931,6 +1038,30 @@ template<class L, class I, class J> using mp_erase = mp_append<mp_take<L, I>, mp
 // mp_erase_c<L, I, J>
 template<class L, std::size_t I, std::size_t J> using mp_erase_c = mp_append<mp_take_c<L, I>, mp_drop_c<L, J>>;
 
+// mp_starts_with<L1, L2>
+// contributed by Glen Joseph Fernandes (glenjofe@gmail.com)
+namespace detail {
+
+template<class L1, class L2>
+struct mp_starts_with_impl { };
+
+template<template<class...> class L1, class... T1, template<class...> class L2,
+    class... T2>
+struct mp_starts_with_impl<L1<T1...>, L2<T2...> > {
+    template<class L>
+    static mp_false check(L);
+
+    template<class... T>
+    static mp_true check(mp_list<T2..., T...>);
+
+    using type = decltype(check(mp_list<T1...>()));
+};
+
+} // namespace detail
+
+template<class L1, class L2>
+using mp_starts_with = typename detail::mp_starts_with_impl<L1, L2>::type;
+
 // mp_min_element<L, P>
 // mp_max_element<L, P>
 //   in detail/mp_min_element.hpp