////
Copyright 2017-2019 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
////

[#algorithm]
# Algorithms, <boost/mp11/algorithm.hpp>
:toc:
:toc-title:
:idprefix:

## mp_transform<F, 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>...>`.

All lists in `L...` must be of the same size. Otherwise, the result is a substitution failure.

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 =
    typename std::add_pointer<T>::type;  // std::add_pointer_t in C++14

using L1 = std::tuple<void, int, float>;
using R1 = mp_transform<add_pointer_t, L1>; // std::tuple<void*, int*, float*>
```

.Using mp_transform to compare the contents of two lists of types
```
using L1 = std::tuple<void, int, float>;
using L2 = mp_list<void, int, float>;

using R1 = mp_apply<mp_all, mp_transform<std::is_same, L1, L2>>; // mp_true
```

.Using mp_transform to compare the contents of two lists of integral constants
```
template<class T1, class T2> using eq = mp_bool<T1::value == T2::value>;

using L1 = std::tuple<mp_int<1>, mp_int<2>, mp_int<3>>;
using L2 = mp_list<mp_size_t<1>, mp_size_t<2>, mp_size_t<3>>;

using R1 = mp_apply<mp_all, mp_transform<eq, L1, L2>>; // mp_true
```

.mp_transform on one list
[cols="<.^4m,4*^.^1m",width=85%]
|===
|*L1*|A~1~|A~2~|...|A~n~
5+|
|*mp_transform<F, L1>*|F<A~1~>|F<A~2~>|...|F<A~n~>
|===

.mp_transform on two lists
[cols="<.^4m,4*^.^1m",width=85%]
|===
|*L1*|A~1~|A~2~|...|A~n~
5+|
|*L2*|B~1~|B~2~|...|B~n~
5+|
|*mp_transform<F, L1, L2>*|F<A~1~,B~1~>|F<A~2~,B~2~>|...|F<A~n~,B~n~>
|===

## mp_transform_q<Q, L...>

    template<class Q, class... L> using mp_transform_q =
        mp_transform<Q::template fn, L...>;

As `mp_transform`, but takes a quoted metafunction.

.Using mp_transform_q to count the occurrences of `void` in a list
```
using L1 = std::tuple<void, int, float, void, int>;

using R1 = mp_apply<mp_plus,
    mp_transform_q<mp_bind_front<std::is_same, void>, L1>>; // mp_int\<2>
```

[cols="<.^4m,4*^.^1m",width=85%]
.mp_transform_q on two lists
|===
|*L1*|A~1~|A~2~|...|A~n~
5+|
|*L2*|B~1~|B~2~|...|B~n~
5+|
|*mp_transform_q<Q, L1, L2>*|Q::fn<A~1~,B~1~>|Q::fn<A~2~,B~2~>|...|Q::fn<A~n~,B~n~>
|===

## mp_transform_if<P, F, L...>

    template<template<class...> class P, template<class...> class F, class... L>
        using mp_transform_if = /*...*/;

`mp_transform_if<P, F, L1, L2, ..., Ln>` replaces the elements of the list `L1` for which `mp_to_bool<P<T1, T2, ..., Tn>>` is `mp_true` with
`F<T1, T2, ..., Tn>`, and returns the result, where `Ti` are the corresponding elements of `Li`.

.Using mp_transform_if to replace the occurrences of 'void' in a list with the corresponding elements of a second list
```
using L1 = std::tuple<void, int, float, void, int>;
using L2 = std::tuple<char[1], char[2], char[3], char[4], char[5]>;

template<class T1, class T2> using first_is_void = std::is_same<T1, void>;
template<class T1, class T2> using second = T2;

using R1 = mp_transform_if<first_is_void, second, L1, L2>;
  // std::tuple<char[1], int, float, char[4], int>
```

.mp_transform_if
[cols="<.^4m,4*^.^1m",width=85%]
|===
|*L1*|A~1~|A~2~|...|A~n~
5+|
|*L2*|B~1~|B~2~|...|B~n~
5+|
|*P<A~i~, B~i~>*|mp_false|mp_true|...|mp_false
5+|
|*mp_transform_if<P, F, L1, L2>*|A~1~|F<A~2~,B~2~>|...|A~n~
|===

## mp_transform_if_q<Qp, Qf, L...>

    template<class Qp, class Qf, class... L> using mp_transform_if_q =
        mp_transform_if<Qp::template fn, Qf::template fn, L...>;

As `mp_transform_if`, but takes quoted metafunctions.

.Using mp_transform_if_q to replace the occurrences of 'void' in a list with the corresponding elements of a second list
```
using L1 = std::tuple<void, int, float, void, int>;
using L2 = std::tuple<char[1], char[2], char[3], char[4], char[5]>;

using R1 = mp_transform_if_q<mp_bind<std::is_same, _1, void>, _2, L1, L2>;
  // std::tuple<char[1], int, float, char[4], int>
```

.mp_transform_if_q
[cols="<.^4m,4*^.^1m",width=85%]
|===
|*L1*|A~1~|A~2~|...|A~n~
5+|
|*L2*|B~1~|B~2~|...|B~n~
5+|
|*Qp::fn<A~i~, B~i~>*|mp_false|mp_true|...|mp_false
5+|
|*mp_transform_if_q<Qp, _2, L1, L2>*|A~1~|B~2~|...|A~n~
|===

## mp_filter<P, L...>

    template<template<class...> class P, class... L> using mp_filter = /*...*/;

`mp_filter<P, L1, L2, ..., Ln>` removes the elements of the list `L1` for which `mp_to_bool<P<T1, T2, ..., Tn>>`
is `mp_false` and returns the result, where `Ti` are the corresponding elements of `Li`.

See also `mp_copy_if` and `mp_remove_if`, less general variants of `mp_filter` that only take a single list.

## mp_filter_q<Qp, L...>

    template<class Qp, class... L> using mp_filter_q =
        mp_filter<Qp::template fn, L...>;

As `mp_filter`, but takes a quoted metafunction.

.Using mp_filter_q to pick elements of a list based on a mask in another list
```
using L1 = std::tuple<void, int, float>;
using L2 = mp_list<mp_true, mp_false, mp_true>;
using R1 = mp_filter_q<_2, L1, L2>; // std::tuple<void, float>
```

## mp_fill<L, V>

    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.

Supports a value list as `L` under {cpp}17. In that case, the elements are replaced with `V::value`.

.Using mp_fill with std::tuple
```
using L1 = std::tuple<void, int, float>;
using R1 = mp_fill<L1, double>; // std::tuple<double, double, double>
```

.Using mp_fill with std::pair
```
using L1 = std::pair<int, float>;
using R1 = mp_fill<L1, void>; // std::pair<void, void>
```

.Using mp_fill with mp_list_v
```
using L1 = mp_list_v<true, false>;
using R1 = mp_fill<L1, mp_int<7>>; // mp_list_v<7, 7>
```

.mp_fill
[cols="<.^4m,4*^.^1m",width=85%]
|===
|*L1*|A~1~|A~2~|...|A~n~
5+|
|*mp_fill<L1, V>*|V|V|...|V
|===

## mp_count<L, V>

    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`.

## mp_count_if<L, P>

    template<class L, template<class...> class P> using mp_count_if = /*...*/;

`mp_count_if<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`.

## mp_count_if_q<L, Q>

    template<class L, class Q> using mp_count_if_q = mp_count_if<L, Q::template fn>;

As `mp_count_if`, but takes a quoted metafunction.

## mp_contains<L, V>

    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.

## mp_starts_with<L1, L2>

    template<class L1, class L2> using mp_starts_with = /*...*/;

`mp_starts_with<L1, L2>` is `mp_true` when `L1` starts with `L2`, `mp_false`
otherwise.

## mp_repeat_c<L, N>

    template<class L, std::size_t N> using mp_repeat_c = /*...*/;

`mp_repeat_c<L, N>` returns a list of the same form as `L` that consists of `N` concatenated copies of `L`.

Supports value lists as `L` under {cpp}17.

.Using mp_repeat_c
```
using L1 = tuple<int>;
using R1 = mp_repeat_c<L1, 3>; // tuple<int, int, int>

using L2 = pair<int, float>;
using R2 = mp_repeat_c<L2, 1>; // pair<int, float>

using L3 = mp_list<int, float>;
using R3 = mp_repeat_c<L3, 2>; // mp_list<int, float, int, float>

using L4 = mp_list<int, float, double>;
using R4 = mp_repeat_c<L4, 0>; // mp_list<>

using L5 = mp_list_v<true, 8>;
using R5 = mp_repeat_c<L5, 2>; // mp_list_v<true, 8, true, 8>
```

## mp_repeat<L, N>

    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.

Supports value lists as `L` under {cpp}17.

## mp_product<F, L...>

    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 the form `L1<V...>` containing the results of the application of `F`. The degenerate case
of zero lists, `mp_product<F>`, returns `mp_list<F<>>`.

.mp_product on two lists
[cols="<.^4m,4*^.^1m",width=85%]
|===
|*L1*|A~1~|A~2~|...|A~n~
5+|
|*L2*|B~1~|B~2~|...|B~m~
5+|
|*mp_product<F, L1, L2>*|F<A~1~,B~1~>|F<A~1~,B~2~>|...|F<A~1~,B~m~>
||F<A~2~,B~1~>|F<A~2~,B~2~>|...|F<A~2~,B~m~>
|
4+|...
||F<A~n~,B~1~>|F<A~n~,B~2~>|...|F<A~n~,B~m~>
|===

## mp_product_q<Q, L...>

    template<class Q, class... L> using mp_product_q = mp_product<Q::template fn, L...>;

As `mp_product`, but takes a quoted metafunction.

## mp_power_set<L>

    template<class L> using mp_power_set = /*...*/;

`mp_power_set<L>` returns a list (of the same form as `L`) of all possible 2^n^ subsets of `L` (where `n` is the length of `L`.)

`mp_power_set<L<>>` returns `L<L<>>`.

`mp_power_set<L<T1>>` returns `L<L<>, L<T1>>`.

`mp_power_set<L<T1, T2>>` returns `L<L<>, L<T2>, L<T1>, L<T1, T2>>`.

`mp_power_set<L<T1, T...>>` returns the concatenation of `mp_power_set<L<T...>>` and that same list with `T1` prepended to each element.

## mp_drop_c<L, N>

    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.

Supports a value list as `L` under {cpp}17.

.mp_drop_c
[cols="<.^4m,6*^.^1m",width=85%]
|===
|*L1*|A~1~|...|A~m~|A~m+1~|...|A~n~
7+|
|*mp_drop_c<L1, M>*|A~m+1~|...|A~n~ 3+|
|===

## mp_drop<L, N>

    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.

## mp_from_sequence<S, F>

    template<class S, class F = mp_int<0>> using mp_from_sequence = /*...*/

`mp_from_sequence` transforms an integer sequence produced by `make_integer_sequence` into an `mp_list`
of the corresponding `std::integral_constant` types. If the optional second parameter `F` is supplied,
an offset of `F::value` is added to all values.

Given

    template<class T, T... I> struct S;

`mp_from_sequence<S<T, I...>, F>` is an alias for `mp_list<std::integral_constant<T, I + F::value>...>`.

## mp_iota_c<N, F>

    template<std::size_t N, std::size_t F = 0> using mp_iota_c = /*...*/;

`mp_iota_c<N, F>` is an alias for `mp_list<mp_size_t<F+0>, mp_size_t<F+1>, ..., mp_size_t<F+N-1>>`.

.mp_iota_c
[cols="<.^4m,4*^.^1m",width=85%]
|===
|*mp_iota_c<4>*|mp_size_t<0>|mp_size_t<1>|mp_size_t<2>|mp_size_t<3>
|*mp_iota_c<4, 2>*|mp_size_t<2>|mp_size_t<3>|mp_size_t<4>|mp_size_t<5>
|===

## mp_iota<N, F>

    template<class N, class F = mp_int<0>> using mp_iota = /*...*/;

Same as `mp_iota_c`, but with a type arguments `N` and `F`. `N::value` must be a nonnegative number. Returns
`mp_list<std::integral_constant<T, F::value+0>, std::integral_constant<T, F::value+1>, ..., std::integral_constant<T, F::value+N::value-1>>`
where `T` is the type of `N::value`.

.mp_iota
[cols="<.^4m,4*^.^1m",width=85%]
|===
|*mp_iota<mp_size_t<4>>*|mp_size_t<0>|mp_size_t<1>|mp_size_t<2>|mp_size_t<3>
|*mp_iota<mp_int<4>, mp_int\<-2>>*|mp_int\<-2>|mp_int\<-1>|mp_int<0>|mp_int<+1>
|===

## mp_at_c<L, I>

    template<class L, std::size_t I> using mp_at_c = /*...*/;

`mp_at_c<L, I>` returns the `I`-th element of `L`, zero-based.

Supports a value list as `L` under {cpp}17. In that case, the element is returned wrapped with `mp_value`.

## mp_at<L, I>

    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.

## mp_take_c<L, N>

    template<class L, std::size_t N> using mp_take_c = /*...*/;

`mp_take_c<L, N>` returns a list of the same form as `L` containing the first `N` elements of `L`.

Supports a value list as `L` under {cpp}17.

.mp_take_c
[cols="<.^4m,6*^.^1m",width=85%]
|===
|*L1*|A~1~|...|A~m~|A~m+1~|...|A~n~
7+|
|*mp_take_c<L1, M>*|A~1~|...|A~m~ 3+|
|===

## mp_take<L, N>

    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.

## 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>;

`mp_back<L>` returns the last element of the list `L`.

Supports a value list as `L` under {cpp}17. In that case, the element is returned wrapped with `mp_value`.

## mp_pop_back<L>

    template<class L> using mp_pop_back = mp_take_c<L, mp_size<L>::value - 1>;

`mp_pop_back<L>` removes the last element of the list `L` and returns the result.

Supports a value list as `L` under {cpp}17.

## mp_insert_c<L, I, T...>

    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).

Supports a value list as `L` under {cpp}17. In that case, the elements `T::value...` are inserted.

.mp_insert_c with two elements
[cols="<.^4m,8*^.^1m",width=85%]
|===
|*L1*|A~1~|...|A~m~|A~m+1~|...|A~n~ 2+|
9+|
|*mp_insert_c<L1, M, B~1~, B~2~>*|A~1~|...|A~m~|B~1~|B~2~|A~m+1~|...|A~n~
|===

## mp_insert<L, I, T...>

    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`.

## mp_erase_c<L, I, J>

    template<class L, std::size_t I, std::size_t J> using mp_erase_c =
        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).

Supports a value list as `L` under {cpp}17.

.mp_erase_c
[cols="<.^4m,9*^.^1m",width=85%]
|===
|*L1*|A~0~|...|A~i-1~|A~i~|...|A~j-1~|A~j~|...|A~n-1~
10+|
|*mp_erase_c<L1, I, J>*|A~0~|...|A~i-1~|A~j~|...|A~n-1~ 3+|
|===

## mp_erase<L, I, J>

    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`.

## mp_replace<L, V, W>

    template<class L, class V, class W> using mp_replace = /*...*/;

Replaces all `V` elements of `L` with `W` and returns the result.

.mp_replace
[cols="<.^4m,4*^.^1m",width=85%]
|===
|*L1*|A~1~|V|...|A~n~
5+|
|*mp_replace<L1, V, W>*|A~1~|W|...|A~n~
|===

## mp_replace_if<L, P, W>

    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.

.mp_replace_if
[cols="<.^4m,4*^.^1m",width=85%]
|===
|*L1*|A~1~|A~2~|...|A~n~
5+|
|*P<A~i~>*|mp_false|mp_true|...|mp_false
5+|
|*mp_replace_if<L1, P, W>*|A~1~|W|...|A~n~
|===

## mp_replace_if_q<L, Q, W>

    template<class L, class Q, class W> using mp_replace_if_q =
        mp_replace_if<L, Q::template fn, W>;

As `mp_replace_if`, but takes a quoted metafunction.

## mp_replace_at_c<L, I, W>

    template<class L, std::size_t I, class W> using mp_replace_at_c = /*...*/;

Replaces the element of `L` at zero-based index `I` with `W` and returns the result.

## mp_replace_at<L, I, W>

    template<class L, class I, class W> using mp_replace_at = /*...*/;

Same as `mp_replace_at_c`, but with a type argument `I`. `I::value` must be a nonnegative number.

## mp_rotate_left_c<L, N>

    template<class L, std::size_t N> using mp_rotate_left_c = /*...*/;

Moves the `N % M` initial elements of the list `L` to the back, where `M` is the size of `L`. Empty
lists are unchanged.

## mp_rotate_left<L, N>

    template<class L, class N> using mp_rotate_left = /*...*/;

Same as `mp_rotate_left_c`, but with a type argument `N`. `N::value` must be a nonnegative number.

## mp_rotate_right_c<L, N>

    template<class L, std::size_t N> using mp_rotate_right_c = /*...*/;

Moves the `N % M` trailing elements of the list `L` to the front, where `M` is the size of `L`. Empty
lists are unchanged.

## mp_rotate_right<L, N>

    template<class L, class N> using mp_rotate_right = /*...*/;

Same as `mp_rotate_right_c`, but with a type argument `N`. `N::value` must be a nonnegative number.

## mp_copy_if<L, P>

    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 form and returns it.

## mp_copy_if_q<L, Q>

    template<class L, class Q> using mp_copy_if_q = mp_copy_if<L, Q::template fn>;

As `mp_copy_if`, but takes a quoted metafunction.

## mp_remove<L, V>

    template<class L, class V> using mp_remove = /*...*/;

Removes all `V` elements of `L` and returns the result.

## mp_remove_if<L, P>

    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.

## mp_remove_if_q<L, Q>

    template<class L, class Q> using mp_remove_if_q = mp_remove_if<L, Q::template fn>;

As `mp_remove_if`, but takes a quoted metafunction.

## mp_flatten<L>

    template<class L, class L2 = mp_clear<L>> using mp_flatten = /*...*/;

Replaces all elements `T` of `L` that are lists of the same form as `L2` (that is, those for which
`mp_similar<T, L2>` is `mp_true`) with their elements and returns the result.

.Using mp_flatten
```
using L1 = tuple<int, tuple<>, void, tuple<float, double>>;
using R1 = mp_flatten<L1>; // tuple<int, void, float, double>

using L2 = mp_list<int, mp_list<float>, tuple<void>>;
using R2a = mp_flatten<L2>; // mp_list<int, float, tuple<void>>
using R2b = mp_flatten<L2, tuple<>>; // mp_list<int, mp_list<float>, void>

using L3 = mp_list<mp_list<float>, mp_list<mp_list<void>>>;
using R3 = mp_flatten<L3>; // mp_list<float, mp_list<void>>
```

## mp_intersperse<L, S>

    template<class L, class S> using mp_intersperse = /*...*/;

Inserts the separator `S` between the elements of the list `L`.

`mp_intersperse<L<>, S>` is `L<>`. `mp_intersperse<L<T1>, S>` is `L<T1>`.
`mp_intersperse<L<T1, T2, T3, ..., Tn-1, Tn>, S>` is `L<T1, S, T2, S, T3, S, ..., Tn-1, S, Tn>`.

## mp_split<L, S>

    template<class L, class S> using mp_split = /*...*/;

Splits the list `L` into segments at each separator `S` and returns a list of
the segments.

`mp_split<L<>, S>` is `L<L<>>`. `mp_split<L<T...>, S>`, where `S` does not occur in `T...`,
is `L<L<T...>>`. `mp_split<L<T1..., S, T2..., S, T3...>, S>` is `L<L<T1...>, L<T2...>, L<T3...>>`.

The segments may be empty; `mp_split<L<S, X, Y, S, S>, S>` is `L<L<>, L<X, Y>, L<>, L<>>`.

## mp_join<L, S>

    template<class L, class S> using mp_join = /*...*/;

`mp_join` is the reverse operation of `mp_split`; it takes a list of segments `L` and joins
them into a single list, inserting the separator `S` between them.

`mp_join<mp_split<L, S>, S>` yields back the original list `L`.

For example, `mp_split<L<X1, X2, S, X3>, S>` gives `L<L<X1, X2>, L<X3>>`, and
`mp_join<L<L<X1, X2>, L<X3>>, S>` results in `L<X1, X2, S, X3>`.

`mp_join<L, S>` is equivalent to (and is implemented as) `mp_apply<mp_append, mp_intersperse<L, mp_list<S>>>`.

## mp_partition<L, P>

    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...>>`.

## mp_partition_q<L, Q>

    template<class L, class Q> using mp_partition_q = mp_partition<L, Q::template fn>;

As `mp_partition`, but takes a quoted metafunction.

## mp_sort<L, P>

    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>>`.

.Using mp_sort to sort a list of std::ratio values
----
#include <ratio>

using L1 = mp_list<std::ratio<1,2>, std::ratio<1,4>>;
using R1 = mp_sort<L1, std::ratio_less>; // mp_list<ratio<1,4>, ratio<1,2>>
----

## mp_sort_q<L, Q>

    template<class L, class Q> using mp_sort_q = mp_sort<L, Q::template fn>;

As `mp_sort`, but takes a quoted metafunction.

## mp_nth_element_c<L, I, P>

    template<class L, std::size_t I, template<class...> class P> using mp_nth_element_c =
        /*...*/;

Returns the element at position `I` in `mp_sort<L, P>`.

## mp_nth_element<L, I, P>

    template<class L, class I, template<class...> class P> using mp_nth_element = /*...*/;

Like `mp_nth_element_c`, but with a type argument `I`. `I::value` must be a nonnegative number.

## mp_nth_element_q<L, I, Q>

    template<class L, class I, class Q> using mp_nth_element_q =
        mp_nth_element<L, I, Q::template fn>;

Like `mp_nth_element`, but takes a quoted metafunction.

## mp_min_element<L, P>

    template<class L, template<class...> class P> using mp_min_element = /*...*/;

`mp_min_element<L, P>` returns the minimal element of the list `L` according to the ordering `mp_to_bool<P<T, U>>`.

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>;

As `mp_min_element`, but takes a quoted metafunction.

## mp_max_element<L, P>

    template<class L, template<class...> class P> using mp_max_element = /*...*/;

`mp_max_element<L, P>` returns the maximal element of the list `L` according to the ordering `mp_to_bool<P<T, U>>`.

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>;

As `mp_max_element`, but takes a quoted metafunction.

## mp_find<L, V>

    template<class L, class V> using mp_find = /*...*/;

`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 occurrence of `V` in `L`. If `L` does not contain `V`, `mp_find<L, V>`
is `mp_size<L>`.

## mp_find_if<L, P>

    template<class L, template<class...> class P> using mp_find_if = /*...*/;

`mp_find_f<L, P>` is an alias for `mp_size_t<I>`, where `I` is the zero-based index of the first element `T` in `L` for which
`mp_to_bool<P<T>>` is `mp_true`. If there is no such element, `mp_find_if<L, P>` is `mp_size<L>`.

## mp_find_if_q<L, Q>

    template<class L, class Q> using mp_find_if_q = mp_find_if<L, Q::template fn>;

As `mp_find_if`, but takes a quoted metafunction.

## mp_reverse<L>

    template<class L> using mp_reverse = /*...*/;

`mp_reverse<L<T1, T2, ..., Tn>>` is `L<Tn, ..., T2, T1>`.

.mp_reverse
[cols="<.^4m,4*^.^1m",width=85%]
|===
|*L1*|A~1~|A~2~|...|A~n~
5+|
|*mp_reverse<L1>*|A~n~|A~n-1~|...|A~1~
|===

## mp_fold<L, V, F>

    template<class L, class V, template<class...> class F> using mp_fold = /*...*/;

`mp_fold<L<T1, T2, ..., Tn>, V, F>` is `F< F< F< F<V, T1>, T2>, ...>, Tn>`, or `V`, if `L` is empty.

.Using mp_fold to add the contents of a list of std::ratio values
----
#include <ratio>

using L1 = mp_list<std::ratio<1,8>, std::ratio<1,4>, std::ratio<1,2>>;
using R1 = mp_fold<L1, std::ratio<0,1>, std::ratio_add>; // std::ratio<7,8>
----

## mp_fold_q<L, V, Q>

    template<class L, class V, class Q> using mp_fold_q =
        mp_fold<L, V, Q::template fn>;

As `mp_fold`, but takes a quoted metafunction.

## mp_reverse_fold<L, V, F>

    template<class L, class V, template<class...> class F> using mp_reverse_fold =
        /*...*/;

`mp_reverse_fold<L<T1, T2, ..., Tn>, V, F>` is `F<T1, F<T2, F<..., F<Tn, V>>>>`, or `V`, if `L` is empty.

## mp_reverse_fold_q<L, V, Q>

    template<class L, class V, class Q> using mp_reverse_fold_q =
        mp_reverse_fold<L, V, Q::template fn>;

As `mp_reverse_fold`, but takes a quoted metafunction.

## mp_partial_sum<L, V, F>

    template<class L, class V, template<class...> class F> using mp_partial_sum = /*...*/;

`mp_partial_sum<L, V, F>` is similar to `mp_fold<L, V, F>`, but instead of its final result, it returns
a list (of the same form as `L`) holding the intermediate results of the fold. The last element of the
result of `mp_partial_sum` is the same as the result of `mp_fold`.

For example, `mp_fold<mp_list<X1, X2, X3>, V, F>` is `F<F<F<V, X1>, X2>, X3>`, but
`mp_partial_sum<mp_list<X1, X2, X3>, V, F>` is `mp_list<F<V, X1>, F<F<V, X1>, X2>, F<F<F<V, X1>, X2>, X3>>`.

It's common for `F` to be `mp_plus`, in which case the result contains the partial sums of `L`.

.Using mp_partial_sum
----
using L1 = mp_list_c<int, 1, 2, 3, 4>;
using R1 = mp_partial_sum<L1, mp_int<0>, mp_plus>; // mp_list_c<int, 1, 3, 6, 10>
----

## mp_partial_sum_q<L, V, Q>

    template<class L, class V, class Q> using mp_partial_sum_q =
        mp_partial_sum<L, V, Q::template fn>;

As `mp_partial_sum`, but takes a quoted metafunction.

## mp_pairwise_fold<L, F>

    template<class L, template<class...> class F> using mp_pairwise_fold = /*...*/;

`mp_pairwise_fold<L, F>` returns a list of the same form as `L` whose elements are
the result of the application of the binary metafunction `F` to each pair of adjacent
elements of `L`. That is, `mp_pairwise_fold<L<T1, T2, T3>, F>` is
`L<F<T1, T2>, F<T2, T3>>`.

The result has one fewer element than the original. If `L` has only one element, the
result is an empty list. If `L` is an empty list, the result is also an empty list.

.Using mp_pairwise_fold
----
template<class L> using is_increasing = mp_all_of<
    mp_pairwise_fold<L, mp_less>, mp_to_bool>;
----

## mp_pairwise_fold_q<L, Q>

    template<class L, class Q> using mp_pairwise_fold_q =
        mp_pairwise_fold<L, Q::template fn>;

As `mp_pairwise_fold`, but takes a quoted metafunction.

.Using mp_pairwise_fold_q
----
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>
        using mp_iterate = /*...*/;

`mp_iterate<V, F, R>` applies `R` to `V` successively until that's no longer possible,
yielding the sequence `V`, `R<V>`, `R<R<V>>`, `R<R<R<V>>>`...

It then returns an `mp_list` whose elements are formed by applying `F` to the above
sequence of values. That is, it returns `mp_list<F<V>, F<R<V>>, F<R<R<V>>>, ...>`.

`mp_iterate` is in a way the reverse operation of `mp_reverse_fold`. Given

    template<class T, class U> struct cons {};
    struct nil {};

`mp_reverse_fold<mp_list<X1, X2, X3>, nil, cons>` produces `cons<X1, cons<X2, cons<X3, nil>>>`,
which when passed as `V` to `mp_iterate<V, mp_first, mp_second>` recovers the original
`mp_list<X1, X2, X3>`.

.Using mp_iterate
----
struct X1 {};
struct X2 {};
struct X3 {};

using L1 = mp_list<X1, X2, X3>;
using R1 = mp_iterate<L1, mp_first, mp_rest>; // L1

template<class T, class U> struct cons {};
struct nil {};

using V2 = mp_reverse_fold<L1, nil, cons>; // cons<X1, cons<X2, cons<X3, nil>>>
using R2 = mp_iterate<V2, mp_first, mp_second>; // L1

struct Y1 {};
struct Y2 { using value_type = double; using next_type = Y1; };
struct Y3 { using value_type = float; using next_type = Y2; };
struct Y4 { using value_type = int; using next_type = Y3; };

template<class T> using value_type = typename T::value_type;
template<class T> using next_type = typename T::next_type;

using R3 = mp_iterate<Y4, mp_identity_t, next_type>; // mp_list<Y4, Y3, Y2, Y1>
using R4 = mp_iterate<Y4, value_type, next_type>; // mp_list<int, float, double>
----

## mp_iterate_q<V, Qf, Qr>

    template<class V, class Qf, class Qr> using mp_iterate_q =
        mp_iterate<V, Qf::template fn, Qr::template fn>;

As `mp_iterate`, but takes quoted metafunctions.

## mp_unique<L>

    template<class L> using mp_unique = /*...*/;

`mp_unique<L>` returns a list of the same form as `L` with the duplicate elements removed.

## mp_unique_if<L, P>

    template<class L, template<class...> class P> using mp_unique_if = /*...*/;

As `mp_unique`, but two elements `T` and `U` are considered duplicates when `mp_to_bool<P<T, U>>` is `mp_true`.

## mp_unique_if_q<L, Q>

    template<class L, class Q> using mp_unique_if_q =
        mp_unique_if<L, Q::template fn>;

As `mp_unique_if`, but takes a quoted metafunction.

## mp_all_of<L, P>

    template<class L, template<class...> class P> using mp_all_of =
        mp_bool< mp_count_if<L, P>::value == mp_size<L>::value >;

`mp_all_of<L, P>` is `mp_true` when `P` holds for all elements of `L`, `mp_false` otherwise. When `L` is empty, the result is `mp_true`.

## mp_all_of_q<L, Q>

    template<class L, class Q> using mp_all_of_q = mp_all_of<L, Q::template fn>;

As `mp_all_of`, but takes a quoted metafunction.

## mp_none_of<L, P>

    template<class L, template<class...> class P> using mp_none_of =
        mp_bool< mp_count_if<L, P>::value == 0 >;

`mp_none_of<L, P>` is `mp_true` when `P` holds for no element of `L`, `mp_false` otherwise. When `L` is empty, the result is `mp_true`.

## mp_none_of_q<L, Q>

    template<class L, class Q> using mp_none_of_q = mp_none_of<L, Q::template fn>;

As `mp_none_of`, but takes a quoted metafunction.

## mp_any_of<L, P>

    template<class L, template<class...> class P> using mp_any_of =
        mp_bool< mp_count_if<L, P>::value != 0 >;

`mp_any_of<L, P>` 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`.

## mp_any_of_q<L, Q>

    template<class L, class Q> using mp_any_of_q = mp_any_of<L, Q::template fn>;

As `mp_any_of`, but takes a quoted metafunction.

## mp_for_each<L>(f)

    template<class L, class F> constexpr F mp_for_each(F&& f);

`mp_for_each<L>(f)` calls `f` with `T()` for each element `T` of the list `L`, in order.

Returns `std::forward<F>(f)`.

.Using mp_for_each and a C++14 lambda to print a tuple
```
template<class... T> void print( std::tuple<T...> const & tp )
{
    std::size_t const N = sizeof...(T);

    mp_for_each<mp_iota_c<N>>( [&]( auto I ){

        // I is mp_size_t<0>, mp_size_t<1>, ..., mp_size_t<N-1>

        std::cout << std::get<I>(tp) << std::endl;

    });
}
```

In case the elements of the list `L` are not default-constructible, you can use
`mp_for_each<mp_transform<mp_identity, L>>`, which would call `f` with `mp_identity<T>()`
instead of `T()`.

## mp_with_index<N>(i, f)

    template<std::size_t N, class F>
      constexpr auto mp_with_index( std::size_t i, F && f )
        -> decltype(std::declval<F>()(std::declval<mp_size_t<0>>()));

`mp_with_index<N>(i, f)` calls `f` with `mp_size_t<i>()` and returns the result. `i` must be less than `N`.
Only `constexpr` on C++14 and higher.

    template<class N, class F>
      constexpr auto mp_with_index( std::size_t i, F && f )
        -> decltype(std::declval<F>()(std::declval<mp_size_t<0>>()));

Returns `mp_with_index<N::value>(i, f)`.

.Using mp_with_index and a C++14 lambda to print the active element of a variant
```
template<class... T> void print( std::variant<T...> const& v )
{
    mp_with_index<sizeof...(T)>( v.index(), [&]( auto I ) {

        // I is mp_size_t<v.index()>{} here

        std::cout << std::get<I>( v ) << std::endl;

    });
}
```
