diff --git a/doc/mp11/algorithm.adoc b/doc/mp11/algorithm.adoc
index 95b9d73..ce9f0dc 100644
--- a/doc/mp11/algorithm.adoc
+++ b/doc/mp11/algorithm.adoc
@@ -19,6 +19,10 @@ http://www.boost.org/LICENSE_1_0.txt
 
 `mp_transform<F, L1<T1...>, L2<T2...>, ..., Ln<Tn...>>` applies `F` to each successive tuple of elements and returns `L1<F<T1, T2, ..., Tn>...>`.
 
+Has limited support of value lists as `L...` under {cpp}17 (for one to three lists.)
+In that case, elements are wrapped with `mp_value` before being passed to `F`, and
+are unwrapped afterwards. The result is `L1<F<mp_value<T1>, mp_value<T2>, ...>::value...>`.
+
 .Using mp_transform to produce a list of pointers from a list of pointees
 ```
 template<class T> using add_pointer_t =
@@ -414,6 +418,28 @@ Supports a value list as `L` under {cpp}17.
 
 Same as `mp_take_c`, but with a type argument `N`. `N::value` must be a nonnegative number.
 
+## mp_slice_c<L, I, J>
+
+    template<class L, std::size_t I, std::size_t J> using mp_slice_c = mp_drop_c<mp_take_c<L, J>, I>;
+
+`mp_slice_c<L, I, J>` returns a list of the same form as `L` containing the elements from index `I` (inclusive) to index `J` (exclusive).
+
+Supports a value list as `L` under {cpp}17.
+
+.mp_slice_c
+[cols="<.^4m,8*^.^1m",width=85%]
+|===
+|*L1*|A~0~|...|A~i~|...|A~j-1~|A~j~|...|A~n-1~
+9+|
+|*mp_slice_c<L1, I, J>* 2+>||A~i~|...|A~j-1~ 3+|
+|===
+
+## mp_slice<L, I, J>
+
+    template<class L, class I, class J> using mp_slice = mp_drop<mp_take<L, J>, I>;
+
+Same as `mp_slice_c`, but with type arguments `I` and `J`. `I::value` and `J::value` must be nonnegative numbers.
+
 ## mp_back<L>
 
     template<class L> using mp_back = mp_at_c<L, mp_size<L>::value - 1>;
@@ -699,6 +725,8 @@ Like `mp_nth_element`, but takes a quoted metafunction.
 
 It's equivalent to `mp_fold<mp_rest<L>, mp_first<L>, F>`, where `F<T, U>` returns `mp_if<P<T, U>, T, U>`.
 
+Supports a value list as `L` under {cpp}17. In that case, the element is returned wrapped with `mp_value`.
+
 ## mp_min_element_q<L, Q>
 
     template<class L, class Q> using mp_min_element_q = mp_min_element<L, Q::template fn>;
@@ -713,6 +741,8 @@ As `mp_min_element`, but takes a quoted metafunction.
 
 It's equivalent to `mp_fold<mp_rest<L>, mp_first<L>, F>`, where `F<T, U>` returns `mp_if<P<U, T>, T, U>`.
 
+Supports a value list as `L` under {cpp}17. In that case, the element is returned wrapped with `mp_value`.
+
 ## mp_max_element_q<L, Q>
 
     template<class L, class Q> using mp_max_element_q = mp_max_element<L, Q::template fn>;
@@ -846,6 +876,39 @@ template<class L, template<class...> class P> using is_sorted =
     mp_none_of<mp_pairwise_fold_q<L, mp_bind<P, _2, _1>>, mp_to_bool>;
 ----
 
+## mp_sliding_fold<L, N, F>
+
+    template<class L, class N, template<class...> class F> using mp_sliding_fold = /*...*/;
+
+`mp_sliding_fold<L, N, F>` returns a list of the same form as `L` whose elements are
+the result of the application of the n-ary metafunction `F` to each n-tuple of adjacent
+elements of `L`. That is, `mp_sliding_fold<L<T1, T2, T3, T4>, mp_size_t<3>, F>` is
+`L<F<T1, T2, T3>, F<T2, T3, T4>>`.
+
+The result has `N-1` fewer elements than the original.
+If `L` has fewer than `N::value` elements, the result is an empty list.
+
+.Using mp_sliding_fold
+----
+template<class L, class N> using local_maximum =
+    mp_sliding_fold<L, N, mp_max>;
+----
+
+## mp_sliding_fold_q<L, N, Q>
+
+    template<class L, class N, class Q> using mp_sliding_fold_q =
+        mp_sliding_fold<L, N, Q::template fn>;
+
+As `mp_sliding_fold`, but takes a quoted metafunction.
+
+.Using mp_sliding_fold_q
+----
+struct average { template<class... C> using fn = mp_int<mp_plus<C...>::value / sizeof...(C)>; };
+
+template<class L, class N> using moving_average =
+    mp_sliding_fold_q<L, N, average>;
+----
+
 ## mp_iterate<V, F, R>
 
     template<class V, template<class...> class F, template<class...> class R>
diff --git a/doc/mp11/changelog.adoc b/doc/mp11/changelog.adoc
index f3fb9b4..59f3d17 100644
--- a/doc/mp11/changelog.adoc
+++ b/doc/mp11/changelog.adoc
@@ -1,5 +1,5 @@
 ////
-Copyright 2019-2020 Peter Dimov
+Copyright 2019-2023 Peter Dimov
 
 Distributed under the Boost Software License, Version 1.0.
 
@@ -10,6 +10,13 @@ http://www.boost.org/LICENSE_1_0.txt
 [#changelog]
 # Revision History
 
+## Changes in 1.85.0
+
+* Added `mp_sliding_fold`, a generalization of `mp_pairwise_fold` (contributed by Braden Ganetsky)
+* Added `mp_slice` (thanks to Braden Ganetsky)
+* Added value list support to `mp_min_element`, `mp_max_element`.
+* Added limited value list support to `mp_transform`.
+
 ## Changes in 1.83.0
 
 * Added an offset/from parameter to `mp_from_sequence`, `mp_iota`, `mp_iota_c`.
diff --git a/include/boost/mp11/algorithm.hpp b/include/boost/mp11/algorithm.hpp
index be377f5..8f80244 100644
--- a/include/boost/mp11/algorithm.hpp
+++ b/include/boost/mp11/algorithm.hpp
@@ -26,6 +26,11 @@
 #include <type_traits>
 #include <utility>
 
+#if defined(_MSC_VER) || defined(__GNUC__)
+# pragma push_macro( "I" )
+# undef I
+#endif
+
 namespace boost
 {
 namespace mp11
@@ -84,6 +89,25 @@ template<template<class...> class F, template<class...> class L1, class... T1, t
 #endif
 };
 
+#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+template<template<class...> class F, template<auto...> class L, auto... A> struct mp_transform_impl<F, L<A...>>
+{
+    using type = L< F< mp_value<A> >::value... >;
+};
+
+template<template<class...> class F, template<auto...> class L1, auto... A1, template<auto...> class L2, auto... A2> struct mp_transform_impl<F, L1<A1...>, L2<A2...>>
+{
+    using type = L1< F< mp_value<A1>, mp_value<A2> >::value... >;
+};
+
+template<template<class...> class F, template<auto...> class L1, auto... A1, template<auto...> class L2, auto... A2, template<auto...> class L3, auto... A3> struct mp_transform_impl<F, L1<A1...>, L2<A2...>, L3<A3...>>
+{
+    using type = L1< F< mp_value<A1>, mp_value<A2>, mp_value<A3> >::value... >;
+};
+
+#endif
+
 #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>...>;
@@ -473,6 +497,10 @@ struct mp_take_c_impl<N, L<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T...>, typen
 template<class L, std::size_t N> using mp_take_c = mp_assign<L, typename detail::mp_take_c_impl<N, mp_rename<L, mp_list>>::type>;
 template<class L, class N> using mp_take = mp_take_c<L, std::size_t{ N::value }>;
 
+// mp_slice(_c)<L, I, J>
+template<class L, std::size_t I, std::size_t J> using mp_slice_c = mp_drop_c< mp_take_c<L, J>, I >;
+template<class L, class I, class J> using mp_slice = mp_drop< mp_take<L, J>, I >;
+
 // mp_back<L>
 template<class L> using mp_back = mp_at_c<L, mp_size<L>::value - 1>;
 
@@ -1261,6 +1289,33 @@ template<class L, class Q> using mp_pairwise_fold_impl = mp_transform_q<Q, mp_po
 template<class L, class Q> using mp_pairwise_fold_q = mp_eval_if<mp_empty<L>, mp_clear<L>, detail::mp_pairwise_fold_impl, L, Q>;
 template<class L, template<class...> class F> using mp_pairwise_fold = mp_pairwise_fold_q<L, mp_quote<F>>;
 
+// mp_sliding_fold<L, N, F>
+namespace detail
+{
+
+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 type = mp_apply<mp_transform_q, mp_push_front<J, Q>>;
+};
+
+template<class L, class N, class Q> struct mp_sliding_fold_impl<mp_false, L, N, Q>
+{
+    using type = mp_clear<L>;
+};
+
+} // namespace detail
+
+template<class L, class N, class Q> using mp_sliding_fold_q = typename detail::mp_sliding_fold_impl<mp_bool<(mp_size<L>::value >= N::value)>, L, N, Q>::type;
+template<class L, class N, template<class...> class F> using mp_sliding_fold = mp_sliding_fold_q<L, N, mp_quote<F>>;
+
 // mp_intersperse<L, S>
 namespace detail
 {
@@ -1324,4 +1379,8 @@ template<class L, class S> using mp_join = mp_apply<mp_append, mp_intersperse<L,
 } // namespace mp11
 } // namespace boost
 
+#if defined(_MSC_VER) || defined(__GNUC__)
+# pragma pop_macro( "I" )
+#endif
+
 #endif // #ifndef BOOST_MP11_ALGORITHM_HPP_INCLUDED
diff --git a/include/boost/mp11/bind.hpp b/include/boost/mp11/bind.hpp
index bbdecd2..289b073 100644
--- a/include/boost/mp11/bind.hpp
+++ b/include/boost/mp11/bind.hpp
@@ -12,6 +12,11 @@
 #include <boost/mp11/utility.hpp>
 #include <cstddef>
 
+#if defined(_MSC_VER) || defined(__GNUC__)
+# pragma push_macro( "I" )
+# undef I
+#endif
+
 namespace boost
 {
 namespace mp11
@@ -108,4 +113,8 @@ template<class Q, class... T> using mp_bind_q = mp_bind<Q::template fn, T...>;
 } // namespace mp11
 } // namespace boost
 
+#if defined(_MSC_VER) || defined(__GNUC__)
+# pragma pop_macro( "I" )
+#endif
+
 #endif // #ifndef BOOST_MP11_BIND_HPP_INCLUDED
diff --git a/include/boost/mp11/detail/mp_fold.hpp b/include/boost/mp11/detail/mp_fold.hpp
index 266d9c1..e2c464c 100644
--- a/include/boost/mp11/detail/mp_fold.hpp
+++ b/include/boost/mp11/detail/mp_fold.hpp
@@ -10,6 +10,8 @@
 
 #include <boost/mp11/detail/config.hpp>
 #include <boost/mp11/detail/mp_defer.hpp>
+#include <boost/mp11/detail/mp_rename.hpp>
+#include <boost/mp11/detail/mp_list.hpp>
 
 namespace boost
 {
@@ -155,7 +157,7 @@ struct mp_fold_impl<L<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T...>, V, F>
 
 } // namespace detail
 
-template<class L, class V, template<class...> class F> using mp_fold = typename detail::mp_fold_impl<L, V, F>::type;
+template<class L, class V, template<class...> class F> using mp_fold = typename detail::mp_fold_impl<mp_rename<L, mp_list>, V, F>::type;
 template<class L, class V, class Q> using mp_fold_q = mp_fold<L, V, Q::template fn>;
 
 } // namespace mp11
diff --git a/include/boost/mp11/integer_sequence.hpp b/include/boost/mp11/integer_sequence.hpp
index 83e2450..013991f 100644
--- a/include/boost/mp11/integer_sequence.hpp
+++ b/include/boost/mp11/integer_sequence.hpp
@@ -11,6 +11,11 @@
 #include <boost/mp11/version.hpp>
 #include <cstddef>
 
+#if defined(_MSC_VER) || defined(__GNUC__)
+# pragma push_macro( "I" )
+# undef I
+#endif
+
 #if defined(__has_builtin)
 # if __has_builtin(__make_integer_seq)
 #  define BOOST_MP11_HAS_MAKE_INTEGER_SEQ
@@ -109,4 +114,8 @@ template<class... T> using index_sequence_for = make_integer_sequence<std::size_
 } // namespace mp11
 } // namespace boost
 
+#if defined(_MSC_VER) || defined(__GNUC__)
+# pragma pop_macro( "I" )
+#endif
+
 #endif // #ifndef BOOST_MP11_INTEGER_SEQUENCE_HPP_INCLUDED
diff --git a/include/boost/mp11/integral.hpp b/include/boost/mp11/integral.hpp
index 1b4fea3..4848ac8 100644
--- a/include/boost/mp11/integral.hpp
+++ b/include/boost/mp11/integral.hpp
@@ -13,6 +13,11 @@
 #include <type_traits>
 #include <cstddef>
 
+#if defined(_MSC_VER) || defined(__GNUC__)
+# pragma push_macro( "I" )
+# undef I
+#endif
+
 namespace boost
 {
 namespace mp11
@@ -39,4 +44,8 @@ template<std::size_t N> using mp_size_t = std::integral_constant<std::size_t, N>
 } // namespace mp11
 } // namespace boost
 
+#if defined(_MSC_VER) || defined(__GNUC__)
+# pragma pop_macro( "I" )
+#endif
+
 #endif // #ifndef BOOST_MP11_INTEGRAL_HPP_INCLUDED
diff --git a/include/boost/mp11/list.hpp b/include/boost/mp11/list.hpp
index 3646764..46b5605 100644
--- a/include/boost/mp11/list.hpp
+++ b/include/boost/mp11/list.hpp
@@ -19,6 +19,11 @@
 #include <boost/mp11/detail/config.hpp>
 #include <type_traits>
 
+#if defined(_MSC_VER) || defined(__GNUC__)
+# pragma push_macro( "I" )
+# undef I
+#endif
+
 namespace boost
 {
 namespace mp11
@@ -469,4 +474,8 @@ template<class L, class Q> using mp_transform_third_q = mp_transform_third<L, Q:
 } // namespace mp11
 } // namespace boost
 
+#if defined(_MSC_VER) || defined(__GNUC__)
+# pragma pop_macro( "I" )
+#endif
+
 #endif // #ifndef BOOST_MP11_LIST_HPP_INCLUDED
diff --git a/test/Jamfile b/test/Jamfile
index 335c812..8fc035c 100644
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -23,6 +23,7 @@ project
 
 # include-only
 compile mp11.cpp ;
+compile complex_h.cpp ;
 
 # list
 run mp_size.cpp ;
@@ -73,7 +74,9 @@ run mp_is_value_list.cpp ;
 
 # algorithm
 run mp_transform.cpp ;
+run mp_transform_2.cpp ;
 run mp_transform_q.cpp ;
+run mp_transform_q_2.cpp ;
 run mp_transform_sf.cpp ;
 run mp_transform_if.cpp ;
 run mp_transform_if_q.cpp ;
@@ -99,6 +102,8 @@ run mp_at_2.cpp ;
 run mp_at_sf.cpp : : : <toolset>gcc-4.7:<warnings>all ;
 run mp_take.cpp ;
 run mp_take_2.cpp ;
+run mp_slice.cpp ;
+run mp_slice_2.cpp ;
 run mp_replace.cpp ;
 run mp_replace_if.cpp ;
 run mp_replace_if_q.cpp ;
@@ -141,9 +146,13 @@ run mp_with_index_cx.cpp ;
 run mp_from_sequence.cpp ;
 run mp_from_sequence_2.cpp ;
 run mp_min_element.cpp ;
+run mp_min_element_2.cpp ;
 run mp_min_element_q.cpp ;
+run mp_min_element_q_2.cpp ;
 run mp_max_element.cpp ;
+run mp_max_element_2.cpp ;
 run mp_max_element_q.cpp ;
+run mp_max_element_q_2.cpp ;
 run mp_nth_element.cpp ;
 run mp_nth_element_q.cpp ;
 run mp_back.cpp ;
@@ -158,6 +167,8 @@ run mp_partial_sum.cpp ;
 run mp_iterate.cpp ;
 run mp_pairwise_fold.cpp ;
 run mp_pairwise_fold_q.cpp ;
+run mp_sliding_fold.cpp ;
+run mp_sliding_fold_q.cpp ;
 run mp_intersperse.cpp ;
 run mp_split.cpp ;
 run mp_join.cpp ;
diff --git a/test/complex_h.cpp b/test/complex_h.cpp
new file mode 100644
index 0000000..63d2675
--- /dev/null
+++ b/test/complex_h.cpp
@@ -0,0 +1,12 @@
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#define _SILENCE_CXX17_C_HEADER_DEPRECATION_WARNING
+
+#include <complex.h>
+#include <boost/mp11.hpp>
+
+int main()
+{
+}
diff --git a/test/mp_max_element_2.cpp b/test/mp_max_element_2.cpp
new file mode 100644
index 0000000..966a698
--- /dev/null
+++ b/test/mp_max_element_2.cpp
@@ -0,0 +1,58 @@
+// Copyright 2017, 2023 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/mp11/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+
+#if !defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+#pragma message("Test skipped because BOOST_MP11_HAS_TEMPLATE_AUTO is not defined")
+int main() {}
+
+#else
+
+#include <boost/core/lightweight_test_trait.hpp>
+
+template<auto... A> struct V1 {};
+template<int... I> struct V2 {};
+
+int main()
+{
+    using boost::mp11::mp_max_element;
+    using boost::mp11::mp_less;
+    using boost::mp11::mp_int;
+
+    {
+        using L1 = V1<1>;
+        BOOST_TEST_TRAIT_SAME(mp_max_element<L1, mp_less>, mp_int<1>);
+
+        using L2 = V1<2, 4, 3, 1>;
+        BOOST_TEST_TRAIT_SAME(mp_max_element<L2, mp_less>, mp_int<4>);
+
+        using L3 = V1<2, 1, 2, 3>;
+        BOOST_TEST_TRAIT_SAME(mp_max_element<L3, mp_less>, mp_int<3>);
+
+        using L4 = V1<-1, 1u, -2, 2u>;
+        BOOST_TEST_TRAIT_SAME(mp_max_element<L4, mp_less>, std::integral_constant<unsigned, 2>);
+    }
+
+    {
+        using L1 = V2<1>;
+        BOOST_TEST_TRAIT_SAME(mp_max_element<L1, mp_less>, mp_int<1>);
+
+        using L2 = V2<2, 4, 3, 1>;
+        BOOST_TEST_TRAIT_SAME(mp_max_element<L2, mp_less>, mp_int<4>);
+
+        using L3 = V2<2, 1, 2, 3>;
+        BOOST_TEST_TRAIT_SAME(mp_max_element<L3, mp_less>, mp_int<3>);
+
+        using L4 = V2<-1, 1, -2, 2>;
+        BOOST_TEST_TRAIT_SAME(mp_max_element<L4, mp_less>, mp_int<2>);
+    }
+
+    return boost::report_errors();
+}
+
+#endif
diff --git a/test/mp_max_element_q_2.cpp b/test/mp_max_element_q_2.cpp
new file mode 100644
index 0000000..4956d8a
--- /dev/null
+++ b/test/mp_max_element_q_2.cpp
@@ -0,0 +1,61 @@
+// Copyright 2017, 2023 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/mp11/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+
+#if !defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+#pragma message("Test skipped because BOOST_MP11_HAS_TEMPLATE_AUTO is not defined")
+int main() {}
+
+#else
+
+#include <boost/core/lightweight_test_trait.hpp>
+
+template<auto... A> struct V1 {};
+template<int... I> struct V2 {};
+
+int main()
+{
+    using boost::mp11::mp_max_element_q;
+    using boost::mp11::mp_less;
+    using boost::mp11::mp_int;
+    using boost::mp11::mp_quote;
+
+    using Q = mp_quote<mp_less>;
+
+    {
+        using L1 = V1<1>;
+        BOOST_TEST_TRAIT_SAME(mp_max_element_q<L1, Q>, mp_int<1>);
+
+        using L2 = V1<2, 4, 3, 1>;
+        BOOST_TEST_TRAIT_SAME(mp_max_element_q<L2, Q>, mp_int<4>);
+
+        using L3 = V1<2, 1, 2, 3>;
+        BOOST_TEST_TRAIT_SAME(mp_max_element_q<L3, Q>, mp_int<3>);
+
+        using L4 = V1<-1, 1u, -2, 2u>;
+        BOOST_TEST_TRAIT_SAME(mp_max_element_q<L4, Q>, std::integral_constant<unsigned, 2>);
+    }
+
+    {
+        using L1 = V2<1>;
+        BOOST_TEST_TRAIT_SAME(mp_max_element_q<L1, Q>, mp_int<1>);
+
+        using L2 = V2<2, 4, 3, 1>;
+        BOOST_TEST_TRAIT_SAME(mp_max_element_q<L2, Q>, mp_int<4>);
+
+        using L3 = V2<2, 1, 2, 3>;
+        BOOST_TEST_TRAIT_SAME(mp_max_element_q<L3, Q>, mp_int<3>);
+
+        using L4 = V2<-1, 1, -2, 2>;
+        BOOST_TEST_TRAIT_SAME(mp_max_element_q<L4, Q>, mp_int<2>);
+    }
+
+    return boost::report_errors();
+}
+
+#endif
diff --git a/test/mp_min_element_2.cpp b/test/mp_min_element_2.cpp
new file mode 100644
index 0000000..8089964
--- /dev/null
+++ b/test/mp_min_element_2.cpp
@@ -0,0 +1,58 @@
+// Copyright 2017, 2023 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/mp11/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+
+#if !defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+#pragma message("Test skipped because BOOST_MP11_HAS_TEMPLATE_AUTO is not defined")
+int main() {}
+
+#else
+
+#include <boost/core/lightweight_test_trait.hpp>
+
+template<auto... A> struct V1 {};
+template<int... I> struct V2 {};
+
+int main()
+{
+    using boost::mp11::mp_min_element;
+    using boost::mp11::mp_less;
+    using boost::mp11::mp_int;
+
+    {
+        using L1 = V1<1>;
+        BOOST_TEST_TRAIT_SAME(mp_min_element<L1, mp_less>, mp_int<1>);
+
+        using L2 = V1<2, 4, 3, 1>;
+        BOOST_TEST_TRAIT_SAME(mp_min_element<L2, mp_less>, mp_int<1>);
+
+        using L3 = V1<2, 1, 2, 3>;
+        BOOST_TEST_TRAIT_SAME(mp_min_element<L3, mp_less>, mp_int<1>);
+
+        using L4 = V1<-1, 1u, -2, 2u>;
+        BOOST_TEST_TRAIT_SAME(mp_min_element<L4, mp_less>, mp_int<-2>);
+    }
+
+    {
+        using L1 = V2<1>;
+        BOOST_TEST_TRAIT_SAME(mp_min_element<L1, mp_less>, mp_int<1>);
+
+        using L2 = V2<2, 4, 3, 1>;
+        BOOST_TEST_TRAIT_SAME(mp_min_element<L2, mp_less>, mp_int<1>);
+
+        using L3 = V2<2, 1, 2, 3>;
+        BOOST_TEST_TRAIT_SAME(mp_min_element<L3, mp_less>, mp_int<1>);
+
+        using L4 = V2<-1, 1, -2, 2>;
+        BOOST_TEST_TRAIT_SAME(mp_min_element<L4, mp_less>, mp_int<-2>);
+    }
+
+    return boost::report_errors();
+}
+
+#endif
diff --git a/test/mp_min_element_q_2.cpp b/test/mp_min_element_q_2.cpp
new file mode 100644
index 0000000..c1bb920
--- /dev/null
+++ b/test/mp_min_element_q_2.cpp
@@ -0,0 +1,61 @@
+// Copyright 2017, 2023 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/mp11/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+
+#if !defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+#pragma message("Test skipped because BOOST_MP11_HAS_TEMPLATE_AUTO is not defined")
+int main() {}
+
+#else
+
+#include <boost/core/lightweight_test_trait.hpp>
+
+template<auto... A> struct V1 {};
+template<int... I> struct V2 {};
+
+int main()
+{
+    using boost::mp11::mp_min_element_q;
+    using boost::mp11::mp_less;
+    using boost::mp11::mp_int;
+    using boost::mp11::mp_quote;
+
+    using Q = mp_quote<mp_less>;
+
+    {
+        using L1 = V1<1>;
+        BOOST_TEST_TRAIT_SAME(mp_min_element_q<L1, Q>, mp_int<1>);
+
+        using L2 = V1<2, 4, 3, 1>;
+        BOOST_TEST_TRAIT_SAME(mp_min_element_q<L2, Q>, mp_int<1>);
+
+        using L3 = V1<2, 1, 2, 3>;
+        BOOST_TEST_TRAIT_SAME(mp_min_element_q<L3, Q>, mp_int<1>);
+
+        using L4 = V1<-1, 1u, -2, 2u>;
+        BOOST_TEST_TRAIT_SAME(mp_min_element_q<L4, Q>, mp_int<-2>);
+    }
+
+    {
+        using L1 = V2<1>;
+        BOOST_TEST_TRAIT_SAME(mp_min_element_q<L1, Q>, mp_int<1>);
+
+        using L2 = V2<2, 4, 3, 1>;
+        BOOST_TEST_TRAIT_SAME(mp_min_element_q<L2, Q>, mp_int<1>);
+
+        using L3 = V2<2, 1, 2, 3>;
+        BOOST_TEST_TRAIT_SAME(mp_min_element_q<L3, Q>, mp_int<1>);
+
+        using L4 = V2<-1, 1, -2, 2>;
+        BOOST_TEST_TRAIT_SAME(mp_min_element_q<L4, Q>, mp_int<-2>);
+    }
+
+    return boost::report_errors();
+}
+
+#endif
diff --git a/test/mp_slice.cpp b/test/mp_slice.cpp
new file mode 100644
index 0000000..867eb55
--- /dev/null
+++ b/test/mp_slice.cpp
@@ -0,0 +1,118 @@
+// Copyright 2023 Braden Ganetsky (braden.ganetsky@gmail.com)
+//
+// 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/core/lightweight_test_trait.hpp>
+#include <boost/mp11/algorithm.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_size_t;
+    using boost::mp11::mp_slice_c;
+    using boost::mp11::mp_slice;
+
+    {
+        using L1 = mp_list<int[], void, float&, char, bool*>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 0, 0>, mp_list<>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 0, 1>, mp_list<int[]>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 0, 2>, mp_list<int[], void>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 0, 3>, mp_list<int[], void, float&>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 0, 4>, mp_list<int[], void, float&, char>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 0, 5>, mp_list<int[], void, float&, char, bool*>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 1, 1>, mp_list<>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 1, 2>, mp_list<void>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 1, 3>, mp_list<void, float&>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 1, 4>, mp_list<void, float&, char>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 1, 5>, mp_list<void, float&, char, bool*>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 2, 2>, mp_list<>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 2, 3>, mp_list<float&>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 2, 4>, mp_list<float&, char>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 2, 5>, mp_list<float&, char, bool*>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 3, 3>, mp_list<>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 3, 4>, mp_list<char>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 3, 5>, mp_list<char, bool*>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 4, 4>, mp_list<>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 4, 5>, mp_list<bool*>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L1, 5, 5>, mp_list<>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<0>, mp_size_t<0>>, mp_list<>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<0>, mp_size_t<1>>, mp_list<int[]>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<0>, mp_size_t<2>>, mp_list<int[], void>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<0>, mp_size_t<3>>, mp_list<int[], void, float&>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<0>, mp_size_t<4>>, mp_list<int[], void, float&, char>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<0>, mp_size_t<5>>, mp_list<int[], void, float&, char, bool*>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<1>, mp_size_t<1>>, mp_list<>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<1>, mp_size_t<2>>, mp_list<void>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<1>, mp_size_t<3>>, mp_list<void, float&>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<1>, mp_size_t<4>>, mp_list<void, float&, char>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<1>, mp_size_t<5>>, mp_list<void, float&, char, bool*>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<2>, mp_size_t<2>>, mp_list<>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<2>, mp_size_t<3>>, mp_list<float&>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<2>, mp_size_t<4>>, mp_list<float&, char>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<2>, mp_size_t<5>>, mp_list<float&, char, bool*>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<3>, mp_size_t<3>>, mp_list<>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<3>, mp_size_t<4>>, mp_list<char>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<3>, mp_size_t<5>>, mp_list<char, bool*>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<4>, mp_size_t<4>>, mp_list<>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<4>, mp_size_t<5>>, mp_list<bool*>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L1, mp_size_t<5>, mp_size_t<5>>, mp_list<>>));
+    }
+
+    {
+        using L2 = std::tuple<int[], void, float&, char, bool*>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 0, 0>, std::tuple<>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 0, 1>, std::tuple<int[]>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 0, 2>, std::tuple<int[], void>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 0, 3>, std::tuple<int[], void, float&>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 0, 4>, std::tuple<int[], void, float&, char>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 0, 5>, std::tuple<int[], void, float&, char, bool*>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 1, 1>, std::tuple<>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 1, 2>, std::tuple<void>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 1, 3>, std::tuple<void, float&>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 1, 4>, std::tuple<void, float&, char>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 1, 5>, std::tuple<void, float&, char, bool*>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 2, 2>, std::tuple<>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 2, 3>, std::tuple<float&>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 2, 4>, std::tuple<float&, char>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 2, 5>, std::tuple<float&, char, bool*>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 3, 3>, std::tuple<>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 3, 4>, std::tuple<char>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 3, 5>, std::tuple<char, bool*>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 4, 4>, std::tuple<>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 4, 5>, std::tuple<bool*>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice_c<L2, 5, 5>, std::tuple<>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<0>, mp_size_t<0>>, std::tuple<>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<0>, mp_size_t<1>>, std::tuple<int[]>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<0>, mp_size_t<2>>, std::tuple<int[], void>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<0>, mp_size_t<3>>, std::tuple<int[], void, float&>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<0>, mp_size_t<4>>, std::tuple<int[], void, float&, char>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<0>, mp_size_t<5>>, std::tuple<int[], void, float&, char, bool*>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<1>, mp_size_t<1>>, std::tuple<>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<1>, mp_size_t<2>>, std::tuple<void>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<1>, mp_size_t<3>>, std::tuple<void, float&>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<1>, mp_size_t<4>>, std::tuple<void, float&, char>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<1>, mp_size_t<5>>, std::tuple<void, float&, char, bool*>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<2>, mp_size_t<2>>, std::tuple<>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<2>, mp_size_t<3>>, std::tuple<float&>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<2>, mp_size_t<4>>, std::tuple<float&, char>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<2>, mp_size_t<5>>, std::tuple<float&, char, bool*>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<3>, mp_size_t<3>>, std::tuple<>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<3>, mp_size_t<4>>, std::tuple<char>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<3>, mp_size_t<5>>, std::tuple<char, bool*>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<4>, mp_size_t<4>>, std::tuple<>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<4>, mp_size_t<5>>, std::tuple<bool*>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_slice<L2, mp_size_t<5>, mp_size_t<5>>, std::tuple<>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/test/mp_slice_2.cpp b/test/mp_slice_2.cpp
new file mode 100644
index 0000000..1ac2d73
--- /dev/null
+++ b/test/mp_slice_2.cpp
@@ -0,0 +1,168 @@
+// Copyright 2023 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/mp11/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+
+#if !defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+#pragma message("Test skipped because BOOST_MP11_HAS_TEMPLATE_AUTO is not defined")
+int main() {}
+
+#else
+
+#include <boost/core/lightweight_test_trait.hpp>
+
+template<auto... A> struct V1 {};
+template<int... I> struct V2 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_slice;
+    using boost::mp11::mp_slice_c;
+    using boost::mp11::mp_size_t;
+
+    {
+        using L1 = V1<>;
+
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L1, 0, 0>, L1);
+        BOOST_TEST_TRAIT_SAME(mp_slice<L1, mp_size_t<0>, mp_size_t<0>>, L1);
+
+        using L2 = V1<false, 0, true, 1, std::size_t(2)>;
+
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 0, 0>, V1<>);
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 0, 1>, V1<false>);
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 0, 2>, V1<false, 0>);
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 0, 3>, V1<false, 0, true>);
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 0, 4>, V1<false, 0, true, 1>);
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 0, 5>, V1<false, 0, true, 1, std::size_t(2)>);
+
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 1, 1>, V1<>);
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 1, 2>, V1<0>);
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 1, 3>, V1<0, true>);
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 1, 4>, V1<0, true, 1>);
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 1, 5>, V1<0, true, 1, std::size_t(2)>);
+
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 2, 2>, V1<>);
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 2, 3>, V1<true>);
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 2, 4>, V1<true, 1>);
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 2, 5>, V1<true, 1, std::size_t(2)>);
+
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 3, 3>, V1<>);
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 3, 4>, V1<1>);
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 3, 5>, V1<1, std::size_t(2)>);
+
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 4, 4>, V1<>);
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 4, 5>, V1<std::size_t(2)>);
+
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 5, 5>, V1<>);
+
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<0>, mp_size_t<0>>, V1<>);
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<0>, mp_size_t<1>>, V1<false>);
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<0>, mp_size_t<2>>, V1<false, 0>);
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<0>, mp_size_t<3>>, V1<false, 0, true>);
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<0>, mp_size_t<4>>, V1<false, 0, true, 1>);
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<0>, mp_size_t<5>>, V1<false, 0, true, 1, std::size_t(2)>);
+
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<1>, mp_size_t<1>>, V1<>);
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<1>, mp_size_t<2>>, V1<0>);
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<1>, mp_size_t<3>>, V1<0, true>);
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<1>, mp_size_t<4>>, V1<0, true, 1>);
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<1>, mp_size_t<5>>, V1<0, true, 1, std::size_t(2)>);
+
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<2>, mp_size_t<2>>, V1<>);
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<2>, mp_size_t<3>>, V1<true>);
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<2>, mp_size_t<4>>, V1<true, 1>);
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<2>, mp_size_t<5>>, V1<true, 1, std::size_t(2)>);
+
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<3>, mp_size_t<3>>, V1<>);
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<3>, mp_size_t<4>>, V1<1>);
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<3>, mp_size_t<5>>, V1<1, std::size_t(2)>);
+
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<4>, mp_size_t<4>>, V1<>);
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<4>, mp_size_t<5>>, V1<std::size_t(2)>);
+
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<5>, mp_size_t<5>>, V1<>);
+    }
+
+    {
+        using L1 = V2<>;
+
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L1, 0, 0>, L1);
+        BOOST_TEST_TRAIT_SAME(mp_slice<L1, mp_size_t<0>, mp_size_t<0>>, L1);
+
+        using L2 = V2<1, 2, 3, 4, 5>;
+
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 0, 0>, V2<>);
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 0, 1>, V2<1>);
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 0, 2>, V2<1, 2>);
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 0, 3>, V2<1, 2, 3>);
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 0, 4>, V2<1, 2, 3, 4>);
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 0, 5>, V2<1, 2, 3, 4, 5>);
+
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 1, 1>, V2<>);
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 1, 2>, V2<2>);
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 1, 3>, V2<2, 3>);
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 1, 4>, V2<2, 3, 4>);
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 1, 5>, V2<2, 3, 4, 5>);
+
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 2, 2>, V2<>);
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 2, 3>, V2<3>);
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 2, 4>, V2<3, 4>);
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 2, 5>, V2<3, 4, 5>);
+
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 3, 3>, V2<>);
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 3, 4>, V2<4>);
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 3, 5>, V2<4, 5>);
+
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 4, 4>, V2<>);
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 4, 5>, V2<5>);
+
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 5, 5>, V2<>);
+
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<0>, mp_size_t<0>>, V2<>);
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<0>, mp_size_t<1>>, V2<1>);
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<0>, mp_size_t<2>>, V2<1, 2>);
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<0>, mp_size_t<3>>, V2<1, 2, 3>);
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<0>, mp_size_t<4>>, V2<1, 2, 3, 4>);
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<0>, mp_size_t<5>>, V2<1, 2, 3, 4, 5>);
+
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<1>, mp_size_t<1>>, V2<>);
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<1>, mp_size_t<2>>, V2<2>);
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<1>, mp_size_t<3>>, V2<2, 3>);
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<1>, mp_size_t<4>>, V2<2, 3, 4>);
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<1>, mp_size_t<5>>, V2<2, 3, 4, 5>);
+
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<2>, mp_size_t<2>>, V2<>);
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<2>, mp_size_t<3>>, V2<3>);
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<2>, mp_size_t<4>>, V2<3, 4>);
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<2>, mp_size_t<5>>, V2<3, 4, 5>);
+
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<3>, mp_size_t<3>>, V2<>);
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<3>, mp_size_t<4>>, V2<4>);
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<3>, mp_size_t<5>>, V2<4, 5>);
+
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<4>, mp_size_t<4>>, V2<>);
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<4>, mp_size_t<5>>, V2<5>);
+
+        BOOST_TEST_TRAIT_SAME(mp_slice<L2, mp_size_t<5>, mp_size_t<5>>, V2<>);
+    }
+
+    using boost::mp11::mp_iota_c;
+    using boost::mp11::mp_rename_v;
+
+    {
+        using L1 = mp_rename_v<mp_iota_c<71>, V1>;
+        using L2 = mp_rename_v<mp_iota_c<72>, V1>;
+
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 0, 72>, L2);
+        BOOST_TEST_TRAIT_SAME(mp_slice_c<L2, 0, 71>, L1);
+    }
+
+    return boost::report_errors();
+}
+
+#endif
diff --git a/test/mp_sliding_fold.cpp b/test/mp_sliding_fold.cpp
new file mode 100644
index 0000000..ba6ee2b
--- /dev/null
+++ b/test/mp_sliding_fold.cpp
@@ -0,0 +1,113 @@
+// Copyright 2023 Braden Ganetsky (braden.ganetsky@gmail.com)
+//
+// 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/mp11/algorithm.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/mp11/function.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+struct X4 {};
+struct X5 {};
+
+using boost::mp11::mp_plus;
+using boost::mp11::mp_int;
+
+#if !BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
+
+template<class... C> using average = mp_int<mp_plus<C...>::value / sizeof...(C)>;
+
+#else
+
+template<class... C> struct average_impl: mp_int<mp_plus<C...>::value / sizeof...(C)> {};
+template<class... C> using average = typename average_impl<C...>::type;
+
+#endif
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_list_c;
+    using boost::mp11::mp_size_t;
+    using boost::mp11::mp_sliding_fold;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<>, mp_size_t<1>, mp_list>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1>, mp_size_t<1>, mp_list>, mp_list<mp_list<X1>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2>, mp_size_t<1>, mp_list>, mp_list<mp_list<X1>, mp_list<X2>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3>, mp_size_t<1>, mp_list>, mp_list<mp_list<X1>, mp_list<X2>, mp_list<X3>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3, X4>, mp_size_t<1>, mp_list>, mp_list<mp_list<X1>, mp_list<X2>, mp_list<X3>, mp_list<X4>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3, X4, X5>, mp_size_t<1>, mp_list>, mp_list<mp_list<X1>, mp_list<X2>, mp_list<X3>, mp_list<X4>, mp_list<X5>>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<>, mp_size_t<2>, mp_list>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1>, mp_size_t<2>, mp_list>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2>, mp_size_t<2>, mp_list>, mp_list<mp_list<X1, X2>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3>, mp_size_t<2>, mp_list>, mp_list<mp_list<X1, X2>, mp_list<X2, X3>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3, X4>, mp_size_t<2>, mp_list>, mp_list<mp_list<X1, X2>, mp_list<X2, X3>, mp_list<X3, X4>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3, X4, X5>, mp_size_t<2>, mp_list>, mp_list<mp_list<X1, X2>, mp_list<X2, X3>, mp_list<X3, X4>, mp_list<X4, X5>>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<>, mp_size_t<3>, mp_list>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1>, mp_size_t<3>, mp_list>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2>, mp_size_t<3>, mp_list>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3>, mp_size_t<3>, mp_list>, mp_list<mp_list<X1, X2, X3>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3, X4>, mp_size_t<3>, mp_list>, mp_list<mp_list<X1, X2, X3>, mp_list<X2, X3, X4>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3, X4, X5>, mp_size_t<3>, mp_list>, mp_list<mp_list<X1, X2, X3>, mp_list<X2, X3, X4>, mp_list<X3, X4, X5>>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<>, mp_size_t<4>, mp_list>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1>, mp_size_t<4>, mp_list>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2>, mp_size_t<4>, mp_list>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3>, mp_size_t<4>, mp_list>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3, X4>, mp_size_t<4>, mp_list>, mp_list<mp_list<X1, X2, X3, X4>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3, X4, X5>, mp_size_t<4>, mp_list>, mp_list<mp_list<X1, X2, X3, X4>, mp_list<X2, X3, X4, X5>>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<>, mp_size_t<5>, mp_list>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1>, mp_size_t<5>, mp_list>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2>, mp_size_t<5>, mp_list>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3>, mp_size_t<5>, mp_list>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3, X4>, mp_size_t<5>, mp_list>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3, X4, X5>, mp_size_t<5>, mp_list>, mp_list<mp_list<X1, X2, X3, X4, X5>>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<>, mp_size_t<6>, mp_list>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1>, mp_size_t<6>, mp_list>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2>, mp_size_t<6>, mp_list>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3>, mp_size_t<6>, mp_list>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3, X4>, mp_size_t<6>, mp_list>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3, X4, X5>, mp_size_t<6>, mp_list>, mp_list<>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<>, mp_size_t<2>, std::pair>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1>, mp_size_t<2>, std::pair>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2>, mp_size_t<2>, std::pair>, mp_list<std::pair<X1, X2>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3>, mp_size_t<2>, std::pair>, mp_list<std::pair<X1, X2>, std::pair<X2, X3>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3, X4>, mp_size_t<2>, std::pair>, mp_list<std::pair<X1, X2>, std::pair<X2, X3>, std::pair<X3, X4>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list<X1, X2, X3, X4, X5>, mp_size_t<2>, std::pair>, mp_list<std::pair<X1, X2>, std::pair<X2, X3>, std::pair<X3, X4>, std::pair<X4, X5>>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<std::tuple<>, mp_size_t<2>, std::pair>, std::tuple<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<std::tuple<X1>, mp_size_t<2>, std::pair>, std::tuple<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<std::tuple<X1, X2>, mp_size_t<2>, std::pair>, std::tuple<std::pair<X1, X2>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<std::tuple<X1, X2, X3>, mp_size_t<2>, std::pair>, std::tuple<std::pair<X1, X2>, std::pair<X2, X3>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<std::tuple<X1, X2, X3, X4>, mp_size_t<2>, std::pair>, std::tuple<std::pair<X1, X2>, std::pair<X2, X3>, std::pair<X3, X4>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<std::tuple<X1, X2, X3, X4, X5>, mp_size_t<2>, std::pair>, std::tuple<std::pair<X1, X2>, std::pair<X2, X3>, std::pair<X3, X4>, std::pair<X4, X5>>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<1>, mp_plus>, mp_list_c<int, 1, 2, 3, 4, 5, 6>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<2>, mp_plus>, mp_list_c<int, 3, 5, 7, 9, 11>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<3>, mp_plus>, mp_list_c<int, 6, 9, 12, 15>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<4>, mp_plus>, mp_list_c<int, 10, 14, 18>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<5>, mp_plus>, mp_list_c<int, 15, 20>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<6>, mp_plus>, mp_list_c<int, 21>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<1>, average>, mp_list_c<int, 1, 2, 3, 4, 5, 6>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<2>, average>, mp_list_c<int, 1, 2, 3, 4, 5>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<3>, average>, mp_list_c<int, 2, 3, 4, 5>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<4>, average>, mp_list_c<int, 2, 3, 4>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<5>, average>, mp_list_c<int, 3, 4>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<6>, average>, mp_list_c<int, 3>>));
+
+    return boost::report_errors();
+}
diff --git a/test/mp_sliding_fold_q.cpp b/test/mp_sliding_fold_q.cpp
new file mode 100644
index 0000000..87794c9
--- /dev/null
+++ b/test/mp_sliding_fold_q.cpp
@@ -0,0 +1,121 @@
+// Copyright 2023 Braden Ganetsky (braden.ganetsky@gmail.com)
+//
+// 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/mp11/algorithm.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/mp11/function.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+struct X4 {};
+struct X5 {};
+
+using boost::mp11::mp_plus;
+using boost::mp11::mp_int;
+
+#if !BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
+
+struct average
+{
+    template<class... C> using fn = mp_int<mp_plus<C...>::value / sizeof...(C)>;
+};
+
+#else
+
+template<class... C> struct average_impl: mp_int<mp_plus<C...>::value / sizeof...(C)> {};
+
+struct average
+{
+    template<class... C> using fn = typename average_impl<C...>::type;
+};
+
+#endif
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_list_c;
+    using boost::mp11::mp_quote;
+    using boost::mp11::mp_size_t;
+    using boost::mp11::mp_sliding_fold_q;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<>, mp_size_t<1>, mp_quote<mp_list>>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1>, mp_size_t<1>, mp_quote<mp_list>>, mp_list<mp_list<X1>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2>, mp_size_t<1>, mp_quote<mp_list>>, mp_list<mp_list<X1>, mp_list<X2>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3>, mp_size_t<1>, mp_quote<mp_list>>, mp_list<mp_list<X1>, mp_list<X2>, mp_list<X3>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3, X4>, mp_size_t<1>, mp_quote<mp_list>>, mp_list<mp_list<X1>, mp_list<X2>, mp_list<X3>, mp_list<X4>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3, X4, X5>, mp_size_t<1>, mp_quote<mp_list>>, mp_list<mp_list<X1>, mp_list<X2>, mp_list<X3>, mp_list<X4>, mp_list<X5>>>));
+    
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<>, mp_size_t<2>, mp_quote<mp_list>>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1>, mp_size_t<2>, mp_quote<mp_list>>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2>, mp_size_t<2>, mp_quote<mp_list>>, mp_list<mp_list<X1, X2>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3>, mp_size_t<2>, mp_quote<mp_list>>, mp_list<mp_list<X1, X2>, mp_list<X2, X3>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3, X4>, mp_size_t<2>, mp_quote<mp_list>>, mp_list<mp_list<X1, X2>, mp_list<X2, X3>, mp_list<X3, X4>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3, X4, X5>, mp_size_t<2>, mp_quote<mp_list>>, mp_list<mp_list<X1, X2>, mp_list<X2, X3>, mp_list<X3, X4>, mp_list<X4, X5>>>));
+    
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<>, mp_size_t<3>, mp_quote<mp_list>>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1>, mp_size_t<3>, mp_quote<mp_list>>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2>, mp_size_t<3>, mp_quote<mp_list>>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3>, mp_size_t<3>, mp_quote<mp_list>>, mp_list<mp_list<X1, X2, X3>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3, X4>, mp_size_t<3>, mp_quote<mp_list>>, mp_list<mp_list<X1, X2, X3>, mp_list<X2, X3, X4>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3, X4, X5>, mp_size_t<3>, mp_quote<mp_list>>, mp_list<mp_list<X1, X2, X3>, mp_list<X2, X3, X4>, mp_list<X3, X4, X5>>>));
+    
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<>, mp_size_t<4>, mp_quote<mp_list>>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1>, mp_size_t<4>, mp_quote<mp_list>>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2>, mp_size_t<4>, mp_quote<mp_list>>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3>, mp_size_t<4>, mp_quote<mp_list>>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3, X4>, mp_size_t<4>, mp_quote<mp_list>>, mp_list<mp_list<X1, X2, X3, X4>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3, X4, X5>, mp_size_t<4>, mp_quote<mp_list>>, mp_list<mp_list<X1, X2, X3, X4>, mp_list<X2, X3, X4, X5>>>));
+    
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<>, mp_size_t<5>, mp_quote<mp_list>>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1>, mp_size_t<5>, mp_quote<mp_list>>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2>, mp_size_t<5>, mp_quote<mp_list>>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3>, mp_size_t<5>, mp_quote<mp_list>>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3, X4>, mp_size_t<5>, mp_quote<mp_list>>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3, X4, X5>, mp_size_t<5>, mp_quote<mp_list>>, mp_list<mp_list<X1, X2, X3, X4, X5>>>));
+    
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<>, mp_size_t<6>, mp_quote<mp_list>>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1>, mp_size_t<6>, mp_quote<mp_list>>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2>, mp_size_t<6>, mp_quote<mp_list>>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3>, mp_size_t<6>, mp_quote<mp_list>>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3, X4>, mp_size_t<6>, mp_quote<mp_list>>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3, X4, X5>, mp_size_t<6>, mp_quote<mp_list>>, mp_list<>>));
+    
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<>, mp_size_t<2>, mp_quote<std::pair>>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1>, mp_size_t<2>, mp_quote<std::pair>>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2>, mp_size_t<2>, mp_quote<std::pair>>, mp_list<std::pair<X1, X2>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3>, mp_size_t<2>, mp_quote<std::pair>>, mp_list<std::pair<X1, X2>, std::pair<X2, X3>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3, X4>, mp_size_t<2>, mp_quote<std::pair>>, mp_list<std::pair<X1, X2>, std::pair<X2, X3>, std::pair<X3, X4>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list<X1, X2, X3, X4, X5>, mp_size_t<2>, mp_quote<std::pair>>, mp_list<std::pair<X1, X2>, std::pair<X2, X3>, std::pair<X3, X4>, std::pair<X4, X5>>>));
+    
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<std::tuple<>, mp_size_t<2>, mp_quote<std::pair>>, std::tuple<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<std::tuple<X1>, mp_size_t<2>, mp_quote<std::pair>>, std::tuple<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<std::tuple<X1, X2>, mp_size_t<2>, mp_quote<std::pair>>, std::tuple<std::pair<X1, X2>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<std::tuple<X1, X2, X3>, mp_size_t<2>, mp_quote<std::pair>>, std::tuple<std::pair<X1, X2>, std::pair<X2, X3>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<std::tuple<X1, X2, X3, X4>, mp_size_t<2>, mp_quote<std::pair>>, std::tuple<std::pair<X1, X2>, std::pair<X2, X3>, std::pair<X3, X4>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<std::tuple<X1, X2, X3, X4, X5>, mp_size_t<2>, mp_quote<std::pair>>, std::tuple<std::pair<X1, X2>, std::pair<X2, X3>, std::pair<X3, X4>, std::pair<X4, X5>>>));
+    
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<1>, mp_quote<mp_plus>>, mp_list_c<int, 1, 2, 3, 4, 5, 6>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<2>, mp_quote<mp_plus>>, mp_list_c<int, 3, 5, 7, 9, 11>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<3>, mp_quote<mp_plus>>, mp_list_c<int, 6, 9, 12, 15>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<4>, mp_quote<mp_plus>>, mp_list_c<int, 10, 14, 18>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<5>, mp_quote<mp_plus>>, mp_list_c<int, 15, 20>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<6>, mp_quote<mp_plus>>, mp_list_c<int, 21>>));
+    
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<1>, average>, mp_list_c<int, 1, 2, 3, 4, 5, 6>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<2>, average>, mp_list_c<int, 1, 2, 3, 4, 5>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<3>, average>, mp_list_c<int, 2, 3, 4, 5>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<4>, average>, mp_list_c<int, 2, 3, 4>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<5>, average>, mp_list_c<int, 3, 4>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sliding_fold_q<mp_list_c<int, 1, 2, 3, 4, 5, 6>, mp_size_t<6>, average>, mp_list_c<int, 3>>));
+
+    return boost::report_errors();
+}
diff --git a/test/mp_transform_2.cpp b/test/mp_transform_2.cpp
new file mode 100644
index 0000000..dc6f305
--- /dev/null
+++ b/test/mp_transform_2.cpp
@@ -0,0 +1,45 @@
+// Copyright 2023 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/mp11/algorithm.hpp>
+#include <boost/mp11/function.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+
+#if !defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+#pragma message("Test skipped because BOOST_MP11_HAS_TEMPLATE_AUTO is not defined")
+int main() {}
+
+#else
+
+template<auto... A> struct V1 {};
+template<int... I> struct V2 {};
+
+int main()
+{
+    using boost::mp11::mp_transform;
+    using boost::mp11::mp_identity_t;
+    using boost::mp11::mp_plus;
+
+    using L1 = V1<true, -2, 3U, -4L>;
+    using L2 = V2<1, -2, 3, -4>;
+
+    BOOST_TEST_TRAIT_SAME(mp_transform<mp_identity_t, L1>, L1);
+
+    BOOST_TEST_TRAIT_SAME(mp_transform<mp_plus, L1>, V1<1, -2, 3U, -4L>);
+    BOOST_TEST_TRAIT_SAME(mp_transform<mp_plus, L1, L2>, V1<2, -4, 6U, -8L>);
+    BOOST_TEST_TRAIT_SAME(mp_transform<mp_plus, L1, L2, L2>, V1<3, -6, 9U, -12L>);
+
+    BOOST_TEST_TRAIT_SAME(mp_transform<mp_identity_t, L2>, L2);
+
+    BOOST_TEST_TRAIT_SAME(mp_transform<mp_plus, L2>, V2<1, -2, 3, -4>);
+    BOOST_TEST_TRAIT_SAME(mp_transform<mp_plus, L2, L1>, V2<2, -4, 6, -8>);
+    BOOST_TEST_TRAIT_SAME(mp_transform<mp_plus, L2, L1, L1>, V2<3, -6, 9, -12>);
+
+    //
+
+    return boost::report_errors();
+}
+
+#endif
diff --git a/test/mp_transform_q_2.cpp b/test/mp_transform_q_2.cpp
new file mode 100644
index 0000000..bacf24d
--- /dev/null
+++ b/test/mp_transform_q_2.cpp
@@ -0,0 +1,67 @@
+// Copyright 2023 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/mp11/algorithm.hpp>
+#include <boost/mp11/bind.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <utility>
+
+struct X1 {};
+struct X2 {};
+
+struct Test
+{
+    void operator()( boost::mp11::mp_size_t<0> )
+    {
+    }
+
+    template<class N> void operator()( N )
+    {
+        using boost::mp11::mp_repeat;
+        using boost::mp11::mp_list;
+        using boost::mp11::mp_apply_q;
+        using boost::mp11::mp_bind_front;
+        using boost::mp11::mp_transform_q;
+        using boost::mp11::mp_quote;
+
+        using L1 = mp_repeat< mp_list<std::pair<X1, X2>>, N >; // mp_list<pair<X1, X2>, pair<X1, X2>, ...>
+        using L2 = mp_apply_q< mp_bind_front<mp_transform_q, mp_quote<mp_list>>, L1>; // pair<mp_list<X1, X1, ...>, mp_list<X2, X2, ...>>
+
+        using R1 = mp_repeat<mp_list<X1>, N>; // mp_list<X1, X1, ...>
+        using R2 = mp_repeat<mp_list<X2>, N>; // mp_list<X2, X2, ...>
+
+        BOOST_TEST_TRAIT_SAME(L2, std::pair<R1, R2>);
+    }
+};
+
+int main()
+{
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
+
+    using boost::mp11::mp_size_t;
+
+    Test()( mp_size_t<1>() );
+    Test()( mp_size_t<2>() );
+    Test()( mp_size_t<3>() );
+    Test()( mp_size_t<4>() );
+    Test()( mp_size_t<5>() );
+    Test()( mp_size_t<6>() );
+    Test()( mp_size_t<7>() );
+    Test()( mp_size_t<9>() );
+    Test()( mp_size_t<10>() );
+    Test()( mp_size_t<11>() );
+
+#else
+
+    using boost::mp11::mp_for_each;
+    using boost::mp11::mp_iota_c;
+
+    mp_for_each< mp_iota_c<32> >( Test() );
+
+#endif
+
+    return boost::report_errors();
+}