mp_product<F, L...>mp_drop_c<L, N>mp_drop<L, N>mp_iota_c<L, N>mp_iota<L, N>mp_iota_c<N>mp_iota<N>mp_at_c<L, I>mp_at<L,
I>template<class L1, class L2> using mp_assign = /*...*/;+
+ mp_assign<L1<T1...>,
+ L2<T2...>>
+ is an alias for L1<T2...>.
+ That is, it replaces the elements of L1
+ with those of L2.
+
template<class L> using mp_clear = mp_assign<L, mp_list<>>;+
+ mp_clear<L<T...>>
+ is an alias for L<>,
+ that is, it removes the elements of L.
+
template<template<class...> class F, class... L> using mp_transform = /*...*/;+
+ mp_transform<F, L1<T1...>, L2<T2...>, ...,
+ Ln<Tn...>>
+ applies F to each successive
+ tuple of elements and returns L1<F<T1, T2, ..., Tn>...>.
+
template<template<class...> class P, template<class...> class F, class L> using mp_transform_if = /*...*/;+
+ mp_transform_if replaces
+ the elements T of L for which mp_to_bool<P<T>> is mp_true
+ with F<T>,
+ and returns the result.
+
template<class L, class V> using mp_fill = /*...*/;+
+ mp_fill<L<T...>, V>
+ returns L<V, V, ..., V>,
+ with the result having the same size as the input.
+
template<class L, class V> using mp_count = /*...*/;+
+ mp_count<L, V> returns mp_size_t<N>, where N
+ is the number of elements of L
+ same as V.
+
template<class L, template<class...> class P> using mp_count_if = /*...*/;+
+ mp_count_f<L, P> returns mp_size_t<N>, where N
+ is the number of elements T
+ of L for which mp_to_bool<P<T>>
+ is mp_true.
+
template<class L, class V> using mp_contains = mp_to_bool<mp_count<L, V>>;+
+ mp_contains<L, V> is mp_true
+ when L contains an element
+ V, mp_false
+ otherwise.
+
template<class L, std::size_t N> using mp_repeat_c = /*...*/;+
+ mp_repeat_c<L, N> returns a list of the same type as
+ L that consists of N concatenated copies of L.
+
template<class L, class N> using mp_repeat = /*...*/;+
+ Same as mp_repeat_c but
+ with a type argument N.
+ The number of copies is N::value
+ and must be nonnegative.
+
template<template<class...> class F, class... L> using mp_product = /*...*/;+
+ mp_product<F, L1<T1...>, L2<T2...>, ...,
+ Ln<Tn...>>
+ evaluates F<U1, U2, ..., Un> for values Ui
+ taken from the Cartesian product of the lists, as if the elements Ui are formed by n
+ nested loops, each traversing Li.
+ It returns a list of type L1
+ containing the results of the application of F.
+
template<class L, std::size_t N> using mp_drop_c = /*...*/;+
+ mp_drop_c<L, N> removes the first N
+ elements of L and returns
+ the result.
+
template<class L, class N> using mp_drop = /*...*/;+
+ Same as mp_drop_c, but
+ with a type argument N.
+ N::value must be a nonnegative number.
+
template<std::size_t N> using mp_iota_c = /*...*/;+
+ mp_iota_c<N>
+ is an alias for mp_list<mp_size_t<0>,
+ mp_size_t<1>, ...,
+ mp_size_t<N-1>>.
+
template<class N> using mp_iota = /*...*/;+
+ Same as mp_iota_c, but
+ with a type argument N.
+ N::value must be a nonnegative number. Returns
+ mp_list<std::integral_constant<T, 0>, std::integral_constant<T, 1>,
+ ..., std::integral_constant<T, N::value-1>>
+ where T is the type of
+ N::value.
+
template<class L, std::size_t I> using mp_at_c = /*...*/;+
+ mp_at_c<L, I> returns the Ith
+ element of L, zero-based.
+
template<class L, class I> using mp_at = /*...*/;+
+ Same as mp_at_c, but with
+ a type argument I. I::value
+ must be a nonnegative number.
+
template<class L, std::size_t N> using mp_take_c = /*...*/;+
+ mp_take_c<L, N> returns a list of the same type as
+ L containing the first
+ N elements of L.
+
template<class L, class N> using mp_take = /*...*/;+
+ Same as mp_take_c, but
+ with a type argument N.
+ N::value must be a nonnegative number.
+
template<class L, class V, class W> using mp_replace = /*...*/;+
+ Replaces all V elements
+ of L with W and returns the result.
+
template<class L, template<class...> class P, class W> using mp_replace_if = /*...*/;+
+ Replaces all T elements
+ of L for which mp_to_bool<P<T>>
+ is mp_true with W and returns the result.
+
template<class L, template<class...> class P> using mp_copy_if = /*...*/;+
+ Copies the elements T of
+ L for which mp_to_bool<P<T>>
+ is mp_true to a new list
+ of the same type and returns it.
+
template<class L, class V> using mp_remove = /*...*/;+
+ Removes all V elements
+ of L and returns the result.
+
template<class L, template<class...> class P> using mp_remove_if = /*...*/;+
+ Removes all elements T
+ of L for which mp_to_bool<P<T>>
+ is mp_true and returns
+ the result.
+
template<class L, template<class...> class P> using mp_partition = /*...*/;+
+ mp_partition<L<T...>, P>
+ partitions L into two lists
+ L<U1...>
+ and L<U2...>
+ such that mp_to_bool<P<T>>
+ is mp_true for the elements
+ of L<U1...>
+ and mp_false for the elements
+ of L<U2...>.
+ Returns L<L<U1...>,
+ L<U2...>>.
+
template<class L, template<class...> class P> using mp_sort = /*...*/;+
+ mp_sort<L, P> sorts the list L
+ according to the strict weak ordering mp_to_bool<P<T, U>>.
+
Last revised: March 15, 2017 at 16:06:15 GMT |
+Last revised: March 15, 2017 at 17:28:31 GMT |