diff --git a/include/boost/mp11/algorithm.hpp b/include/boost/mp11/algorithm.hpp
index 07a8ffd..a1264f3 100644
--- a/include/boost/mp11/algorithm.hpp
+++ b/include/boost/mp11/algorithm.hpp
@@ -153,13 +153,13 @@ template<class Q, class... L> using mp_transform_q = mp_transform<Q::template fn
 namespace detail
 {
 
+template<class V, class T> using mp_transform_push_back = mp_transform<mp_push_back, V, T>;
+
 template<template<class...> class F, template<class...> class L1, class... T1, template<class...> class L2, class... T2, template<class...> class L3, class... T3, template<class...> class L4, class... T4, class... L> struct mp_transform_impl<F, L1<T1...>, L2<T2...>, L3<T3...>, L4<T4...>, L...>
 {
     using A1 = L1<mp_list<T1, T2, T3, T4>...>;
 
-    template<class V, class T> using _f = mp_transform<mp_push_back, V, T>;
-
-    using A2 = mp_fold<mp_list<L...>, A1, _f>;
+    using A2 = mp_fold<mp_list<L...>, A1, mp_transform_push_back>;
 
     template<class T> using _g = mp_apply<F, T>;
 
@@ -172,7 +172,7 @@ template<template<class...> class F, template<class...> class L1, class... T1, t
 namespace detail
 {
 
-template<template<class...> class P, template<class...> class F, class... L> struct mp_transform_if_impl
+template<template<class...> class P, template<class...> class F> struct mp_transform_if_impl
 {
     // the stupid quote-unquote dance avoids "pack expansion used as argument for non-pack parameter of alias template"
 
@@ -181,34 +181,35 @@ template<template<class...> class P, template<class...> class F, class... L> str
 
 #if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
 
-    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;
+    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 fn = typename _f<U...>::type;
 
 #else
 
-    template<class... U> using _f = mp_eval_if_q<mp_not<mp_invoke_q<Qp, U...>>, mp_first<mp_list<U...>>, Qf, U...>;
+    template<class... U> using fn = mp_eval_if_q<mp_not<mp_invoke_q<Qp, U...>>, mp_first<mp_list<U...>>, Qf, U...>;
 
 #endif
-
-    using type = mp_transform<_f, L...>;
 };
 
 } // namespace detail
 
-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;
+template<template<class...> class P, template<class...> class F, class... L> using mp_transform_if = mp_transform_q<detail::mp_transform_if_impl<P, F>, L...>;
+template<class Qp, class Qf, class... L> using mp_transform_if_q = mp_transform_q<detail::mp_transform_if_impl<Qp::template fn, Qf::template fn>, L...>;
 
 // mp_filter<P, L...>
 namespace detail
 {
 
-template<template<class...> class P, class L1, class... L> struct mp_filter_impl
+template<template<class...> class P> struct mp_filter_impl_f
 {
     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<> >;
+    template<class T1, class... T> using fn = mp_if<mp_invoke_q<Qp, T1, T...>, mp_list<T1>, mp_list<> >;
+};
 
-    using _t1 = mp_transform<_f, L1, L...>;
+template<template<class...> class P, class L1, class... L> struct mp_filter_impl
+{
+    using _t1 = mp_transform_q<mp_filter_impl_f<P>, L1, L...>;
     using _t2 = mp_apply<mp_append, _t1>;
 
     using type = mp_assign<L1, _t2>;
@@ -228,6 +229,8 @@ template<class L, class V> struct mp_fill_impl
 // An error "no type named 'type'" here means that the L argument of mp_fill is not a list
 };
 
+template<class T, class> using mp_fill_first_item = T;
+
 template<template<class...> class L, class... T, class V> struct mp_fill_impl<L<T...>, V>
 {
 #if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1900 )
@@ -237,8 +240,7 @@ template<template<class...> class L, class... T, class V> struct mp_fill_impl<L<
 
 #else
 
-    template<class...> using _f = V;
-    using type = L<_f<T>...>;
+    using type = L<mp_fill_first_item<V, T>...>;
 
 #endif
 };
@@ -329,11 +331,14 @@ namespace detail
 
 template<class L, class L2, class En> struct mp_drop_impl;
 
-template<template<class...> class L, class... T, template<class...> class L2, class... U> struct mp_drop_impl<L<T...>, L2<U...>, mp_true>
+template<template<class...> class L, class... U> struct mp_drop_impl_f
 {
     template<class... W> static mp_identity<L<W...>> f( U*..., mp_identity<W>*... );
+};
 
-    using R = decltype( f( static_cast<mp_identity<T>*>(0) ... ) );
+template<template<class...> class L, class... T, template<class...> class L2, class... U> struct mp_drop_impl<L<T...>, L2<U...>, mp_true>
+{
+    using R = decltype( mp_drop_impl_f<L, U...>::f( static_cast<mp_identity<T>*>(0) ... ) );
 
     using type = typename R::type;
 };
@@ -524,8 +529,7 @@ template<template<class...> class L, class... T, class V, class W> struct mp_rep
     template<class A> struct _f { using type = mp_if<std::is_same<A, V>, W, A>; };
     using type = L<typename _f<T>::type...>;
 #else
-    template<class A> using _f = mp_if<std::is_same<A, V>, W, A>;
-    using type = L<_f<T>...>;
+    using type = L<mp_if<std::is_same<T, V>, W, T>...>;
 #endif
 };
 
@@ -545,8 +549,7 @@ template<template<class...> class L, class... T, template<class...> class P, cla
     template<class U> struct _f { using type = mp_if<P<U>, W, U>; };
     using type = L<typename _f<T>::type...>;
 #else
-    template<class U> using _f = mp_if<P<U>, W, U>;
-    using type = L<_f<T>...>;
+    using type = L<mp_if<P<T>, W, T>...>;
 #endif
 };
 
@@ -570,8 +573,7 @@ template<template<class...> class L, class... T, class V> struct mp_remove_impl<
     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
-    template<class U> using _f = mp_if<std::is_same<U, V>, mp_list<>, mp_list<U>>;
-    using type = mp_append<L<>, _f<T>...>;
+    using type = mp_append<L<>, mp_if<std::is_same<T, V>, mp_list<>, mp_list<T>>...>;
 #endif
 };
 
@@ -639,11 +641,14 @@ template<template<class...> class L, class T1, template<class...> class P> struc
     using type = L<T1>;
 };
 
-template<template<class...> class L, class T1, class... T, template<class...> class P> struct mp_sort_impl<L<T1, T...>, P>
+template<class T1, template<class...> class P> struct mp_sort_impl_f
 {
-    template<class U> using F = P<U, T1>;
+    template<class U> using fn = P<U, T1>;
+};
 
-    using part = mp_partition<L<T...>, F>;
+template<template<class...> class L, class T1, class... T, template<class...> class P> struct mp_sort_impl<L<T1, T...>, P>
+{
+    using part = mp_partition_q<L<T...>, mp_sort_impl_f<T1, P>>;
 
     using S1 = typename mp_sort_impl<mp_first<part>, P>::type;
     using S2 = typename mp_sort_impl<mp_second<part>, P>::type;
@@ -672,9 +677,7 @@ template<template<class...> class L, class T1, class... T, std::size_t I, templa
 {
     static_assert( I < 1 + sizeof...(T), "mp_nth_element index out of range" );
 
-    template<class U> using F = P<U, T1>;
-
-    using part = mp_partition<L<T...>, F>;
+    using part = mp_partition_q<L<T...>, mp_sort_impl_f<T1, P>>;
 
     using L1 = mp_first<part>;
     static std::size_t const N1 = mp_size<L1>::value;
@@ -1030,14 +1033,36 @@ template<class L, class Q> using mp_any_of_q = mp_any_of<L, Q::template fn>;
 namespace detail
 {
 
+#if ! BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1900 )
+
+template<class I> struct mp_replace_at_impl_p
+{
+    template<class T1, class T2> using fn = std::is_same<T2, I>;
+};
+
+template<class W> struct mp_replace_at_impl_f
+{
+    template<class T1, class T2> using fn = W;
+};
+
+#endif
+
 template<class L, class I, class W> struct mp_replace_at_impl
 {
     static_assert( I::value >= 0, "mp_replace_at<L, I, W>: I must not be negative" );
 
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1900 )
+
     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> > >;
+
+#else
+
+    using type = mp_transform_if_q<mp_replace_at_impl_p<mp_size_t<I::value>>, mp_replace_at_impl_f<W>, L, mp_iota<mp_size<L> > >;
+
+#endif
 };
 
 } // namespace detail
@@ -1182,13 +1207,16 @@ template<template<class...> class L> struct mp_power_set_impl< L<> >
 
 #endif
 
+template<class T1> struct mp_power_set_impl_f
+{
+    template<class L2> using fn = mp_push_front<L2, T1>;
+};
+
 template<template<class...> class L, class T1, class... T> struct mp_power_set_impl< L<T1, T...> >
 {
     using S1 = mp_power_set< L<T...> >;
 
-    template<class L2> using _f = mp_push_front<L2, T1>;
-
-    using S2 = mp_transform<_f, S1>;
+    using S2 = mp_transform_q<mp_power_set_impl_f<T1>, S1>;
 
     using type = mp_append< S1, S2 >;
 };
@@ -1260,15 +1288,18 @@ template<class L, template<class...> class F> using mp_pairwise_fold = mp_pairwi
 namespace detail
 {
 
+template<class L, std::size_t M> struct mp_sliding_fold_impl_f
+{
+    template<class I> using fn = mp_slice_c<L, I::value, I::value + M>;
+};
+
 template<class C, class L, class Q, class S> struct mp_sliding_fold_impl;
 
 template<class L, class N, class Q> struct mp_sliding_fold_impl<mp_true, L, N, Q>
 {
     static const std::size_t M = mp_size<L>::value - N::value + 1;
 
-    template<class I> using F = mp_slice_c<L, I::value, I::value + M>;
-
-    using J = mp_transform<F, mp_iota<N>>;
+    using J = mp_transform_q<mp_sliding_fold_impl_f<L, M>, mp_iota<N>>;
 
     using type = mp_apply<mp_transform_q, mp_push_front<J, Q>>;
 };
diff --git a/include/boost/mp11/detail/mp_copy_if.hpp b/include/boost/mp11/detail/mp_copy_if.hpp
index 4edcde0..99a6ab5 100644
--- a/include/boost/mp11/detail/mp_copy_if.hpp
+++ b/include/boost/mp11/detail/mp_copy_if.hpp
@@ -32,8 +32,7 @@ template<template<class...> class L, class... T, template<class...> class P> str
     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>...>;
+    using type = mp_append<L<>, mp_if<P<T>, mp_list<T>, mp_list<>>...>;
 #endif
 };
 
diff --git a/include/boost/mp11/detail/mp_map_find.hpp b/include/boost/mp11/detail/mp_map_find.hpp
index 035538a..f10157c 100644
--- a/include/boost/mp11/detail/mp_map_find.hpp
+++ b/include/boost/mp11/detail/mp_map_find.hpp
@@ -11,7 +11,8 @@
 #include <boost/mp11/utility.hpp>
 #include <boost/mp11/detail/config.hpp>
 
-#if BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, >= 140000 )
+#if (BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, >= 140000 ) && BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, < 140400 )) \
+ || (BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, >= 150000 ) && BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, < 150200 ))
 
 #include <boost/mp11/detail/mp_list.hpp>
 #include <boost/mp11/detail/mp_append.hpp>
@@ -34,20 +35,24 @@ namespace boost
 namespace mp11
 {
 
-#if BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, >= 140000 )
+#if (BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, >= 140000 ) && BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, < 140400 )) \
+ || (BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, >= 150000 ) && BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, < 150200 ))
 
 // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=120161
 
 namespace detail
 {
 
+template<class K, class T> struct mp_map_find_impl_k
+{
+    using type = mp_if<std::is_same<mp_front<T>, K>, mp_list<T>, mp_list<>>;
+};
+
 template<class M, class K> struct mp_map_find_impl;
 
 template<template<class...> class M, class... T, class K> struct mp_map_find_impl<M<T...>, K>
 {
-    template<class U> using _f = mp_if<std::is_same<mp_front<U>, K>, mp_list<U>, mp_list<>>;
-
-    using _l = mp_append<_f<T>..., mp_list<void>>;
+    using _l = mp_append<typename mp_map_find_impl_k<K, T>::type..., mp_list<void>>;
 
     using type = mp_front<_l>;
 };
@@ -99,14 +104,17 @@ template<class T> using mpmf_unwrap = typename mpmf_unwrap_impl<T>::type;
 
 template<class M, class K> struct mp_map_find_impl;
 
-template<template<class...> class M, class... T, class K> struct mp_map_find_impl<M<T...>, K>
+template<class K> struct mp_map_find_impl_f
 {
-    using U = mp_inherit<mpmf_wrap<T>...>;
-
     template<template<class...> class L, class... U> static mp_identity<L<K, U...>> f( mp_identity<L<K, U...>>* );
     static mp_identity<void> f( ... );
+};
+
+template<template<class...> class M, class... T, class K> struct mp_map_find_impl<M<T...>, K>
+{
+    using U = mp_inherit<mpmf_wrap<T>...>;
 
-    using type = mpmf_unwrap< decltype( f( static_cast<U*>(0) ) ) >;
+    using type = mpmf_unwrap< decltype( mp_map_find_impl_f<K>::f( static_cast<U*>(0) ) ) >;
 };
 
 } // namespace detail
diff --git a/include/boost/mp11/detail/mp_remove_if.hpp b/include/boost/mp11/detail/mp_remove_if.hpp
index 9687b4a..cafbf34 100644
--- a/include/boost/mp11/detail/mp_remove_if.hpp
+++ b/include/boost/mp11/detail/mp_remove_if.hpp
@@ -32,8 +32,7 @@ template<template<class...> class L, class... T, template<class...> class P> str
     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>...>;
+    using type = mp_append<L<>, mp_if<P<T>, mp_list<>, mp_list<T>>...>;
 #endif
 };
 
diff --git a/include/boost/mp11/integer_sequence.hpp b/include/boost/mp11/integer_sequence.hpp
index 013991f..279550b 100644
--- a/include/boost/mp11/integer_sequence.hpp
+++ b/include/boost/mp11/integer_sequence.hpp
@@ -19,6 +19,8 @@
 #if defined(__has_builtin)
 # if __has_builtin(__make_integer_seq)
 #  define BOOST_MP11_HAS_MAKE_INTEGER_SEQ
+# elif __has_builtin(__integer_pack)
+#  define BOOST_MP11_HAS_INTEGER_PACK
 # endif
 #endif
 
@@ -36,69 +38,51 @@ template<class T, T... I> struct integer_sequence
 
 template<class T, T N> using make_integer_sequence = __make_integer_seq<integer_sequence, T, N>;
 
+#elif defined(BOOST_MP11_HAS_INTEGER_PACK)
+
+template<class T, T N> using make_integer_sequence = integer_sequence<T, __integer_pack(N)...>;
+
 #else
 
 // detail::make_integer_sequence_impl
 namespace detail
 {
+template<bool, class T, T N, class L>
+struct iseq_expand;
 
-// iseq_if_c
-template<bool C, class T, class E> struct iseq_if_c_impl;
-
-template<class T, class E> struct iseq_if_c_impl<true, T, E>
+template<class T, T N, T... I>
+struct iseq_expand<false, T, N, integer_sequence<T, I...>>
 {
-    using type = T;
+    using type = integer_sequence<T, I..., (N+I)...>;
 };
 
-template<class T, class E> struct iseq_if_c_impl<false, T, E>
+template<class T, T N, T... I>
+struct iseq_expand<true, T, N, integer_sequence<T, I...>>
 {
-    using type = E;
+    using type = integer_sequence<T, I..., (N+I)..., N * 2>;
 };
 
-template<bool C, class T, class E> using iseq_if_c = typename iseq_if_c_impl<C, T, E>::type;
-
-// iseq_identity
-template<class T> struct iseq_identity
+template<class T, T N, T Zero, T One> struct make_integer_sequence_impl
 {
-    using type = T;
-};
-
-template<class S1, class S2> struct append_integer_sequence;
+    static_assert( N >= 0, "make_integer_sequence<T, N>: N must not be negative" );
 
-template<class T, T... I, T... J> struct append_integer_sequence<integer_sequence<T, I...>, integer_sequence<T, J...>>
-{
-    using type = integer_sequence< T, I..., ( J + sizeof...(I) )... >;
+    using type = typename iseq_expand<N & 1, T, N / 2, typename make_integer_sequence_impl<T, N / 2, Zero, One>::type>::type;
 };
 
-template<class T, T N> struct make_integer_sequence_impl;
-
-template<class T, T N> struct make_integer_sequence_impl_
+template<class T, T Zero, T One> struct make_integer_sequence_impl<T, Zero, Zero, One>
 {
-private:
-
-    static_assert( N >= 0, "make_integer_sequence<T, N>: N must not be negative" );
-
-    static T const M = N / 2;
-    static T const R = N % 2;
-
-    using S1 = typename make_integer_sequence_impl<T, M>::type;
-    using S2 = typename append_integer_sequence<S1, S1>::type;
-    using S3 = typename make_integer_sequence_impl<T, R>::type;
-    using S4 = typename append_integer_sequence<S2, S3>::type;
-
-public:
-
-    using type = S4;
+    using type = integer_sequence<T>;
 };
 
-template<class T, T N> struct make_integer_sequence_impl: iseq_if_c<N == 0, iseq_identity<integer_sequence<T>>, iseq_if_c<N == 1, iseq_identity<integer_sequence<T, 0>>, make_integer_sequence_impl_<T, N> > >
+template<class T, T Zero, T One> struct make_integer_sequence_impl<T, One, Zero, One>
 {
+    using type = integer_sequence<T, Zero>;
 };
 
 } // namespace detail
 
 // make_integer_sequence
-template<class T, T N> using make_integer_sequence = typename detail::make_integer_sequence_impl<T, N>::type;
+template<class T, T N> using make_integer_sequence = typename detail::make_integer_sequence_impl<T, N, 0, 1>::type;
 
 #endif // defined(BOOST_MP11_HAS_MAKE_INTEGER_SEQ)
 
diff --git a/include/boost/mp11/map.hpp b/include/boost/mp11/map.hpp
index b9581ac..0836507 100644
--- a/include/boost/mp11/map.hpp
+++ b/include/boost/mp11/map.hpp
@@ -38,11 +38,17 @@ template<template<class...> class M, class... U, class T> struct mp_map_replace_
 {
     using K = mp_first<T>;
 
-    // mp_replace_if is inlined here using a struct _f because of msvc-14.0
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
 
     template<class V> struct _f { using type = mp_if< std::is_same<mp_first<V>, K>, T, V >; };
 
     using type = mp_if< mp_map_contains<M<U...>, K>, M<typename _f<U>::type...>, M<U..., T> >;
+
+#else
+
+    using type = mp_if< mp_map_contains<M<U...>, K>, M<mp_if< std::is_same<mp_first<U>, K>, T, U >...>, M<U..., T> >;
+
+#endif
 };
 
 } // namespace detail
@@ -53,14 +59,37 @@ template<class M, class T> using mp_map_replace = typename detail::mp_map_replac
 namespace detail
 {
 
+#if ! BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1900 )
+
+template<class T> struct mp_map_update_impl_f
+{
+    template<class U> using fn = std::is_same<mp_first<T>, mp_first<U>>;
+};
+
+template<template<class...> class F> struct mp_map_update_impl_f3
+{
+    // fn<L<X, Y...>> -> L<X, F<X, Y...>>
+    template<class L> using fn = mp_assign<L, mp_list<mp_first<L>, mp_rename<L, F> > >;
+};
+
+#endif
+
 template<class M, class T, template<class...> class F> struct mp_map_update_impl
 {
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1900 )
+
     template<class U> using _f = std::is_same<mp_first<T>, mp_first<U>>;
 
     // _f3<L<X, Y...>> -> L<X, F<X, Y...>>
     template<class L> using _f3 = mp_assign<L, mp_list<mp_first<L>, mp_rename<L, F> > >;
 
     using type = mp_if< mp_map_contains<M, mp_first<T>>, mp_transform_if<_f, _f3, M>, mp_push_back<M, T> >;
+
+#else
+
+    using type = mp_if< mp_map_contains<M, mp_first<T>>, mp_transform_if_q<mp_map_update_impl_f<T>, mp_map_update_impl_f3<F>, M>, mp_push_back<M, T> >;
+
+#endif
 };
 
 } // namespace detail
@@ -72,15 +101,14 @@ template<class M, class T, class Q> using mp_map_update_q = mp_map_update<M, T,
 namespace detail
 {
 
-template<class M, class K> struct mp_map_erase_impl
+template<class K> struct mp_map_erase_impl
 {
-    template<class T> using _f = std::is_same<mp_first<T>, K>;
-    using type = mp_remove_if<M, _f>;
+    template<class T> using fn = std::is_same<mp_first<T>, K>;
 };
 
 } // namespace detail
 
-template<class M, class K> using mp_map_erase = typename detail::mp_map_erase_impl<M, K>::type;
+template<class M, class K> using mp_map_erase = mp_remove_if_q<M, detail::mp_map_erase_impl<K>>;
 
 // mp_map_keys<M>
 template<class M> using mp_map_keys = mp_transform<mp_first, M>;