Mp11 Metaprogramming Library

The mp_apply<F, L> primitive is an alias for mp_rename<L, F>. It is used to 'call' a metafunction F using the elements of a list L as its template arguments. This exploits the structural similarity between a list L<T...> and a metafunction call F<T...>.

// If you have a list and want to pass its contents to a template
template<class... T> using my_metafunction = /* ... */; 
template<class... T> using my_list = mp_list<T...>;

using list = my_list<int, char>;
using result = mp_apply<my_metafunction, list>;

Mp11 provides three primary ways to represent lists of types or values:

1. mp_list<T...>: The standard type list. While mp_list is the default, Mp11 can operate on other class templates like std::tuple, std::variant, or std::pair.
2. mp_list_c<T, I...>: A helper that produces an mp_list of std::integral_constant<T, I> types from integer template arguments.
3. mp_list_v<A...>: The standard value list type (requires C++17), where elements are values rather than types.

Note: When using value lists with C++17, many Mp11 metafunctions will automatically wrap/unwrap values as needed.

// Type list
using L1 = mp_list<int, float>;

// Integral constant list
using L2 = mp_list_c<int, 2, 3>; // mp_list<mp_int<2>, mp_int<3>>

// Value list (C++17)
using L3 = mp_list_v<1, false, 8ull>;

In mp11, a map is represented as a list of lists. Each inner list must contain at least one element, which serves as the key. For a list to be considered a valid map, all keys must be unique.

You can verify if a type is a map using the mp_is_map<M> metafunction.

template<class M> using mp_is_map = /*...*/;

A quoted metafunction is a type that wraps a template so it can be passed as a value.

• mp_quote<F>: Transforms template F into a struct with a nested template fn such that fn<T...> returns F<T...>.
• mp_quote_trait<F>: Transforms a C++03-style trait F (which uses typename F<T>::type) into a quoted metafunction.
• mp_invoke_q<Q, T...>: Evaluates the fn template of a quoted metafunction Q with arguments T....

// Creating a list of metafunctions
using LQ = mp_list<mp_quote<std::is_const>, mp_quote<std::is_volatile>>;

// Using mp_quote_trait with std::add_pointer
using L1 = mp_list<int, void, float>;
using R1 = mp_transform_q<mp_quote_trait<std::add_pointer>, L1>;
  // mp_list<int*, void*, float*>

// Invoking a quoted metafunction
template<class T> using is_const_and_volatile = 
    mp_apply<mp_all, mp_product<mp_invoke_q, LQ, mp_list<T>>>;

In C++11, instead of using complex library primitives like meta_compose, you can compose metafunctions F, G, and H by defining a new template alias. This approach leverages the language's ability to nest template applications.

To compose functions such that F is applied to the result of G<H<T...>>, define:

template<class... T> using Fgh = F<G<H<T...>>>;

Both mp_or<T...> and mp_any<T...> check if mp_to_bool<U> is mp_true for any type in the pack.

Key Differences:

• mp_or<T...> performs short-circuit evaluation. If it encounters mp_true, it returns mp_true immediately and does not evaluate subsequent types.
• mp_any<T...> does not short-circuit. It evaluates all types in the pack. If any type in the pack causes a substitution failure, mp_any will result in a compile-time error.

// mp_or short-circuits: void is not reached
using R2 = mp_or<mp_true, void>;       // mp_true

// mp_any does NOT short-circuit: causes compile-time error
using R2 = mp_any<mp_true, void>;      // compile-time error

When specializing std::common_type for complex types (like std::tuple or custom expected types), use mp_defer to ensure the specialization is SFINAE-friendly.

Instead of defining a nested type member directly, mp_defer will only define the type if the metafunction passed to it is valid. This prevents hard substitution errors when the specialization is checked in a context where it shouldn't apply.

// Example: Specializing common_type for std::tuple
template<class Tp1, class Tp2> using common_tuple = mp_transform<common_type_t, Tp1, Tp2>;

namespace std
{
template<class... T1, class... T2>
struct common_type<std::tuple<T1...>, std::tuple<T2...>>:
    mp_defer<common_tuple, std::tuple<T1...>, std::tuple<T2...>>
{
};
}

Mp11 provides specialized structures for organizing types:

• Set: A list where all elements are unique.
• Map: A list of lists where each inner list has at least one element (the key), and all keys are unique. Maps can be represented using std::pair or nested mp_list structures.
• Value List: A template class where parameters are non-type template parameters (values) rather than types (e.g., template<auto...> class L).

Note on Value Lists: Mp11 focuses primarily on type manipulation. To manipulate value lists, the recommended pattern is to convert the value list to a type list using mp_rename, perform your type manipulations, and then convert back using mp_rename_v.

// Map example using mp_list of mp_lists
using M2 = mp_list<mp_list<int, int*>, mp_list<float>, mp_list<char, char[1], char[2]>>;