@@ -434,7 +440,7 @@
just a matter of applying it over the possible combinations of the variant
values:
-using R = mp_product<Qret<F>::template fn, std::remove_reference_t<V>...>;
+using R = mp_product_q<Qret<F>, std::remove_reference_t<V>...>;
Why does this work? mp_product<F,
@@ -442,6 +448,9 @@
where Ui traverse all possible
combinations of list values. Since in our case all Li
are std::variant, the result will also be std::variant.
+ (mp_product_q is the same
+ as mp_product, but for quoted
+ metafunctions such as our Qret<F>.)
One more step remains. Suppose that, as above, we're passing two variants
@@ -1121,6 +1130,17 @@
+
template<class Q, class... L> using mp_product_q = mp_product<Q::template fn, L...>;
+
+
+ As mp_product, but takes
+ a quoted metafunction.
+
+
+
+
template<class L, std::size_t N> using mp_drop_c = ;
@@ -1222,6 +1242,53 @@
+
template<class L, std::size_t I, class... T> using mp_insert_c = mp_append<mp_take_c<L, I>, mp_push_front<mp_drop_c<L, I>, T...>>;
+
+
+ Inserts the elements T... into the list L
+ at position I (a zero-based
+ index).
+
+
+
+
+
template<class L, class I, class... T> using mp_insert = mp_append<mp_take<L, I>, mp_push_front<mp_drop<L, I>, T...>>;
+
+
+ Same as mp_insert_c, but
+ with a type argument I.
+
+
+
+
template<class L, std::size_t I, std::size_t J> using mp_erase = mp_append<mp_take_c<L, I>, mp_drop_c<L, J>>;
+
+
+ Removes from the list L
+ the elements with indices from I
+ (inclusive) to J (exclusive).
+
+
+
+
template<class L, class I, class J> using mp_erase = mp_append<mp_take<L, I>, mp_drop<L, J>>;
+
+
+ Same as mp_erase_c, but
+ with a type arguments I
+ and J.
+
+
+
template<class L, class V, class W> using mp_replace = ;
@@ -1342,8 +1409,11 @@
template<class L, class V> using mp_find = ;
- mp_find<L, V> is an alias for mp_size_t<I>, where I
- is the zero-based index of the first occurence of V
+ mp_find<L, V> returns the index at which the type
+ V is located in the list
+ L. It's an alias for mp_size_t<I>,
+ where I is the zero-based
+ index of the first occurence of V
in L. If L does not contain V,
mp_find<L, V> is mp_size<L>.
@@ -1453,6 +1523,21 @@
one element of L, mp_false otherwise. When L is empty, the result is mp_false.
+
+
template<class L, class F> constexpr F mp_for_each(F&& f);
+
+
+ mp_for_each<L>(f) calls
+ f with mp_identity<T>() for each element T
+ of the list L, in order.
+
+
+ Returns std::forward<F>(f).
+
+
-Last revised: May 12, 2017 at 16:48:16 GMT |
+Last revised: May 13, 2017 at 18:21:04 GMT |
|
diff --git a/doc/mp11/algorithm.qbk b/doc/mp11/algorithm.qbk
index b325077..8a555db 100644
--- a/doc/mp11/algorithm.qbk
+++ b/doc/mp11/algorithm.qbk
@@ -83,6 +83,12 @@ the Cartesian product of the lists, as if the elements `Ui` are formed by `n` ne
It returns a list of type `L1` containing the results of the application of `F`.
[endsect]
+[section `mp_product_q
`]
+ template using mp_product_q = mp_product;
+
+As `mp_product`, but takes a quoted metafunction.
+[endsect]
+
[section `mp_drop_c`]
template using mp_drop_c = /*...*/;
@@ -133,6 +139,30 @@ Same as `mp_at_c`, but with a type argument `I`. `I::value` must be a nonnegativ
Same as `mp_take_c`, but with a type argument `N`. `N::value` must be a nonnegative number.
[endsect]
+[section `mp_insert_c`]
+ template using mp_insert_c = mp_append, mp_push_front, T...>>;
+
+Inserts the elements `T...` into the list `L` at position `I` (a zero-based index).
+[endsect]
+
+[section `mp_insert`]
+ template using mp_insert = mp_append, mp_push_front, T...>>;
+
+Same as `mp_insert_c`, but with a type argument `I`.
+[endsect]
+
+[section `mp_erase_c`]
+ template using mp_erase = mp_append, mp_drop_c>;
+
+Removes from the list `L` the elements with indices from `I` (inclusive) to `J` (exclusive).
+[endsect]
+
+[section `mp_erase`]
+ template using mp_erase = mp_append, mp_drop>;
+
+Same as `mp_erase_c`, but with a type arguments `I` and `J`.
+[endsect]
+
[section `mp_replace`]
template using mp_replace = /*...*/;
@@ -191,8 +221,9 @@ for the elements of `L` and `mp_false` for the elements of `L`. Re
[section `mp_find`]
template using mp_find = /*...*/;
-`mp_find` is an alias for `mp_size_t`, where `I` is the zero-based index of the first occurence of `V` in `L`. If
-`L` does not contain `V`, `mp_find` is `mp_size`.
+`mp_find` returns the index at which the type `V` is located in the list `L`. It's an alias for `mp_size_t`,
+where `I` is the zero-based index of the first occurence of `V` in `L`. If `L` does not contain `V`, `mp_find`
+is `mp_size`.
[endsect]
[section `mp_find_if`]
@@ -244,4 +275,12 @@ for the elements of `L` and `mp_false` for the elements of `L`. Re
`mp_any_of` is `mp_true` when `P` holds for at least one element of `L`, `mp_false` otherwise. When `L` is empty, the result is `mp_false`.
[endsect]
+[section `mp_for_each(f)`]
+ template constexpr F mp_for_each(F&& f);
+
+`mp_for_each(f)` calls `f` with `mp_identity()` for each element `T` of the list `L`, in order.
+
+Returns `std::forward(f)`.
+[endsect]
+
[endsect:algorithm]
diff --git a/doc/mp11/examples.qbk b/doc/mp11/examples.qbk
index 041c589..9e5a7de 100644
--- a/doc/mp11/examples.qbk
+++ b/doc/mp11/examples.qbk
@@ -115,10 +115,11 @@ We'll first define a helper quoted metafunction `Qret` that returns the resul
With `Qret` in hand, a `variant` of the possible return types is just a matter of applying it over the possible combinations of the variant values:
- using R = mp_product::template fn, std::remove_reference_t...>;
+ using R = mp_product_q, std::remove_reference_t...>;
Why does this work? `mp_product, L2, ..., Ln>` returns `L1, ...>`, where `Ui` traverse all
-possible combinations of list values. Since in our case all `Li` are `std::variant`, the result will also be `std::variant`.
+possible combinations of list values. Since in our case all `Li` are `std::variant`, the result will also be `std::variant`. (`mp_product_q` is
+the same as `mp_product`, but for quoted metafunctions such as our `Qret`.)
One more step remains. Suppose that, as above, we're passing two variants of type `std::variant` and `F` is
`[]( auto const& x, auto const& y ){ return x + y; }`. This will generate `R` of length 9, one per each combination, but many of those
diff --git a/include/boost/mp11/algorithm.hpp b/include/boost/mp11/algorithm.hpp
index ba7eedf..298c25a 100644
--- a/include/boost/mp11/algorithm.hpp
+++ b/include/boost/mp11/algorithm.hpp
@@ -20,6 +20,7 @@
#include
#include
#include
+#include
namespace boost
{
@@ -208,6 +209,7 @@ template class F, class L1, class... L> struct mp_product_imp
} // namespace detail
template class F, class... L> using mp_product = typename detail::mp_product_impl::type;
+template using mp_product_q = typename detail::mp_product_impl::type;
// mp_drop(_c)
namespace detail
@@ -823,6 +825,44 @@ template struct mp_replace_at_impl
template using mp_replace_at = typename detail::mp_replace_at_impl::type;
template using mp_replace_at_c = typename detail::mp_replace_at_impl, W>::type;
+//mp_for_each(f)
+namespace detail
+{
+
+template BOOST_CONSTEXPR F mp_for_each_impl( mp_list, F && f )
+{
+ using A = int[sizeof...(T)];
+ return (void)A{ ((void)f(mp_identity()), 0)... }, std::forward(f);
+}
+
+#if BOOST_WORKAROUND( BOOST_MSVC, <= 1800 )
+
+template BOOST_CONSTEXPR F mp_for_each_impl( mp_list<>, F && f )
+{
+ return std::forward(f);
+}
+
+#endif
+
+} // namespace detail
+
+template BOOST_CONSTEXPR F mp_for_each( F && f )
+{
+ return detail::mp_for_each_impl( mp_rename(), std::forward(f) );
+}
+
+// mp_insert
+template using mp_insert = mp_append, mp_push_front, T...>>;
+
+// mp_insert_c
+template using mp_insert_c = mp_append, mp_push_front, T...>>;
+
+// mp_erase
+template using mp_erase = mp_append, mp_drop>;
+
+// mp_erase_c
+template using mp_erase_c = mp_append, mp_drop_c>;
+
} // namespace mp11
} // namespace boost
diff --git a/include/boost/tuple_for_each.hpp b/include/boost/tuple_for_each.hpp
index 2d2d135..8e3d766 100644
--- a/include/boost/tuple_for_each.hpp
+++ b/include/boost/tuple_for_each.hpp
@@ -3,6 +3,7 @@
#include
#include
+#include
#include
#include
#include
@@ -20,6 +21,15 @@ template BOOST_CONSTEXPR F tuple_for_each_i
return (void)A{ ((void)f(std::get(std::forward(tp))), 0)... }, std::forward(f);
}
+#if BOOST_WORKAROUND( BOOST_MSVC, <= 1800 )
+
+template BOOST_CONSTEXPR F tuple_for_each_impl( Tp && tp, boost::integer_sequence, F && f )
+{
+ return std::forward(f);
+}
+
+#endif
+
} // namespace detail
template BOOST_CONSTEXPR F tuple_for_each( Tp && tp, F && f )
diff --git a/test/Jamfile.v2 b/test/Jamfile.v2
index c627c6b..da5c569 100644
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@@ -64,6 +64,9 @@ run mp_any_of.cpp : : : $(REQ) ;
run mp_none_of.cpp : : : $(REQ) ;
run mp_replace_at.cpp : : : $(REQ) ;
run mp_replace_at_c.cpp : : : $(REQ) ;
+run mp_for_each.cpp : : : $(REQ) ;
+run mp_insert.cpp : : : $(REQ) ;
+run mp_erase.cpp : : : $(REQ) ;
# integral
run integral.cpp : : : $(REQ) ;
diff --git a/test/mp_erase.cpp b/test/mp_erase.cpp
new file mode 100644
index 0000000..10e9638
--- /dev/null
+++ b/test/mp_erase.cpp
@@ -0,0 +1,171 @@
+
+// Copyright 2015, 2017 Peter Dimov.
+//
+// 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
+#include
+#include
+#include
+#include
+#include
+#include
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+struct X4 {};
+struct X5 {};
+
+int main()
+{
+ using boost::mp11::mp_list;
+ using boost::mp11::mp_erase;
+ using boost::mp11::mp_erase_c;
+ using boost::mp11::mp_size_t;
+
+ using _0 = mp_size_t<0>;
+ using _1 = mp_size_t<1>;
+ using _2 = mp_size_t<2>;
+ using _3 = mp_size_t<3>;
+ using _4 = mp_size_t<4>;
+ using _5 = mp_size_t<5>;
+
+ {
+ using L1 = mp_list<>;
+
+ BOOST_TEST_TRAIT_TRUE((std::is_same, L1>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, L1>));
+
+ using L2 = mp_list;
+
+ BOOST_TEST_TRAIT_TRUE((std::is_same, L2>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, L2>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, L2>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, L2>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, L2>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, L2>));
+
+ BOOST_TEST_TRAIT_TRUE((std::is_same, L2>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, L2>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, L2>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, L2>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, L2>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, L2>));
+
+ BOOST_TEST_TRAIT_TRUE((std::is_same, mp_list>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, mp_list>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, mp_list>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, mp_list>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, mp_list>));
+
+ BOOST_TEST_TRAIT_TRUE((std::is_same, mp_list>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, mp_list>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, mp_list>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, mp_list>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, mp_list>));
+
+ BOOST_TEST_TRAIT_TRUE((std::is_same, mp_list>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, mp_list>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, mp_list>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, mp_list>));
+
+ BOOST_TEST_TRAIT_TRUE((std::is_same, mp_list>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, mp_list>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, mp_list>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, mp_list>));
+
+ BOOST_TEST_TRAIT_TRUE((std::is_same, mp_list>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, mp_list>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, mp_list>));
+
+ BOOST_TEST_TRAIT_TRUE((std::is_same, mp_list>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, mp_list>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, mp_list>));
+
+ BOOST_TEST_TRAIT_TRUE((std::is_same, mp_list>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, mp_list>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, mp_list<>>));
+
+ BOOST_TEST_TRAIT_TRUE((std::is_same, mp_list>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, mp_list>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, mp_list<>>));
+
+ using L3 = mp_list;
+
+ BOOST_TEST_TRAIT_TRUE((std::is_same, mp_list>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, mp_size_t<18>>, mp_list>));
+ }
+
+ {
+ using L1 = std::tuple<>;
+
+ BOOST_TEST_TRAIT_TRUE((std::is_same, L1>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, L1>));
+
+ using L2 = std::tuple;
+
+ BOOST_TEST_TRAIT_TRUE((std::is_same, L2>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, L2>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, L2>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, L2>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, L2>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, L2>));
+
+ BOOST_TEST_TRAIT_TRUE((std::is_same, L2>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, L2>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, L2>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, L2>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, L2>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, L2>));
+
+ BOOST_TEST_TRAIT_TRUE((std::is_same, std::tuple>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, std::tuple>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, std::tuple>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, std::tuple>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, std::tuple>));
+
+ BOOST_TEST_TRAIT_TRUE((std::is_same, std::tuple>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, std::tuple>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, std::tuple>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, std::tuple>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, std::tuple>));
+
+ BOOST_TEST_TRAIT_TRUE((std::is_same, std::tuple>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, std::tuple>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, std::tuple>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, std::tuple>));
+
+ BOOST_TEST_TRAIT_TRUE((std::is_same, std::tuple>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, std::tuple>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, std::tuple>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, std::tuple>));
+
+ BOOST_TEST_TRAIT_TRUE((std::is_same, std::tuple>));
+ BOOST_TEST_TRAIT_TRUE((std::is_same, std::tuple