From 247ffe8afe9c7fb119cb095e3d57a84c8b3d58d4 Mon Sep 17 00:00:00 2001
From: Braden Ganetsky <braden.ganetsky@gmail.com>
Date: Sun, 30 Jul 2023 12:12:10 -0500
Subject: [PATCH 01/21] Add mp_sliding_fold

---
 include/boost/mp11/algorithm.hpp | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/include/boost/mp11/algorithm.hpp b/include/boost/mp11/algorithm.hpp
index be377f5..b58ce12 100644
--- a/include/boost/mp11/algorithm.hpp
+++ b/include/boost/mp11/algorithm.hpp
@@ -1261,6 +1261,27 @@ 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 Q, std::size_t... Ints> struct mp_sliding_fold_impl<mp_true, L, Q, index_sequence<Ints...>>
+{
+    using type = mp_transform_q<Q, mp_drop_c<mp_take_c<L, mp_size<L>::value - (sizeof...(Ints) - Ints - 1)>, Ints>...>;
+};
+
+template<class L, class Q, class S> struct mp_sliding_fold_impl<mp_false, L, Q, S>
+{
+    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, Q, make_index_sequence<size_t{ N::value }>>::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
 {

From 70ff01c85f20b1af5e2fee6c49ada1e30c1f36a9 Mon Sep 17 00:00:00 2001
From: Braden Ganetsky <braden.ganetsky@gmail.com>
Date: Sun, 30 Jul 2023 12:48:11 -0500
Subject: [PATCH 02/21] Add mp_sliding_fold to the adoc file

---
 doc/mp11/algorithm.adoc | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/doc/mp11/algorithm.adoc b/doc/mp11/algorithm.adoc
index 95b9d73..a3b4553 100644
--- a/doc/mp11/algorithm.adoc
+++ b/doc/mp11/algorithm.adoc
@@ -846,6 +846,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>

From d16fb0201cac235821972cd16639aeade5487b3f Mon Sep 17 00:00:00 2001
From: Braden Ganetsky <braden.ganetsky@gmail.com>
Date: Sun, 30 Jul 2023 22:42:05 -0500
Subject: [PATCH 03/21] Add mp_sliding_fold tests

---
 test/Jamfile               |   2 +
 test/mp_sliding_fold.cpp   | 100 +++++++++++++++++++++++++++++++++++
 test/mp_sliding_fold_q.cpp | 104 +++++++++++++++++++++++++++++++++++++
 3 files changed, 206 insertions(+)
 create mode 100644 test/mp_sliding_fold.cpp
 create mode 100644 test/mp_sliding_fold_q.cpp

diff --git a/test/Jamfile b/test/Jamfile
index 335c812..510da30 100644
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -158,6 +158,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/mp_sliding_fold.cpp b/test/mp_sliding_fold.cpp
new file mode 100644
index 0000000..5eacc35
--- /dev/null
+++ b/test/mp_sliding_fold.cpp
@@ -0,0 +1,100 @@
+// 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.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+struct X4 {};
+struct X5 {};
+
+template<class... C> using average = boost::mp11::mp_int<boost::mp11::mp_plus<C...>::value / sizeof...(C)>;
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_list_c;
+    using boost::mp11::mp_plus;
+    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..ac68f09
--- /dev/null
+++ b/test/mp_sliding_fold_q.cpp
@@ -0,0 +1,104 @@
+// 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.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+struct X4 {};
+struct X5 {};
+
+struct average
+{
+    template<class... C> using fn = boost::mp11::mp_int<boost::mp11::mp_plus<C...>::value / sizeof...(C)>;
+};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_list_c;
+    using boost::mp11::mp_plus;
+    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();
+}

From f653a83ca9f30adc5c78dce045e5ecdfb5c2b7dc Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Sun, 26 Nov 2023 19:08:19 +0200
Subject: [PATCH 04/21] Update ci.yml

---
 .github/workflows/ci.yml | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index a0bd86d..6e0b6eb 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -112,17 +112,20 @@ jobs:
           - toolset: clang
             compiler: clang++-13
             cxxstd: "03,11,14,17,20,2b"
-            os: ubuntu-22.04
+            os: ubuntu-latest
+            container: ubuntu:22.04
             install: clang-13
           - toolset: clang
             compiler: clang++-14
             cxxstd: "03,11,14,17,20,2b"
-            os: ubuntu-22.04
+            os: ubuntu-latest
+            container: ubuntu:22.04
             install: clang-14
           - toolset: clang
             compiler: clang++-15
             cxxstd: "03,11,14,17,20,2b"
-            os: ubuntu-22.04
+            os: ubuntu-latest
+            container: ubuntu:22.04
             install: clang-15
           - toolset: clang
             compiler: clang++-16
@@ -130,6 +133,12 @@ jobs:
             os: ubuntu-latest
             container: ubuntu:23.04
             install: clang-16
+          - toolset: clang
+            compiler: clang++-17
+            cxxstd: "03,11,14,17,20,2b"
+            os: ubuntu-latest
+            container: ubuntu:23.10
+            install: clang-17
           - toolset: clang
             cxxstd: "03,11,14,17,2a"
             os: macos-11

From 0715df5ca8ac0303504998ccbb04d067e387e529 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Mon, 27 Nov 2023 01:46:58 +0200
Subject: [PATCH 05/21] Reformulate mp_sliding_fold to pass msvc-14.0

---
 include/boost/mp11/algorithm.hpp | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

diff --git a/include/boost/mp11/algorithm.hpp b/include/boost/mp11/algorithm.hpp
index b58ce12..a469f89 100644
--- a/include/boost/mp11/algorithm.hpp
+++ b/include/boost/mp11/algorithm.hpp
@@ -1265,21 +1265,30 @@ template<class L, template<class...> class F> using mp_pairwise_fold = mp_pairwi
 namespace detail
 {
 
+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 >;
+
 template<class C, class L, class Q, class S> struct mp_sliding_fold_impl;
 
-template<class L, class Q, std::size_t... Ints> struct mp_sliding_fold_impl<mp_true, L, Q, index_sequence<Ints...>>
+template<class L, class N, class Q> struct mp_sliding_fold_impl<mp_true, L, N, Q>
 {
-    using type = mp_transform_q<Q, mp_drop_c<mp_take_c<L, mp_size<L>::value - (sizeof...(Ints) - Ints - 1)>, Ints>...>;
+    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 Q, class S> struct mp_sliding_fold_impl<mp_false, L, Q, S>
+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, Q, make_index_sequence<size_t{ N::value }>>::type;
+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>

From 82a1cb6f36a6afc8397e46537e6b8104b3a6b197 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Mon, 27 Nov 2023 02:05:19 +0200
Subject: [PATCH 06/21] Work around msvc-12.0 failures in mp_sliding_fold tests

---
 test/mp_sliding_fold.cpp   | 21 +++++++++++++++++----
 test/mp_sliding_fold_q.cpp | 23 ++++++++++++++++++++---
 2 files changed, 37 insertions(+), 7 deletions(-)

diff --git a/test/mp_sliding_fold.cpp b/test/mp_sliding_fold.cpp
index 5eacc35..ba6ee2b 100644
--- a/test/mp_sliding_fold.cpp
+++ b/test/mp_sliding_fold.cpp
@@ -5,7 +5,9 @@
 // See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt
 
-#include <boost/mp11.hpp>
+#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>
@@ -16,13 +18,24 @@ struct X3 {};
 struct X4 {};
 struct X5 {};
 
-template<class... C> using average = boost::mp11::mp_int<boost::mp11::mp_plus<C...>::value / sizeof...(C)>;
+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_plus;
     using boost::mp11::mp_size_t;
     using boost::mp11::mp_sliding_fold;
 
@@ -67,7 +80,7 @@ int main()
     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>>>));
diff --git a/test/mp_sliding_fold_q.cpp b/test/mp_sliding_fold_q.cpp
index ac68f09..87794c9 100644
--- a/test/mp_sliding_fold_q.cpp
+++ b/test/mp_sliding_fold_q.cpp
@@ -5,7 +5,9 @@
 // See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt
 
-#include <boost/mp11.hpp>
+#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>
@@ -16,16 +18,31 @@ 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 = boost::mp11::mp_int<boost::mp11::mp_plus<C...>::value / sizeof...(C)>;
+    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_plus;
     using boost::mp11::mp_quote;
     using boost::mp11::mp_size_t;
     using boost::mp11::mp_sliding_fold_q;

From 0c491bcd77ebd40a78ef97aba9f4c129731eaaf1 Mon Sep 17 00:00:00 2001
From: Braden Ganetsky <braden.ganetsky@gmail.com>
Date: Mon, 27 Nov 2023 19:07:38 -0600
Subject: [PATCH 07/21] Move mp_slice_c and mp_slice into the public API

---
 include/boost/mp11/algorithm.hpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/include/boost/mp11/algorithm.hpp b/include/boost/mp11/algorithm.hpp
index a469f89..b40dfd9 100644
--- a/include/boost/mp11/algorithm.hpp
+++ b/include/boost/mp11/algorithm.hpp
@@ -473,6 +473,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>;
 
@@ -1265,9 +1269,6 @@ template<class L, template<class...> class F> using mp_pairwise_fold = mp_pairwi
 namespace detail
 {
 
-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 >;
-
 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>

From 56a9b7db1c47a87a4e69e67defa7e3c05c553c14 Mon Sep 17 00:00:00 2001
From: Braden Ganetsky <braden.ganetsky@gmail.com>
Date: Mon, 27 Nov 2023 19:08:10 -0600
Subject: [PATCH 08/21] Add mp_slice_c and mp_slice to the adoc file

---
 doc/mp11/algorithm.adoc | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/doc/mp11/algorithm.adoc b/doc/mp11/algorithm.adoc
index a3b4553..2e5e126 100644
--- a/doc/mp11/algorithm.adoc
+++ b/doc/mp11/algorithm.adoc
@@ -414,6 +414,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>;

From b052fa1bc5ca34d7116aa0807f7b3ddb5623e3c0 Mon Sep 17 00:00:00 2001
From: Braden Ganetsky <braden.ganetsky@gmail.com>
Date: Mon, 27 Nov 2023 19:08:40 -0600
Subject: [PATCH 09/21] Add mp_slice_c and mp_slice tests

---
 test/Jamfile      |   1 +
 test/mp_slice.cpp | 118 ++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 119 insertions(+)
 create mode 100644 test/mp_slice.cpp

diff --git a/test/Jamfile b/test/Jamfile
index 510da30..445f10c 100644
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -99,6 +99,7 @@ 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_replace.cpp ;
 run mp_replace_if.cpp ;
 run mp_replace_if_q.cpp ;
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();
+}

From eb3ea17c81e29dfd15d56c26393bcf3a687d0980 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Sun, 17 Dec 2023 19:11:05 +0200
Subject: [PATCH 10/21] Add value list test for mp_slice

---
 test/Jamfile        |   1 +
 test/mp_slice_2.cpp | 168 ++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 169 insertions(+)
 create mode 100644 test/mp_slice_2.cpp

diff --git a/test/Jamfile b/test/Jamfile
index 445f10c..5d5c94c 100644
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -100,6 +100,7 @@ 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 ;
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

From 5dfa20ca6dab9c04dd1db0b471b9e7a494dbc1d6 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Sun, 17 Dec 2023 20:01:09 +0200
Subject: [PATCH 11/21] Update revision history

---
 doc/mp11/changelog.adoc | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/doc/mp11/changelog.adoc b/doc/mp11/changelog.adoc
index f3fb9b4..8af79f8 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,11 @@ 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)
+
 ## Changes in 1.83.0
 
 * Added an offset/from parameter to `mp_from_sequence`, `mp_iota`, `mp_iota_c`.

From ee5f1d620fd7fc6e31d7f8eac6db6aaf188f44c9 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Sun, 17 Dec 2023 20:37:56 +0200
Subject: [PATCH 12/21] Add value list support to mp_min_element,
 mp_max_element. Fixes #87.

---
 include/boost/mp11/detail/mp_fold.hpp |  4 +-
 test/Jamfile                          |  4 ++
 test/mp_max_element_2.cpp             | 58 +++++++++++++++++++++++++
 test/mp_max_element_q_2.cpp           | 61 +++++++++++++++++++++++++++
 test/mp_min_element_2.cpp             | 58 +++++++++++++++++++++++++
 test/mp_min_element_q_2.cpp           | 61 +++++++++++++++++++++++++++
 6 files changed, 245 insertions(+), 1 deletion(-)
 create mode 100644 test/mp_max_element_2.cpp
 create mode 100644 test/mp_max_element_q_2.cpp
 create mode 100644 test/mp_min_element_2.cpp
 create mode 100644 test/mp_min_element_q_2.cpp

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/test/Jamfile b/test/Jamfile
index 5d5c94c..538e66a 100644
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -143,9 +143,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 ;
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

From 2e7328ea26ff5cd6e5ec77a3c4fcdd57c71a0fe7 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Sun, 17 Dec 2023 20:41:43 +0200
Subject: [PATCH 13/21] Update documentation

---
 doc/mp11/algorithm.adoc | 4 ++++
 doc/mp11/changelog.adoc | 1 +
 2 files changed, 5 insertions(+)

diff --git a/doc/mp11/algorithm.adoc b/doc/mp11/algorithm.adoc
index 2e5e126..7b9d852 100644
--- a/doc/mp11/algorithm.adoc
+++ b/doc/mp11/algorithm.adoc
@@ -721,6 +721,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>;
@@ -735,6 +737,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>;
diff --git a/doc/mp11/changelog.adoc b/doc/mp11/changelog.adoc
index 8af79f8..8d83807 100644
--- a/doc/mp11/changelog.adoc
+++ b/doc/mp11/changelog.adoc
@@ -14,6 +14,7 @@ http://www.boost.org/LICENSE_1_0.txt
 
 * 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`.
 
 ## Changes in 1.83.0
 

From 9e1a5d014fcbc9ebeff019b5b16d60f3c943c172 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Mon, 18 Dec 2023 01:52:29 +0200
Subject: [PATCH 14/21] Add mp_transform_q test for up to 32 lists

---
 test/Jamfile              |  1 +
 test/mp_transform_q_2.cpp | 48 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 49 insertions(+)
 create mode 100644 test/mp_transform_q_2.cpp

diff --git a/test/Jamfile b/test/Jamfile
index 538e66a..4522892 100644
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -74,6 +74,7 @@ run mp_is_value_list.cpp ;
 # algorithm
 run mp_transform.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 ;
diff --git a/test/mp_transform_q_2.cpp b/test/mp_transform_q_2.cpp
new file mode 100644
index 0000000..be9e851
--- /dev/null
+++ b/test/mp_transform_q_2.cpp
@@ -0,0 +1,48 @@
+// 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()
+{
+    using boost::mp11::mp_for_each;
+    using boost::mp11::mp_iota_c;
+
+    mp_for_each< mp_iota_c<32> >( Test() );
+
+    return boost::report_errors();
+}

From f8fb53c7751485e93f1cd7a189064f3a36ff3c46 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Mon, 18 Dec 2023 02:37:52 +0200
Subject: [PATCH 15/21] Work around MSVC failures

---
 test/mp_transform_q_2.cpp | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/test/mp_transform_q_2.cpp b/test/mp_transform_q_2.cpp
index be9e851..bacf24d 100644
--- a/test/mp_transform_q_2.cpp
+++ b/test/mp_transform_q_2.cpp
@@ -39,10 +39,29 @@ struct Test
 
 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();
 }

From 4db3374eeddbf21c1a1904f8e85b96515e5e7f22 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Mon, 18 Dec 2023 05:53:20 +0200
Subject: [PATCH 16/21] Add value list support to mp_transform (for up to three
 lists). Closes #86.

---
 include/boost/mp11/algorithm.hpp | 19 ++++++++++++++
 test/Jamfile                     |  1 +
 test/mp_transform_2.cpp          | 45 ++++++++++++++++++++++++++++++++
 3 files changed, 65 insertions(+)
 create mode 100644 test/mp_transform_2.cpp

diff --git a/include/boost/mp11/algorithm.hpp b/include/boost/mp11/algorithm.hpp
index b40dfd9..61c8669 100644
--- a/include/boost/mp11/algorithm.hpp
+++ b/include/boost/mp11/algorithm.hpp
@@ -84,6 +84,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>...>;
diff --git a/test/Jamfile b/test/Jamfile
index 4522892..1d8252d 100644
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -73,6 +73,7 @@ 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 ;
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

From 6ffe4c3d750daef2a6873fb9578acae2b7bbbb71 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Mon, 18 Dec 2023 18:29:53 +0200
Subject: [PATCH 17/21] Update documentation

---
 doc/mp11/algorithm.adoc | 4 ++++
 doc/mp11/changelog.adoc | 1 +
 2 files changed, 5 insertions(+)

diff --git a/doc/mp11/algorithm.adoc b/doc/mp11/algorithm.adoc
index 7b9d852..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 =
diff --git a/doc/mp11/changelog.adoc b/doc/mp11/changelog.adoc
index 8d83807..59f3d17 100644
--- a/doc/mp11/changelog.adoc
+++ b/doc/mp11/changelog.adoc
@@ -15,6 +15,7 @@ http://www.boost.org/LICENSE_1_0.txt
 * 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
 

From 679834bfdcfac8fb90a60381cd906688f3769858 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Tue, 19 Dec 2023 13:20:05 +0200
Subject: [PATCH 18/21] Update version

---
 include/boost/mp11/version.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/boost/mp11/version.hpp b/include/boost/mp11/version.hpp
index ab5e09c..aba1fb1 100644
--- a/include/boost/mp11/version.hpp
+++ b/include/boost/mp11/version.hpp
@@ -11,6 +11,6 @@
 // Same format as BOOST_VERSION:
 //   major * 100000 + minor * 100 + patch
 
-#define BOOST_MP11_VERSION 108400
+#define BOOST_MP11_VERSION 108500
 
 #endif // #ifndef BOOST_MP11_VERSION_HPP_INCLUDED

From e584d92a9fec2a2f37839953cce4e36de277a32d Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Tue, 19 Dec 2023 16:23:47 +0200
Subject: [PATCH 19/21] Update version

---
 CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 85289b2..f97464c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -4,7 +4,7 @@
 
 cmake_minimum_required(VERSION 3.5...3.16)
 
-project(boost_mp11 VERSION 1.84.0 LANGUAGES CXX)
+project(boost_mp11 VERSION 1.85.0 LANGUAGES CXX)
 
 add_library(boost_mp11 INTERFACE)
 add_library(Boost::mp11 ALIAS boost_mp11)

From ed049f2741a2b1b0643a7cdc537a746da7d73335 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Thu, 21 Dec 2023 20:35:22 +0200
Subject: [PATCH 20/21] Add a test that includes <complex.h> before mp11.hpp.
 Refs #88.

---
 test/Jamfile       |  1 +
 test/complex_h.cpp | 12 ++++++++++++
 2 files changed, 13 insertions(+)
 create mode 100644 test/complex_h.cpp

diff --git a/test/Jamfile b/test/Jamfile
index 1d8252d..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 ;
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()
+{
+}

From 20fff14a90da21579b855f2612355cf8f0fbd751 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Thu, 21 Dec 2023 21:55:24 +0200
Subject: [PATCH 21/21] Use push_macro/pop_macro to guard against the macro I
 from <complex.h>. Fixes #88.

---
 include/boost/mp11/algorithm.hpp        | 9 +++++++++
 include/boost/mp11/bind.hpp             | 9 +++++++++
 include/boost/mp11/integer_sequence.hpp | 9 +++++++++
 include/boost/mp11/integral.hpp         | 9 +++++++++
 include/boost/mp11/list.hpp             | 9 +++++++++
 5 files changed, 45 insertions(+)

diff --git a/include/boost/mp11/algorithm.hpp b/include/boost/mp11/algorithm.hpp
index 61c8669..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
@@ -1374,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/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