diff --git a/docs.in/reference/apply_product.cpp b/docs.in/reference/apply_product.cpp
index cf4d2663..89c112c2 100644
--- a/docs.in/reference/apply_product.cpp
+++ b/docs.in/reference/apply_product.cpp
@@ -26,7 +26,7 @@ the n-fold Cartesian product of the input `mp_list` lists.
 #include <yorel/yomm2/templates.hpp>
 
 using namespace yorel::yomm2;
-using boost::mp11::mp_list;
+using detail::types;
 
 struct a;
 struct b;
@@ -41,10 +41,10 @@ static_assert(
     std::is_same_v<
         apply_product<
             templates<bin1, bin2>,
-            mp_list<a, b>,
-            mp_list<x, y, z>
+            types<a, b>,
+            types<x, y, z>
         >,
-        mp_list<
+        types<
             bin1<a, x>, bin1<a, y>, bin1<a, z>,
             bin1<b, x>, bin1<b, y>, bin1<b, z>,
 
diff --git a/docs.in/reference/product.cpp b/docs.in/reference/product.cpp
index 75e8e763..172a1297 100644
--- a/docs.in/reference/product.cpp
+++ b/docs.in/reference/product.cpp
@@ -6,7 +6,7 @@ headers:yorel/yomm2/templates.hpp>
 template<typename... TypeLists>
 using product = /*unspecified*/;
 ```
-`product` takes a list of ->mp_list lists, and evaluates to a `mp_list` list
+`product` takes a list of ->types lists, and evaluates to a `types` list
 consisting of the n-fold Cartesian product of the input lists.
 
 ## Example
@@ -19,11 +19,9 @@ consisting of the n-fold Cartesian product of the input lists.
 
 #include <type_traits>
 #include <yorel/yomm2/core.hpp>
-#include <yorel/yomm2/compiler.hpp>
 #include <yorel/yomm2/templates.hpp>
 
 namespace yomm2 = yorel::yomm2;
-using boost::mp11::mp_list;
 
 struct a;
 struct b;
@@ -34,12 +32,12 @@ struct z;
 static_assert(
     std::is_same_v<
         yomm2::product<
-            mp_list<a, b>,
-            mp_list<x, y, z>
+            yomm2::types<a, b>,
+            yomm2::types<x, y, z>
         >,
-        mp_list<
-            mp_list<a, x>, mp_list<a, y>, mp_list<a, z>,
-            mp_list<b, x>, mp_list<b, y>, mp_list<b, z>
+        yomm2::types<
+            yomm2::types<a, x>, yomm2::types<a, y>, yomm2::types<a, z>,
+            yomm2::types<b, x>, yomm2::types<b, y>, yomm2::types<b, z>
         >
     >);
 
diff --git a/docs.in/tutorials/templates_tutorial.cpp b/docs.in/tutorials/templates_tutorial.cpp
index 724057f3..2cb2e1d6 100644
--- a/docs.in/tutorials/templates_tutorial.cpp
+++ b/docs.in/tutorials/templates_tutorial.cpp
@@ -19,13 +19,12 @@ std::ostream &operator<<(std::ostream &os, const std::type_info &ti) {
 
 #define elided
 
-#include <yorel/yomm2/core.hpp>
 #include <yorel/yomm2/compiler.hpp>
+#include <yorel/yomm2/core.hpp>
 #include <yorel/yomm2/symbols.hpp>
 #include <yorel/yomm2/templates.hpp>
 
 using namespace yorel::yomm2;
-using boost::mp11::mp_list;
 
 // md<
 
@@ -229,7 +228,6 @@ vector reals(new concrete_vector<double>{4., 5., 6.});
 
 // code<
 #include <yorel/yomm2/core.hpp>
-#include <yorel/yomm2/compiler.hpp>
 #include <yorel/yomm2/symbols.hpp>
 
 using namespace yorel::yomm2;
@@ -293,9 +291,9 @@ inline bool operator==(const vector& a, const vector& b) {
 // ```
 
 // This "closed" approach is lazy, and defies the purpose of *open* methods. It
-// is not for the author of the library to decide which mp_list to support. The
+// is not for the author of the library to decide which types to support. The
 // user may have no interest in integer vectors, but may need `complex` vectors.
-// Or vectors of `decimal` floating-point numbers. Or, mp_list from another
+// Or vectors of `decimal` floating-point numbers. Or, types from another
 // library, or perhaps created by the user himself. An advanced user may also
 // want to add new operations or vector subtypes (like large sparse vectors).
 // All this must be possible, and not unduly complex. Extensibility is what open
@@ -311,14 +309,14 @@ inline bool operator==(const vector& a, const vector& b) {
 // 1. Put the definitions in one or several templates, where the method being
 //    defined is the first template argument.
 // 2. Create a meta-function that generates interesting combinations of methods
-//    and mp_list.
+//    and types.
 // 3. Instantiate the container(s) for these combinations. The resulting classes
 //    must satisfy the requirements of a definition container, *or* be derived
 //    from class `not_defined`. Add the definition containers to the method,
 //    extracted from the first template argument.
 
 // The meta-programming library comprises:
-// - containers for mp_list and templates
+// - containers for types and templates
 // - meta-functions that generate Cartesian products of these containers.
 // - a mechanism for instantiating the resulting definitions.
 
@@ -328,7 +326,7 @@ inline bool operator==(const vector& a, const vector& b) {
 // 1. Make it very easy for a new user to use the library with all the defaults.
 // 2. Make it easy for a "normal" user to specify which parts of the library to
 //    use.
-// 3. Make it possible for an advanced user to extend the library with new mp_list
+// 3. Make it possible for an advanced user to extend the library with new types
 //    and new operations.
 
 // Let's apply these ideas to the `vector` methods. First we declare a container
@@ -344,7 +342,7 @@ struct definition;
 // md<
 
 // Let's create partial specializations that defines addition, subtraction and
-// comparison for vectors or two underlying mp_list:
+// comparison for vectors or two underlying types:
 
 // >
 
@@ -403,15 +401,15 @@ struct definition<comparison, T, U> {
 // ...then add the resulting definitions to their respective method.
 
 // For the Cartesian product, we can use two constructs provided by YOMM2: the
-// `mp_list` container, and the `product` meta-function.
+// `types` container, and the `product` meta-function.
 
-// `mp_list<typename...>` is a simple list of mp_list. It is similar to Boost.Mp11's
-// `mp_list`. Unlike `mp_list`, `mp_list` does not have a body. This helps detect
+// `types<typename...>` is a simple list of types. It is similar to Boost.Mp11's
+// `mp_list`. Unlike `mp_list`, `types` does not have a body. This helps detect
 // meta-programming bugs.
 
-// `product<typename... TypeLists>` takes any number of `mp_list` lists, and
-// returns a `mp_list` list containing all the combinations of one element taken
-// from each input list, each combination being itself wrapped in a `mp_list`. For
+// `product<typename... TypeLists>` takes any number of `types` lists, and
+// returns a `types` list containing all the combinations of one element taken
+// from each input list, each combination being itself wrapped in a `types`. For
 // example:
 
 // >
@@ -421,12 +419,12 @@ struct definition<comparison, T, U> {
 static_assert(
     std::is_same_v<
         product<
-            mp_list<int, double>,
-            mp_list<int, double, float>
+            types<int, double>,
+            types<int, double, float>
         >,
-        mp_list<
-            mp_list<int, int>, mp_list<int, double>, mp_list<int, float>,
-            mp_list<double, int>, mp_list<double, double>, mp_list<double, float>
+        types<
+            types<int, int>, types<int, double>, types<int, float>,
+            types<double, int>, types<double, double>, types<double, float>
         >
 >);
 
@@ -456,9 +454,9 @@ use_classes<
 use_definitions<
     definition,
     product<
-        mp_list<addition, subtraction, comparison>,
-        mp_list<int, double>,
-        mp_list<int, double>
+        types<addition, subtraction, comparison>,
+        types<int, double>,
+        types<int, double>
     >
 > YOMM2_GENSYM;
 
@@ -506,7 +504,7 @@ BOOST_AUTO_TEST_CASE(test_vectors) {
 // ## Writing a user-friendly instantiation function
 
 // Now we have everything we need to write a single template that allows users
-// to initialize the library for the mp_list they need. For that we use
+// to initialize the library for the types they need. For that we use
 // `std::tuple` to lump teh registration object together:
 
 // >
@@ -523,9 +521,9 @@ using use_vector_library = std::tuple<
     use_definitions<
         definition,
         product<
-            mp_list<addition, subtraction, comparison>,
-            mp_list<NumericTypes...>,
-            mp_list<NumericTypes...>
+            types<addition, subtraction, comparison>,
+            types<NumericTypes...>,
+            types<NumericTypes...>
         >
     >
 >;
@@ -535,7 +533,7 @@ using use_vector_library = std::tuple<
 // md<
 
 // All the user of the library needs to do now is to create an instance (object)
-// of `use_vector_library`, instantiated with the required mp_list:
+// of `use_vector_library`, instantiated with the required types:
 
 // >
 
@@ -606,7 +604,7 @@ use_vector_library<int, double> init_vectors;
 
 // For brevity, we will consider only ordinary (i.e. non-square), square and
 // symmetric matrices. Also, we will omit all maths and storage management, to
-// focus on dealing with mp_list.
+// focus on dealing with types.
 
 // Here is the implementation of these classes, and the intermediary abstract
 // classes:
@@ -702,7 +700,7 @@ struct symmetric : any_symmetric<T> {
 // importantly, better interfaces. For example, square matrices have a
 // determinant, which ordinary matrices do not have. Also, type errors can be
 // diagnosed by the compiler. However, compile-time specialization is possible
-// only if the mp_list of the matrices is known in advance. It may not always be
+// only if the types of the matrices is known in advance. It may not always be
 // the case.
 
 // Thus, as library designers, we face a dilemma: which users to serve best?
@@ -909,7 +907,7 @@ auto operator~(const handle<Matrix<T>>& m) {
 // 1. `Matrix`  is actually one of our `matrix` templates; without (1), *any*
 //    template would match.
 // 2. `Matrix<T>` is abstract; without (2), we would have an ambiguity with our
-//    own `operator~` defined above for concrete matrix mp_list.
+//    own `operator~` defined above for concrete matrix types.
 
 // C++20 concepts offer a much cleaner solution for taming template
 // instantiations.
@@ -919,7 +917,7 @@ auto operator~(const handle<Matrix<T>>& m) {
 // methods, e.g. `negate`. For that we use a templatized definition container
 // called `unary_definition`. We want to instantiate it for every combination of
 // method template, abstract base class, concrete implementation of the abstract
-// class, and this for the required numeric mp_list. E.g.:
+// class, and this for the required numeric types. E.g.:
 // - `transpose<any<int>>`, `any<int>`, `ordinary<int>`
 // - `transpose<any<int>>`, `any_square`, `square`
 // - `transpose<any<int>>`, `any_square`, `symmetrical`
@@ -939,14 +937,14 @@ auto operator~(const handle<Matrix<T>>& m) {
 // M = { unary method templates: transpose, negate, etc }
 // A = { abstract class templates }
 // C = { concrete class templates }
-// T = { required numeric mp_list }
+// T = { required numeric types }
 // ```
 
 // ...and selecting the combinations that satisfy the condition:
 // - `A<T>` is a base of `C<T>`
 
 // This time, we need to make a Cartesian product that involves templates as
-// well as mp_list. For this, YOMM2 provides two constructs:
+// well as types. For this, YOMM2 provides two constructs:
 // - `template_<template<typename...> typename>` wraps a template in a type. It
 // contains a nested template `fn<typename...Ts>`, which applies the original
 // template to `Ts...`. Thus we have the identity:
@@ -954,7 +952,7 @@ auto operator~(const handle<Matrix<T>>& m) {
 // template_<F>::template fn<Ts...> = F<Ts...>
 // ```
 // - `templates<template<typename...> typename...>` wraps a list of templates in
-// a `mp_list` list of `template_`s.
+// a `types` list of `template_`s.
 
 // We can now implement `unary_definition`:
 
@@ -1032,27 +1030,27 @@ use_definitions<
     unary_definition,
     product<
         templates<transpose>, abstract_matrix_templates,
-        concrete_matrix_templates, mp_list<double, int>>>
+        concrete_matrix_templates, types<double, int>>>
     YOMM2_GENSYM;
 // >
 
 // md<
 
 // We must not forget to register all the matrix classes, for both numeric
-// mp_list. For that, we can use another YOMM2 helper: `apply_product`. It takes a
-// `templates` list, and any number of `mp_list` list; forms the Cartesian
+// types. For that, we can use another YOMM2 helper: `apply_product`. It takes a
+// `templates` list, and any number of `types` list; forms the Cartesian
 // product; and, for each resulting combination, applies the first element - a
-// template - to the other elements. The result is a `mp_list` list of template
+// template - to the other elements. The result is a `types` list of template
 // instantiations.
 
 // We saw that `use_classes` takes a list of classes. It also works with a
-// list of `mp_list` lists. We can thus inject the result of `apply_product` into
+// list of `types` lists. We can thus inject the result of `apply_product` into
 // `use_classes`:
 
 // >
 
 // code<
-YOMM2_STATIC(use_classes<apply_product<matrix_templates, mp_list<double, int>>>);
+YOMM2_STATIC(use_classes<apply_product<matrix_templates, types<double, int>>>);
 // >
 
 #endif
@@ -1088,12 +1086,12 @@ BOOST_AUTO_TEST_CASE(test_dynamic_transpose) {
 // `any_square<double>`.
 
 // Fortunately, we can leverage the static `operator+` to deduce the return type
-// of additions that involve one or two abstract mp_list. This is what the nested
-// `abstract_type` and `concrete_type` aliases are for. We can convert the mp_list
+// of additions that involve one or two abstract types. This is what the nested
+// `abstract_type` and `concrete_type` aliases are for. We can convert the types
 // of the arguments to their nearest concrete type: for a
 // `any_symmetric<double>`, it is a `symmetric<double>`; for a `square<double>`,
 // it is `square<double>`. Then we can "pretend" to add two handles to objects
-// of the two mp_list, and extract the result's type using `decltype`. And
+// of the two types, and extract the result's type using `decltype`. And
 // finally, we convert that type to its abstract base class, using
 // `abstract_type`.
 
@@ -1182,7 +1180,7 @@ auto operator+(const handle<M1>& a, const handle<M2>& b) {
 // M = { unary method templates: transpose, negate, etc }
 // A1, A2 = { abstract class templates }
 // C1, C2 = { concrete class templates }
-// T1, T2 = { required numeric mp_list }
+// T1, T2 = { required numeric types }
 // ```
 
 // ...and selecting the combinations that satisfy the condition:
@@ -1287,8 +1285,8 @@ use_definitions<
     binary_definition,
     product<
         templates<add>, abstract_matrix_templates, concrete_matrix_templates,
-        mp_list<double, int>, abstract_matrix_templates,
-        concrete_matrix_templates, mp_list<double, int>>>
+        types<double, int>, abstract_matrix_templates,
+        concrete_matrix_templates, types<double, int>>>
     YOMM2_GENSYM;
 // >
 
@@ -1326,7 +1324,7 @@ BOOST_AUTO_TEST_CASE(test_dynamic_operations) {
 // Now we need to create a mechanism that enable users to instantiate just the
 // method definitions they want. This is more complicated than for the vector
 // library, because users need to be able to select from three sets: the
-// underlying numeric mp_list, the matrix mp_list, and the methods. For example:
+// underlying numeric types, the matrix types, and the methods. For example:
 
 // >
 
@@ -1338,11 +1336,11 @@ BOOST_AUTO_TEST_CASE(test_dynamic_operations) {
 // use_polymorphic_matrices<>::with<add, transpose> YOMM2_GENSYM;                        // 5
 // ```
 
-// 1. all matrix mp_list of `double`, with all operations
-// 2. all matrix mp_list of `int` and `double`, with all operations
+// 1. all matrix types of `double`, with all operations
+// 2. all matrix types of `int` and `double`, with all operations
 // 3. square and symmetric matrices of `double`, with all operations
 // 4. square and symmetric matrices of `int` and `double`, polymorphic addition only
-// 5. all matrix mp_list of `double`, with all operations
+// 5. all matrix types of `double`, with all operations
 
 // Let's implement this. First we need a few helpers.
 
@@ -1424,17 +1422,17 @@ struct definition_traits<add> : binary_definition_traits<add> {};
 
 template<template<typename> typename... Ms>
 struct use_polymorphic_matrices {
-    using abstract_matrix_templates = mp_list<
+    using abstract_matrix_templates = types<
         typename template_of<typename Ms<double>::abstract_type>::type...>;
     using concrete_matrix_templates = templates<Ms...>;
     template<typename... Ts>
     struct of {
-        using numeric_types = mp_list<Ts...>;
+        using numeric_types = types<Ts...>;
         template<template<typename...> typename... Ops>
         struct with
             : use_classes<
-                  apply_product<abstract_matrix_templates, mp_list<Ts...>>,
-                  apply_product<concrete_matrix_templates, mp_list<Ts...>>>,
+                  apply_product<abstract_matrix_templates, types<Ts...>>,
+                  apply_product<concrete_matrix_templates, types<Ts...>>>,
               definition_traits<Ops>::template fn<
                   abstract_matrix_templates, concrete_matrix_templates,
                   numeric_types>... {};
diff --git a/include/yorel/yomm2/core.hpp b/include/yorel/yomm2/core.hpp
index 57934bfd..ebf180fb 100644
--- a/include/yorel/yomm2/core.hpp
+++ b/include/yorel/yomm2/core.hpp
@@ -23,14 +23,6 @@ struct virtual_;
 template<class Class, class Policy>
 struct virtual_ptr;
 
-} // namespace yomm2
-} // namespace yorel
-
-#include <yorel/yomm2/detail.hpp>
-
-namespace yorel {
-namespace yomm2 {
-
 // -----------------------------------------------------------------------------
 // Method
 
@@ -41,7 +33,7 @@ template<typename Key, typename R, class Policy, typename... A>
 struct method<Key, R(A...), Policy> : detail::method_info {
     using self_type = method;
     using policy_type = Policy;
-    using declared_argument_types = boost::mp11::mp_list<A...>;
+    using declared_argument_types = detail::types<A...>;
     using call_argument_types = boost::mp11::mp_transform<
         detail::remove_virtual, declared_argument_types>;
     using virtual_argument_types =
@@ -190,7 +182,7 @@ struct class_declaration
           detail::get_policy<Classes...>, detail::remove_policy<Classes...>> {};
 
 template<class... Classes>
-struct class_declaration<boost::mp11::mp_list<Classes...>>
+struct class_declaration<detail::types<Classes...>>
     : detail::class_declaration_aux<
           detail::get_policy<Classes...>, detail::remove_policy<Classes...>> {};
 
@@ -453,9 +445,9 @@ method<Key, R(A...), Policy>::resolve(const ArgType&... args) const {
     std::uintptr_t pf;
 
     if constexpr (arity == 1) {
-        pf = resolve_uni<boost::mp11::mp_list<A...>, ArgType...>(args...);
+        pf = resolve_uni<types<A...>, ArgType...>(args...);
     } else {
-        pf = resolve_multi_first<0, boost::mp11::mp_list<A...>, ArgType...>(
+        pf = resolve_multi_first<0, types<A...>, ArgType...>(
             args...);
     }
 
diff --git a/include/yorel/yomm2/detail.hpp b/include/yorel/yomm2/detail.hpp
index 5884cc75..c0da834e 100644
--- a/include/yorel/yomm2/detail.hpp
+++ b/include/yorel/yomm2/detail.hpp
@@ -1,13 +1,10 @@
 #ifndef YOREL_YOMM2_DETAIL_HPP
 #define YOREL_YOMM2_DETAIL_HPP
 
-#include <boost/assert.hpp>
-#include <boost/dynamic_bitset.hpp>
-#include <boost/mp11/algorithm.hpp>
-#include <boost/mp11/bind.hpp>
-
 #include <yorel/yomm2/detail/static_list.hpp>
 
+#include <boost/assert.hpp>
+
 namespace yorel {
 namespace yomm2 {
 namespace detail {
@@ -25,7 +22,7 @@ template<class Policy, class TypeList>
 struct type_id_list;
 
 template<class Policy, typename... T>
-struct type_id_list<Policy, boost::mp11::mp_list<T...>> {
+struct type_id_list<Policy, types<T...>> {
     // If using deferred 'static_type', add an extra element in 'value',
     // default-initialized to zero, indicating the ids need to be resolved. Set
     // to 1 after this is done.
@@ -37,18 +34,18 @@ struct type_id_list<Policy, boost::mp11::mp_list<T...>> {
 };
 
 template<class Policy, typename... T>
-type_id type_id_list<Policy, boost::mp11::mp_list<T...>>::value[values] = {
+type_id type_id_list<Policy, types<T...>>::value[values] = {
     collect_static_type_id<Policy, T>()...};
 
 template<class Policy, typename... T>
-type_id* type_id_list<Policy, boost::mp11::mp_list<T...>>::begin = value;
+type_id* type_id_list<Policy, types<T...>>::begin = value;
 
 template<class Policy, typename... T>
-type_id* type_id_list<Policy, boost::mp11::mp_list<T...>>::end =
+type_id* type_id_list<Policy, types<T...>>::end =
     value + sizeof...(T);
 
 template<class Policy>
-struct type_id_list<Policy, boost::mp11::mp_list<>> {
+struct type_id_list<Policy, types<>> {
     static constexpr type_id* const begin = nullptr;
     static constexpr auto end = begin;
 };
@@ -70,12 +67,12 @@ struct parameter_type_list;
 
 template<typename ReturnType, typename... ParameterTypes>
 struct parameter_type_list<ReturnType(ParameterTypes...)> {
-    using type = boost::mp11::mp_list<ParameterTypes...>;
+    using type = types<ParameterTypes...>;
 };
 
 template<typename ReturnType, typename... ParameterTypes>
 struct parameter_type_list<ReturnType (*)(ParameterTypes...)> {
-    using type = boost::mp11::mp_list<ParameterTypes...>;
+    using type = types<ParameterTypes...>;
 };
 
 template<typename T>
@@ -139,14 +136,14 @@ template<class...>
 struct class_declaration_aux;
 
 template<class Policy, class Class, typename... Bases>
-struct class_declaration_aux<Policy, boost::mp11::mp_list<Class, Bases...>>
+struct class_declaration_aux<Policy, types<Class, Bases...>>
     : class_info {
     class_declaration_aux() {
         this->type = collect_static_type_id<Policy, Class>();
         this->first_base =
-            type_id_list<Policy, boost::mp11::mp_list<Bases...>>::begin;
+            type_id_list<Policy, types<Bases...>>::begin;
         this->last_base =
-            type_id_list<Policy, boost::mp11::mp_list<Bases...>>::end;
+            type_id_list<Policy, types<Bases...>>::end;
         Policy::classes.push_back(*this);
         this->is_abstract = std::is_abstract_v<Class>;
         this->static_vptr = &Policy::template static_vptr<Class>;
@@ -159,7 +156,7 @@ struct class_declaration_aux<Policy, boost::mp11::mp_list<Class, Bases...>>
 
 template<typename... Ts>
 constexpr auto arity =
-    boost::mp11::mp_count_if<boost::mp11::mp_list<Ts...>, is_virtual>::value;
+    boost::mp11::mp_count_if<types<Ts...>, is_virtual>::value;
 
 inline definition_info::~definition_info() {
     if (method) {
@@ -171,7 +168,7 @@ template<typename T>
 struct is_policy_aux : std::is_base_of<policy::abstract_policy, T> {};
 
 template<typename... T>
-struct is_policy_aux<boost::mp11::mp_list<T...>> : std::false_type {};
+struct is_policy_aux<types<T...>> : std::false_type {};
 
 template<typename T>
 constexpr bool is_policy = is_policy_aux<T>::value;
@@ -340,8 +337,8 @@ constexpr bool is_virtual_ptr = is_virtual_ptr_aux<T>::value;
 template<class... Ts>
 using virtual_ptr_class = std::conditional_t<
     sizeof...(Ts) == 2,
-    boost::mp11::mp_second<boost::mp11::mp_list<Ts..., void>>,
-    boost::mp11::mp_first<boost::mp11::mp_list<Ts...>>>;
+    boost::mp11::mp_second<types<Ts..., void>>,
+    boost::mp11::mp_first<types<Ts...>>>;
 
 template<class Policy, typename T>
 struct argument_traits {
@@ -500,19 +497,19 @@ inline uintptr_t get_tip(const T& arg) {
 
 template<typename... Classes>
 using get_policy = std::conditional_t<
-    is_policy<boost::mp11::mp_back<boost::mp11::mp_list<Classes...>>>,
-    boost::mp11::mp_back<boost::mp11::mp_list<Classes...>>,
+    is_policy<boost::mp11::mp_back<types<Classes...>>>,
+    boost::mp11::mp_back<types<Classes...>>,
     YOMM2_DEFAULT_POLICY>;
 
 template<typename... Classes>
 using remove_policy = std::conditional_t<
-    is_policy<boost::mp11::mp_back<boost::mp11::mp_list<Classes...>>>,
-    boost::mp11::mp_pop_back<boost::mp11::mp_list<Classes...>>,
-    boost::mp11::mp_list<Classes...>>;
+    is_policy<boost::mp11::mp_back<types<Classes...>>>,
+    boost::mp11::mp_pop_back<types<Classes...>>,
+    types<Classes...>>;
 
 template<class... Ts>
 using virtual_ptr_policy = std::conditional_t<
-    sizeof...(Ts) == 2, boost::mp11::mp_first<boost::mp11::mp_list<Ts...>>,
+    sizeof...(Ts) == 2, boost::mp11::mp_first<types<Ts...>>,
     YOMM2_DEFAULT_POLICY>;
 
 // -----------------------------------------------------------------------------
@@ -526,12 +523,12 @@ template<
     typename... SPEC_PARAM>
 struct thunk<
     Policy, BASE_RETURN(BASE_PARAM...), SPEC,
-    boost::mp11::mp_list<SPEC_PARAM...>> {
+    types<SPEC_PARAM...>> {
     static BASE_RETURN fn(remove_virtual<BASE_PARAM>... arg) {
         using base_type =
-            boost::mp11::mp_first<boost::mp11::mp_list<BASE_PARAM...>>;
+            boost::mp11::mp_first<types<BASE_PARAM...>>;
         using spec_type =
-            boost::mp11::mp_first<boost::mp11::mp_list<SPEC_PARAM...>>;
+            boost::mp11::mp_first<types<SPEC_PARAM...>>;
         return SPEC(
             argument_traits<Policy, BASE_PARAM>::template cast<SPEC_PARAM>(
                 remove_virtual<BASE_PARAM>(arg))...);
@@ -563,40 +560,40 @@ struct member_function_thunk<F, R (C::*)(Args...)> {
 // base. The direct and its direct and indirect proper bases are included. The
 // runtime will extract the direct proper bases. See unit tests for an example.
 template<typename... Cs>
-using inheritance_map = boost::mp11::mp_list<boost::mp11::mp_push_front<
+using inheritance_map = types<boost::mp11::mp_push_front<
     boost::mp11::mp_filter_q<
         boost::mp11::mp_bind_back<std::is_base_of, Cs>,
-        boost::mp11::mp_list<Cs...>>,
+        types<Cs...>>,
     Cs>...>;
 
 template<class Policy, class... Classes>
 struct use_classes_aux;
 
 template<class Policy, class... Classes>
-struct use_classes_aux<Policy, boost::mp11::mp_list<Classes...>> {
+struct use_classes_aux<Policy, types<Classes...>> {
     using type = boost::mp11::mp_apply<
         std::tuple,
         boost::mp11::mp_transform_q<
             boost::mp11::mp_bind_front<class_declaration_aux, Policy>,
             boost::mp11::mp_apply<
-                inheritance_map, boost::mp11::mp_list<Classes...>>>>;
+                inheritance_map, types<Classes...>>>>;
 };
 
 template<class Policy, class... Classes, class... MoreClassLists>
 struct use_classes_aux<
     Policy,
-    boost::mp11::mp_list<boost::mp11::mp_list<Classes...>, MoreClassLists...>>
+    types<types<Classes...>, MoreClassLists...>>
     : use_classes_aux<
           Policy,
           boost::mp11::mp_append<
-              boost::mp11::mp_list<Classes...>, MoreClassLists...>>
+              types<Classes...>, MoreClassLists...>>
 
 {};
 
 template<typename... Ts>
 using second_last = boost::mp11::mp_at_c<
-    boost::mp11::mp_list<Ts...>,
-    boost::mp11::mp_size<boost::mp11::mp_list<Ts...>>::value - 2>;
+    types<Ts...>,
+    boost::mp11::mp_size<types<Ts...>>::value - 2>;
 
 template<class... Classes>
 using use_classes_macro = typename std::conditional_t<
@@ -604,10 +601,10 @@ using use_classes_macro = typename std::conditional_t<
     use_classes_aux<
         second_last<Classes...>,
         boost::mp11::mp_pop_back<
-            boost::mp11::mp_pop_back<boost::mp11::mp_list<Classes...>>>>,
+            boost::mp11::mp_pop_back<types<Classes...>>>>,
     use_classes_aux<
-        boost::mp11::mp_back<boost::mp11::mp_list<Classes...>>,
-        boost::mp11::mp_pop_back<boost::mp11::mp_list<Classes...>>>>::type;
+        boost::mp11::mp_back<types<Classes...>>,
+        boost::mp11::mp_pop_back<types<Classes...>>>>::type;
 
 struct empty_base {};
 
diff --git a/include/yorel/yomm2/detail/compiler.hpp b/include/yorel/yomm2/detail/compiler.hpp
index 9137342d..2a3f6aa5 100644
--- a/include/yorel/yomm2/detail/compiler.hpp
+++ b/include/yorel/yomm2/detail/compiler.hpp
@@ -36,32 +36,32 @@ struct aggregate_reports;
 
 template<class... Reports, class Facet, class... MoreFacets>
 struct aggregate_reports<
-    boost::mp11::mp_list<Reports...>,
-    boost::mp11::mp_list<Facet, MoreFacets...>,
+    types<Reports...>,
+    types<Facet, MoreFacets...>,
     std::void_t<typename Facet::report>> {
     using type = typename aggregate_reports<
-        boost::mp11::mp_list<Reports..., typename Facet::report>,
-        boost::mp11::mp_list<MoreFacets...>>::type;
+        types<Reports..., typename Facet::report>,
+        types<MoreFacets...>>::type;
 };
 
 template<class... Reports, class Facet, class... MoreFacets, typename Void>
 struct aggregate_reports<
-    boost::mp11::mp_list<Reports...>,
-    boost::mp11::mp_list<Facet, MoreFacets...>, Void> {
+    types<Reports...>,
+    types<Facet, MoreFacets...>, Void> {
     using type = typename aggregate_reports<
-        boost::mp11::mp_list<Reports...>,
-        boost::mp11::mp_list<MoreFacets...>>::type;
+        types<Reports...>,
+        types<MoreFacets...>>::type;
 };
 
 template<class... Reports, typename Void>
 struct aggregate_reports<
-    boost::mp11::mp_list<Reports...>, boost::mp11::mp_list<>, Void> {
+    types<Reports...>, types<>, Void> {
     struct type : Reports... {};
 };
 
 template<class Policy>
 using report_type = typename aggregate_reports<
-    boost::mp11::mp_list<update_report>, typename Policy::facets>::type;
+    types<update_report>, typename Policy::facets>::type;
 
 inline void merge_into(boost::dynamic_bitset<>& a, boost::dynamic_bitset<>& b) {
     if (b.size() < a.size()) {
@@ -242,7 +242,7 @@ struct compiler : detail::generic_compiler {
     using type_index_type = decltype(Policy::type_index(0));
 
     typename detail::aggregate_reports<
-        boost::mp11::mp_list<update_report>, typename Policy::facets>::type
+        detail::types<update_report>, typename Policy::facets>::type
         report;
 
     std::unordered_map<type_index_type, class_*> class_map;
diff --git a/include/yorel/yomm2/detail/ostdstream.hpp b/include/yorel/yomm2/detail/ostdstream.hpp
index abfa87d2..ed989358 100644
--- a/include/yorel/yomm2/detail/ostdstream.hpp
+++ b/include/yorel/yomm2/detail/ostdstream.hpp
@@ -3,6 +3,8 @@
 
 #include <array>
 #include <cstdio>
+#include <charconv>
+#include <random>
 
 namespace yorel {
 namespace yomm2 {
diff --git a/include/yorel/yomm2/detail/trace.hpp b/include/yorel/yomm2/detail/trace.hpp
index 26384ef6..5a83b6bc 100644
--- a/include/yorel/yomm2/detail/trace.hpp
+++ b/include/yorel/yomm2/detail/trace.hpp
@@ -1,6 +1,8 @@
 #ifndef YOREL_YOMM2_DETAIL_TRACE_HPP
 #define YOREL_YOMM2_DETAIL_TRACE_HPP
 
+#include <boost/dynamic_bitset.hpp>
+
 namespace yorel {
 namespace yomm2 {
 namespace detail {
diff --git a/include/yorel/yomm2/detail/types.hpp b/include/yorel/yomm2/detail/types.hpp
new file mode 100644
index 00000000..fefb7bb5
--- /dev/null
+++ b/include/yorel/yomm2/detail/types.hpp
@@ -0,0 +1,40 @@
+#ifndef YOREL_YOMM2_DETAIL_TYPES_HPP
+#define YOREL_YOMM2_DETAIL_TYPES_HPP
+
+#include <cstdint>
+#include <limits>
+
+#if defined(YOMM2_SHARED)
+#if defined(_MSC_VER)
+#if !defined(yOMM2_API_msc)
+#define yOMM2_API_msc __declspec(dllimport)
+#endif
+#endif
+#endif
+
+#if !defined(yOMM2_API_gcc)
+#define yOMM2_API_gcc
+#endif
+
+#if !defined(yOMM2_API_msc)
+#define yOMM2_API_msc
+#endif
+
+#define yOMM2_API yOMM2_API_gcc yOMM2_API_msc
+
+namespace yorel {
+namespace yomm2 {
+
+using type_id = std::uintptr_t;
+constexpr type_id invalid_type = (std::numeric_limits<type_id>::max)();
+
+namespace detail {
+
+template<typename... Types>
+struct types;
+
+}
+} // namespace yomm2
+} // namespace yorel
+
+#endif
diff --git a/include/yorel/yomm2/policies/basic_error_output.hpp b/include/yorel/yomm2/policies/basic_error_output.hpp
new file mode 100644
index 00000000..9cdb8bbe
--- /dev/null
+++ b/include/yorel/yomm2/policies/basic_error_output.hpp
@@ -0,0 +1,29 @@
+
+// Copyright (c) 2018-2024 Jean-Louis Leroy
+// 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)
+
+#ifndef YOREL_YOMM2_POLICY_BASIC_ERROR_OUTPUT_HPP
+#define YOREL_YOMM2_POLICY_BASIC_ERROR_OUTPUT_HPP
+
+#include <yorel/yomm2/policies/core.hpp>
+#include <yorel/yomm2/detail/ostdstream.hpp>
+
+namespace yorel {
+namespace yomm2 {
+namespace policy {
+
+template<class Policy, typename Stream = detail::ostderr>
+struct yOMM2_API_gcc basic_error_output : virtual error_output {
+    static Stream error_stream;
+};
+
+template<class Policy, typename Stream>
+Stream basic_error_output<Policy, Stream>::error_stream;
+
+}
+}
+}
+
+#endif
diff --git a/include/yorel/yomm2/policies/basic_indirect_vptr.hpp b/include/yorel/yomm2/policies/basic_indirect_vptr.hpp
new file mode 100644
index 00000000..2a872ba9
--- /dev/null
+++ b/include/yorel/yomm2/policies/basic_indirect_vptr.hpp
@@ -0,0 +1,29 @@
+
+// Copyright (c) 2018-2024 Jean-Louis Leroy
+// 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)
+
+#ifndef YOREL_YOMM2_POLICY_BASIC_INDIRECT_VPTR_HPP
+#define YOREL_YOMM2_POLICY_BASIC_INDIRECT_VPTR_HPP
+
+#include <yorel/yomm2/policies/core.hpp>
+
+namespace yorel {
+namespace yomm2 {
+namespace policy {
+
+template<class Policy>
+struct yOMM2_API_gcc basic_indirect_vptr : virtual indirect_vptr {
+    static std::vector<std::uintptr_t const* const*> indirect_vptrs;
+};
+
+template<class Policy>
+std::vector<std::uintptr_t const* const*>
+    basic_indirect_vptr<Policy>::indirect_vptrs;
+
+}
+}
+}
+
+#endif
diff --git a/include/yorel/yomm2/policies/basic_trace_output.hpp b/include/yorel/yomm2/policies/basic_trace_output.hpp
new file mode 100644
index 00000000..3d8deda1
--- /dev/null
+++ b/include/yorel/yomm2/policies/basic_trace_output.hpp
@@ -0,0 +1,35 @@
+
+// Copyright (c) 2018-2024 Jean-Louis Leroy
+// 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)
+
+#ifndef YOREL_YOMM2_POLICY_BASIC_TRACE_OUTPUT_HPP
+#define YOREL_YOMM2_POLICY_BASIC_TRACE_OUTPUT_HPP
+
+#include <yorel/yomm2/policies/core.hpp>
+
+namespace yorel {
+namespace yomm2 {
+namespace policy {
+
+template<class Policy, typename Stream = detail::ostderr>
+struct yOMM2_API_gcc basic_trace_output : virtual trace_output {
+    static Stream trace_stream;
+    static bool trace_enabled;
+};
+
+template<class Policy, typename Stream>
+Stream basic_trace_output<Policy, Stream>::trace_stream;
+
+template<class Policy, typename Stream>
+bool basic_trace_output<Policy, Stream>::trace_enabled([]() {
+    auto env = getenv("YOMM2_TRACE");
+    return env && *env++ == '1' && *env++ == 0;
+}());
+
+}
+}
+}
+
+#endif
diff --git a/include/yorel/yomm2/policies/core.hpp b/include/yorel/yomm2/policies/core.hpp
index 549d4799..a0fd74ea 100644
--- a/include/yorel/yomm2/policies/core.hpp
+++ b/include/yorel/yomm2/policies/core.hpp
@@ -1,38 +1,21 @@
+// Copyright (c) 2018-2024 Jean-Louis Leroy
+// 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)
+
 #ifndef YOREL_YOMM2_POLICIES_CORE_HPP
 #define YOREL_YOMM2_POLICIES_CORE_HPP
 
+#include <yorel/yomm2/detail/types.hpp>
 #include <yorel/yomm2/detail/static_list.hpp>
 
-#if defined(YOMM2_SHARED)
-#if defined(_MSC_VER)
-#if !defined(yOMM2_API_msc)
-#define yOMM2_API_msc __declspec(dllimport)
-#endif
-#endif
-#endif
+#include <boost/mp11/algorithm.hpp>
+#include <boost/mp11/bind.hpp>
 
-#if !defined(yOMM2_API_gcc)
-#define yOMM2_API_gcc
-#endif
-
-#if !defined(yOMM2_API_msc)
-#define yOMM2_API_msc
-#endif
-
-#define yOMM2_API yOMM2_API_gcc yOMM2_API_msc
-
-// -----------------------------------------------------------------------------
-// Forward declarations needed by "detail.hpp"
+#include <string_view>
 
 namespace yorel {
 namespace yomm2 {
-
-struct context;
-struct catalog;
-
-using type_id = std::uintptr_t;
-constexpr type_id invalid_type = (std::numeric_limits<type_id>::max)();
-
 namespace detail {
 
 // -----------------------------------------------------------------------------
@@ -207,6 +190,75 @@ detail::method_catalog basic_domain<Key>::methods;
 template<class Key>
 std::vector<std::uintptr_t> basic_domain<Key>::dispatch_data;
 
+template<typename Policy, class Facet>
+struct rebind_facet {
+    using type = Facet;
+};
+
+template<
+    typename NewPolicy, typename OldPolicy,
+    template<typename...> class GenericFacet, typename... Args>
+struct rebind_facet<NewPolicy, GenericFacet<OldPolicy, Args...>> {
+    using type = GenericFacet<NewPolicy, Args...>;
+};
+
+template<class Policy, class... Facets>
+struct basic_policy : virtual abstract_policy,
+                      virtual basic_domain<Policy>,
+                      virtual Facets... {
+    using facets = detail::types<Facets...>;
+
+    template<class Facet>
+    static constexpr bool has_facet = std::is_base_of_v<Facet, Policy>;
+
+    template<class Facet>
+    using use_facet = boost::mp11::mp_first<boost::mp11::mp_filter_q<
+        boost::mp11::mp_bind_front_q<
+            boost::mp11::mp_quote_trait<std::is_base_of>, Facet>,
+        facets>>;
+
+    template<class NewPolicy>
+    using rebind = basic_policy<
+        NewPolicy, typename rebind_facet<NewPolicy, Facets>::type...>;
+
+    template<class Base, class Facet>
+    using replace = boost::mp11::mp_apply<
+        basic_policy,
+        boost::mp11::mp_push_front<
+            boost::mp11::mp_replace_if_q<
+                facets,
+                boost::mp11::mp_bind_front_q<
+                    boost::mp11::mp_quote_trait<std::is_base_of>, Base>,
+                Facet>,
+            Policy>>;
+
+    template<class Base>
+    using remove = boost::mp11::mp_apply<
+        basic_policy,
+        boost::mp11::mp_push_front<
+            boost::mp11::mp_remove_if_q<
+                facets,
+                boost::mp11::mp_bind_front_q<
+                    boost::mp11::mp_quote_trait<std::is_base_of>, Base>>,
+            Policy>>;
+};
+
+template<class Policy, class Facet>
+constexpr bool has_facet = Policy::template has_facet<Facet>;
+
+struct rtti {
+    static type_id type_index(type_id type) {
+        return type;
+    }
+
+    template<typename Stream>
+    static void type_name(type_id type, Stream& stream) {
+        stream << "type_id(" << type << ")";
+    }
+};
+
+struct deferred_static_rtti : virtual rtti {};
+
 } // namespace policy
 
 } // namespace yomm2
diff --git a/include/yorel/yomm2/policies/fast_perfect_hash.hpp b/include/yorel/yomm2/policies/fast_perfect_hash.hpp
new file mode 100644
index 00000000..c4ee7c62
--- /dev/null
+++ b/include/yorel/yomm2/policies/fast_perfect_hash.hpp
@@ -0,0 +1,202 @@
+
+// Copyright (c) 2018-2024 Jean-Louis Leroy
+// 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)
+
+#ifndef YOREL_YOMM2_POLICY_FAST_PERFECT_HASH_HPP
+#define YOREL_YOMM2_POLICY_FAST_PERFECT_HASH_HPP
+
+#include <random>
+
+#include <yorel/yomm2/policies/core.hpp>
+
+namespace yorel {
+namespace yomm2 {
+namespace policy {
+
+template<class Policy>
+struct yOMM2_API_gcc fast_perfect_hash : virtual type_hash {
+    struct report {
+        std::size_t method_table_size, dispatch_table_size;
+        std::size_t hash_search_attempts;
+    };
+
+    static type_id hash_mult;
+    static std::size_t hash_shift;
+    static std::size_t hash_length;
+    static std::size_t hash_min;
+    static std::size_t hash_max;
+
+#ifdef _MSC_VER
+    __forceinline
+#endif
+        static type_id
+        hash_type_id(type_id type) {
+        return (hash_mult * type) >> hash_shift;
+    }
+
+    template<typename ForwardIterator>
+    static void hash_initialize(ForwardIterator first, ForwardIterator last) {
+        std::vector<type_id> buckets;
+        hash_initialize(first, last, buckets);
+    }
+
+    template<typename ForwardIterator>
+    static void hash_initialize(
+        ForwardIterator first, ForwardIterator last,
+        std::vector<type_id>& buckets);
+};
+
+template<class Policy>
+template<typename ForwardIterator>
+void fast_perfect_hash<Policy>::hash_initialize(
+    ForwardIterator first, ForwardIterator last,
+    std::vector<type_id>& buckets) {
+    using namespace policy;
+
+    constexpr bool trace_enabled = Policy::template has_facet<trace_output>;
+    const auto N = std::distance(first, last);
+
+    if constexpr (trace_enabled) {
+        if (Policy::trace_enabled) {
+            Policy::trace_stream << "Finding hash factor for " << N
+                                 << " types\n";
+        }
+    }
+
+    std::default_random_engine rnd(13081963);
+    std::size_t total_attempts = 0;
+    std::size_t M = 1;
+
+    for (auto size = N * 5 / 4; size >>= 1;) {
+        ++M;
+    }
+
+    std::uniform_int_distribution<type_id> uniform_dist;
+
+    for (std::size_t pass = 0; pass < 4; ++pass, ++M) {
+        hash_shift = 8 * sizeof(type_id) - M;
+        auto hash_size = 1 << M;
+
+        if constexpr (trace_enabled) {
+            if (Policy::trace_enabled) {
+                Policy::trace_stream << "  trying with M = " << M << ", "
+                                     << hash_size << " buckets\n";
+            }
+        }
+
+        bool found = false;
+        std::size_t attempts = 0;
+        buckets.resize(hash_size);
+        hash_length = 0;
+
+        while (!found && attempts < 100000) {
+            std::fill(buckets.begin(), buckets.end(), static_cast<type_id>(-1));
+            ++attempts;
+            ++total_attempts;
+            found = true;
+            hash_mult = uniform_dist(rnd) | 1;
+
+            for (auto iter = first; iter != last; ++iter) {
+                for (auto type_iter = iter->type_id_begin();
+                     type_iter != iter->type_id_end(); ++type_iter) {
+                    auto type = *type_iter;
+                    auto index = (type * hash_mult) >> hash_shift;
+                    hash_min = (std::min)(hash_min, index);
+                    hash_max = (std::max)(hash_max, index);
+
+                    if (buckets[index] != static_cast<type_id>(-1)) {
+                        found = false;
+                        break;
+                    }
+
+                    buckets[index] = type;
+                }
+            }
+        }
+
+        // metrics.hash_search_attempts = total_attempts;
+        // metrics.hash_search_time =
+        //     std::chrono::steady_clock::now() - start_time;
+        // metrics.hash_table_size = hash_size;
+
+        if (found) {
+            hash_length = hash_max + 1;
+
+            if constexpr (trace_enabled) {
+                if (Policy::trace_enabled) {
+                    Policy::trace_stream << "  found " << hash_mult << " after "
+                                         << total_attempts
+                                         << " attempts; min = " << hash_min
+                                         << ", max = " << hash_max << "\n";
+                }
+            }
+
+            return;
+        }
+    }
+
+    hash_search_error error;
+    error.attempts = total_attempts;
+    // error.duration = std::chrono::steady_clock::now() - start_time;
+    error.buckets = 1 << M;
+
+    if constexpr (has_facet<Policy, error_handler>) {
+        Policy::error(error_type(error));
+    }
+
+    abort();
+}
+
+template<class Policy>
+type_id fast_perfect_hash<Policy>::hash_mult;
+template<class Policy>
+std::size_t fast_perfect_hash<Policy>::hash_shift;
+template<class Policy>
+std::size_t fast_perfect_hash<Policy>::hash_length;
+template<class Policy>
+std::size_t fast_perfect_hash<Policy>::hash_min;
+template<class Policy>
+std::size_t fast_perfect_hash<Policy>::hash_max;
+
+template<class Policy>
+struct yOMM2_API_gcc checked_perfect_hash : virtual fast_perfect_hash<Policy>,
+                                            virtual runtime_checks {
+    static std::vector<type_id> control;
+
+    static type_id hash_type_id(type_id type) {
+        auto index = fast_perfect_hash<Policy>::hash_type_id(type);
+
+        if (index >= fast_perfect_hash<Policy>::hash_length ||
+            control[index] != type) {
+            using namespace policy;
+
+            if constexpr (Policy::template has_facet<error_handler>) {
+                unknown_class_error error;
+                error.context = unknown_class_error::update;
+                error.type = type;
+                Policy::error(error);
+            }
+
+            abort();
+        }
+
+        return index;
+    }
+
+    template<typename ForwardIterator>
+    static void hash_initialize(ForwardIterator first, ForwardIterator last) {
+        fast_perfect_hash<Policy>::hash_initialize(first, last, control);
+        control.resize(fast_perfect_hash<Policy>::hash_length);
+    }
+};
+
+template<class Policy>
+std::vector<type_id> checked_perfect_hash<Policy>::control;
+
+}
+}
+}
+
+#endif
diff --git a/include/yorel/yomm2/policies/minimal_rtti.hpp b/include/yorel/yomm2/policies/minimal_rtti.hpp
new file mode 100644
index 00000000..8cfebcac
--- /dev/null
+++ b/include/yorel/yomm2/policies/minimal_rtti.hpp
@@ -0,0 +1,28 @@
+
+// Copyright (c) 2018-2024 Jean-Louis Leroy
+// 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)
+
+#ifndef YOREL_YOMM2_POLICY_MINIMAL_RTTI_HPP
+#define YOREL_YOMM2_POLICY_MINIMAL_RTTI_HPP
+
+#include <yorel/yomm2/policies/core.hpp>
+
+namespace yorel {
+namespace yomm2 {
+namespace policy {
+
+struct minimal_rtti : virtual rtti {
+    template<typename T>
+    static type_id static_type() {
+        static char id;
+        return reinterpret_cast<type_id>(&id);
+    }
+};
+
+}
+}
+}
+
+#endif
diff --git a/include/yorel/yomm2/policies/std_rtti.hpp b/include/yorel/yomm2/policies/std_rtti.hpp
new file mode 100644
index 00000000..95309d59
--- /dev/null
+++ b/include/yorel/yomm2/policies/std_rtti.hpp
@@ -0,0 +1,57 @@
+
+// Copyright (c) 2018-2024 Jean-Louis Leroy
+// 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)
+
+#ifndef YOREL_YOMM2_POLICY_STD_RTTI_HPP
+#define YOREL_YOMM2_POLICY_STD_RTTI_HPP
+
+#include <yorel/yomm2/policies/core.hpp>
+
+#ifndef BOOST_NO_RTTI
+#include <typeindex>
+#include <typeinfo>
+#include <boost/core/demangle.hpp>
+#endif
+
+namespace yorel {
+namespace yomm2 {
+namespace policy {
+
+struct std_rtti : virtual rtti {
+#ifndef BOOST_NO_RTTI
+    template<class Class>
+    static type_id static_type() {
+        auto tip = &typeid(Class);
+        return reinterpret_cast<type_id>(tip);
+    }
+
+    template<class Class>
+    static type_id dynamic_type(const Class& obj) {
+        auto tip = &typeid(obj);
+        return reinterpret_cast<type_id>(tip);
+    }
+
+    template<typename Stream>
+    static void type_name(type_id type, Stream& stream) {
+        stream << boost::core::demangle(
+            reinterpret_cast<const std::type_info*>(type)->name());
+    }
+
+    static std::type_index type_index(type_id type) {
+        return std::type_index(*reinterpret_cast<const std::type_info*>(type));
+    }
+
+    template<typename D, typename B>
+    static D dynamic_cast_ref(B&& obj) {
+        return dynamic_cast<D>(obj);
+    }
+#endif
+};
+
+}
+}
+}
+
+#endif
diff --git a/include/yorel/yomm2/policies/throw_error.hpp b/include/yorel/yomm2/policies/throw_error.hpp
new file mode 100644
index 00000000..20c6a004
--- /dev/null
+++ b/include/yorel/yomm2/policies/throw_error.hpp
@@ -0,0 +1,25 @@
+
+// Copyright (c) 2018-2024 Jean-Louis Leroy
+// 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)
+
+#ifndef YOREL_YOMM2_POLICY_THROW_ERROR_HPP
+#define YOREL_YOMM2_POLICY_THROW_ERROR_HPP
+
+#include <yorel/yomm2/policies/core.hpp>
+
+namespace yorel {
+namespace yomm2 {
+namespace policy {
+struct yOMM2_API_gcc throw_error : virtual error_handler {
+    static void error(const error_type& error_v) {
+        std::visit([](auto&& arg) { throw arg; }, error_v);
+    }
+};
+
+}
+}
+}
+
+#endif
diff --git a/include/yorel/yomm2/policies/vectored_error.hpp b/include/yorel/yomm2/policies/vectored_error.hpp
new file mode 100644
index 00000000..6da609eb
--- /dev/null
+++ b/include/yorel/yomm2/policies/vectored_error.hpp
@@ -0,0 +1,71 @@
+
+// Copyright (c) 2018-2024 Jean-Louis Leroy
+// 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)
+
+#ifndef YOREL_YOMM2_POLICY_VECTORED_ERROR_HPP
+#define YOREL_YOMM2_POLICY_VECTORED_ERROR_HPP
+
+#include <yorel/yomm2/policies/core.hpp>
+#include <yorel/yomm2/detail/range.hpp>
+
+namespace yorel {
+namespace yomm2 {
+namespace policy {
+
+template<class Policy, typename DefaultHandlerProvider = void>
+struct yOMM2_API_gcc vectored_error : virtual error_handler {
+    static error_handler_type error;
+
+    static void default_error_handler(const error_type& error_v) {
+        using namespace detail;
+        using namespace policy;
+
+        if constexpr (Policy::template has_facet<error_output>) {
+            if (auto error = std::get_if<resolution_error>(&error_v)) {
+                const char* explanation[] = {
+                    "no applicable definition", "ambiguous call"};
+                Policy::error_stream
+                    << explanation
+                           [error->status - resolution_error::no_definition]
+                    << " for " << error->method_name << "(";
+                auto comma = "";
+
+                for (auto ti :
+                     range{error->types, error->types + error->arity}) {
+                    Policy::error_stream << comma;
+                    Policy::type_name(ti, Policy::error_stream);
+                    comma = ", ";
+                }
+
+                Policy::error_stream << ")\n";
+            } else if (
+                auto error = std::get_if<unknown_class_error>(&error_v)) {
+                Policy::error_stream << "unknown class ";
+                Policy::type_name(error->type, Policy::error_stream);
+                Policy::error_stream << "\n";
+            } else if (auto error = std::get_if<method_table_error>(&error_v)) {
+                Policy::error_stream << "invalid method table for ";
+                Policy::type_name(error->type, Policy::error_stream);
+                Policy::error_stream << "\n";
+            } else if (auto error = std::get_if<hash_search_error>(&error_v)) {
+                Policy::error_stream << "could not find hash factors after "
+                                     << error->attempts << "s using "
+                                     << error->buckets << " buckets\n";
+            }
+        }
+    }
+};
+
+template<class Policy, typename DefaultHandlerProvider>
+error_handler_type vectored_error<Policy, DefaultHandlerProvider>::error =
+    std::conditional_t<
+        std::is_same_v<DefaultHandlerProvider, void>, vectored_error<Policy>,
+        DefaultHandlerProvider>::default_error_handler;
+
+}
+}
+}
+
+#endif
diff --git a/include/yorel/yomm2/policies/vptr_map.hpp b/include/yorel/yomm2/policies/vptr_map.hpp
new file mode 100644
index 00000000..e5b60435
--- /dev/null
+++ b/include/yorel/yomm2/policies/vptr_map.hpp
@@ -0,0 +1,45 @@
+
+// Copyright (c) 2018-2024 Jean-Louis Leroy
+// 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)
+
+#ifndef YOREL_YOMM2_POLICY_VPTR_MAP_HPP
+#define YOREL_YOMM2_POLICY_VPTR_MAP_HPP
+
+#include <yorel/yomm2/policies/core.hpp>
+
+namespace yorel {
+namespace yomm2 {
+namespace policy {
+
+template<
+    class Policy,
+    class Map = std::unordered_map<type_id, const std::uintptr_t*>>
+struct yOMM2_API_gcc vptr_map : virtual external_vptr {
+    static Map vptrs;
+
+    template<typename ForwardIterator>
+    static void publish_vptrs(ForwardIterator first, ForwardIterator last) {
+        for (auto iter = first; iter != last; ++iter) {
+            for (auto type_iter = iter->type_id_begin();
+                 type_iter != iter->type_id_end(); ++type_iter) {
+                vptrs[*type_iter] = iter->vptr();
+            }
+        }
+    }
+
+    template<class Class>
+    static auto dynamic_vptr(const Class& arg) {
+        return vptrs.find(Policy::dynamic_type(arg))->second;
+    }
+};
+
+template<class Policy, class Map>
+Map vptr_map<Policy, Map>::vptrs;
+
+}
+}
+}
+
+#endif
diff --git a/include/yorel/yomm2/policies/vptr_vector.hpp b/include/yorel/yomm2/policies/vptr_vector.hpp
new file mode 100644
index 00000000..5689396c
--- /dev/null
+++ b/include/yorel/yomm2/policies/vptr_vector.hpp
@@ -0,0 +1,85 @@
+
+// Copyright (c) 2018-2024 Jean-Louis Leroy
+// 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)
+
+#ifndef YOREL_YOMM2_POLICY_VPTR_VECTOR_HPP
+#define YOREL_YOMM2_POLICY_VPTR_VECTOR_HPP
+
+#include <yorel/yomm2/policies/core.hpp>
+
+namespace yorel {
+namespace yomm2 {
+namespace policy {
+
+template<class Policy>
+struct yOMM2_API_gcc vptr_vector : virtual external_vptr {
+    static std::vector<const std::uintptr_t*> vptrs;
+
+    template<typename ForwardIterator>
+    static void publish_vptrs(ForwardIterator first, ForwardIterator last) {
+        using namespace policy;
+
+        std::size_t size;
+
+        if constexpr (has_facet<Policy, type_hash>) {
+            Policy::hash_initialize(first, last);
+            size = Policy::hash_length;
+        } else {
+            size = 0;
+
+            for (auto iter = first; iter != last; ++iter) {
+                for (auto type_iter = iter->type_id_begin();
+                     type_iter != iter->type_id_end(); ++type_iter) {
+                    size = (std::max)(size, *type_iter);
+                }
+            }
+
+            ++size;
+        }
+
+        vptrs.resize(size);
+
+        if constexpr (has_facet<Policy, indirect_vptr>) {
+            Policy::indirect_vptrs.resize(size);
+        }
+
+        for (auto iter = first; iter != last; ++iter) {
+            for (auto type_iter = iter->type_id_begin();
+                 type_iter != iter->type_id_end(); ++type_iter) {
+                auto index = *type_iter;
+
+                if constexpr (has_facet<Policy, type_hash>) {
+                    index = Policy::hash_type_id(index);
+                }
+
+                vptrs[index] = iter->vptr();
+
+                if constexpr (has_facet<Policy, indirect_vptr>) {
+                    Policy::indirect_vptrs[index] = iter->indirect_vptr();
+                }
+            }
+        }
+    }
+
+    template<class Class>
+    static const std::uintptr_t* dynamic_vptr(const Class& arg) {
+        auto index = Policy::dynamic_type(arg);
+
+        if constexpr (has_facet<Policy, type_hash>) {
+            index = Policy::hash_type_id(index);
+        }
+
+        return vptrs[index];
+    }
+};
+
+template<class Policy>
+std::vector<const std::uintptr_t*> vptr_vector<Policy>::vptrs;
+
+}
+}
+}
+
+#endif
diff --git a/include/yorel/yomm2/policy.hpp b/include/yorel/yomm2/policy.hpp
index 614961b8..73779dd9 100644
--- a/include/yorel/yomm2/policy.hpp
+++ b/include/yorel/yomm2/policy.hpp
@@ -1,505 +1,36 @@
+// Copyright (c) 2018-2024 Jean-Louis Leroy
+// 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)
+
 #ifndef YOREL_YOMM2_POLICY_HPP
 #define YOREL_YOMM2_POLICY_HPP
 
-#include <charconv>
-#include <cstdint>
 #include <functional>
-#include <limits>
 #include <memory>
-#include <random>
-#include <string_view>
-#include <unordered_map>
 #include <variant>
 #include <vector>
 
-#ifndef BOOST_NO_RTTI
-#include <typeindex>
-#include <typeinfo>
-#include <boost/core/demangle.hpp>
-#endif
+#include <yorel/yomm2/policies/core.hpp>
 
-#include <boost/mp11.hpp>
+#include <yorel/yomm2/policies/minimal_rtti.hpp>
+#include <yorel/yomm2/policies/std_rtti.hpp>
+#include <yorel/yomm2/policies/vptr_vector.hpp>
+#include <yorel/yomm2/policies/vptr_map.hpp>
+#include <yorel/yomm2/policies/basic_indirect_vptr.hpp>
+#include <yorel/yomm2/policies/basic_error_output.hpp>
+#include <yorel/yomm2/policies/basic_trace_output.hpp>
+#include <yorel/yomm2/policies/fast_perfect_hash.hpp>
+#include <yorel/yomm2/policies/vectored_error.hpp>
 
-#include <yorel/yomm2/policies/core.hpp>
-#include <yorel/yomm2/detail/ostdstream.hpp>
-#include <yorel/yomm2/detail/range.hpp>
+#ifndef BOOST_NO_EXCEPTIONS
+#include <yorel/yomm2/policies/throw_error.hpp>
+#endif
 
 namespace yorel {
 namespace yomm2 {
 namespace policy {
 
-struct rtti {
-    static type_id type_index(type_id type) {
-        return type;
-    }
-
-    template<typename Stream>
-    static void type_name(type_id type, Stream& stream) {
-        stream << "type_id(" << type << ")";
-    }
-};
-
-struct minimal_rtti : virtual rtti {
-    template<typename T>
-    static type_id static_type() {
-        static char id;
-        return reinterpret_cast<type_id>(&id);
-    }
-};
-
-struct std_rtti : virtual rtti {
-#ifndef BOOST_NO_RTTI
-    template<class Class>
-    static type_id static_type() {
-        auto tip = &typeid(Class);
-        return reinterpret_cast<type_id>(tip);
-    }
-
-    template<class Class>
-    static type_id dynamic_type(const Class& obj) {
-        auto tip = &typeid(obj);
-        return reinterpret_cast<type_id>(tip);
-    }
-
-    template<typename Stream>
-    static void type_name(type_id type, Stream& stream) {
-        stream << boost::core::demangle(
-            reinterpret_cast<const std::type_info*>(type)->name());
-    }
-
-    static std::type_index type_index(type_id type) {
-        return std::type_index(*reinterpret_cast<const std::type_info*>(type));
-    }
-
-    template<typename D, typename B>
-    static D dynamic_cast_ref(B&& obj) {
-        return dynamic_cast<D>(obj);
-    }
-#endif
-};
-
-struct deferred_static_rtti : virtual rtti {};
-
-template<typename T>
-constexpr bool implemented = !std::is_same_v<T, void>;
-
-template<typename Policy, class Facet>
-struct rebind_facet {
-    using type = Facet;
-};
-
-template<
-    typename NewPolicy, typename OldPolicy,
-    template<typename...> class GenericFacet, typename... Args>
-struct rebind_facet<NewPolicy, GenericFacet<OldPolicy, Args...>> {
-    using type = GenericFacet<NewPolicy, Args...>;
-};
-
-template<class Policy, class... Facets>
-struct basic_policy : virtual abstract_policy,
-                      virtual basic_domain<Policy>,
-                      virtual Facets... {
-    using facets = boost::mp11::mp_list<Facets...>;
-
-    template<class Facet>
-    static constexpr bool has_facet = std::is_base_of_v<Facet, Policy>;
-
-    template<class Facet>
-    using use_facet = boost::mp11::mp_first<boost::mp11::mp_filter_q<
-        boost::mp11::mp_bind_front_q<
-            boost::mp11::mp_quote_trait<std::is_base_of>, Facet>,
-        facets>>;
-
-    template<class NewPolicy>
-    using rebind = basic_policy<
-        NewPolicy, typename rebind_facet<NewPolicy, Facets>::type...>;
-
-    template<class Base, class Facet>
-    using replace = boost::mp11::mp_apply<
-        basic_policy,
-        boost::mp11::mp_push_front<
-            boost::mp11::mp_replace_if_q<
-                facets,
-                boost::mp11::mp_bind_front_q<
-                    boost::mp11::mp_quote_trait<std::is_base_of>, Base>,
-                Facet>,
-            Policy>>;
-
-    template<class Base>
-    using remove = boost::mp11::mp_apply<
-        basic_policy,
-        boost::mp11::mp_push_front<
-            boost::mp11::mp_remove_if_q<
-                facets,
-                boost::mp11::mp_bind_front_q<
-                    boost::mp11::mp_quote_trait<std::is_base_of>, Base>>,
-            Policy>>;
-};
-
-template<class Policy, class Facet>
-constexpr bool has_facet = Policy::template has_facet<Facet>;
-
-template<class Policy>
-struct yOMM2_API_gcc vptr_vector : virtual external_vptr {
-    static std::vector<const std::uintptr_t*> vptrs;
-
-    template<typename ForwardIterator>
-    static void publish_vptrs(ForwardIterator first, ForwardIterator last) {
-        using namespace policy;
-
-        std::size_t size;
-
-        if constexpr (has_facet<Policy, type_hash>) {
-            Policy::hash_initialize(first, last);
-            size = Policy::hash_length;
-        } else {
-            size = 0;
-
-            for (auto iter = first; iter != last; ++iter) {
-                for (auto type_iter = iter->type_id_begin();
-                     type_iter != iter->type_id_end(); ++type_iter) {
-                    size = (std::max)(size, *type_iter);
-                }
-            }
-
-            ++size;
-        }
-
-        vptrs.resize(size);
-
-        if constexpr (has_facet<Policy, indirect_vptr>) {
-            Policy::indirect_vptrs.resize(size);
-        }
-
-        for (auto iter = first; iter != last; ++iter) {
-            for (auto type_iter = iter->type_id_begin();
-                 type_iter != iter->type_id_end(); ++type_iter) {
-                auto index = *type_iter;
-
-                if constexpr (has_facet<Policy, type_hash>) {
-                    index = Policy::hash_type_id(index);
-                }
-
-                vptrs[index] = iter->vptr();
-
-                if constexpr (has_facet<Policy, indirect_vptr>) {
-                    Policy::indirect_vptrs[index] = iter->indirect_vptr();
-                }
-            }
-        }
-    }
-
-    template<class Class>
-    static const std::uintptr_t* dynamic_vptr(const Class& arg) {
-        auto index = Policy::dynamic_type(arg);
-
-        if constexpr (has_facet<Policy, type_hash>) {
-            index = Policy::hash_type_id(index);
-        }
-
-        return vptrs[index];
-    }
-};
-
-template<class Policy>
-std::vector<const std::uintptr_t*> vptr_vector<Policy>::vptrs;
-
-template<
-    class Policy,
-    class Map = std::unordered_map<type_id, const std::uintptr_t*>>
-struct yOMM2_API_gcc vptr_map : virtual external_vptr {
-    static Map vptrs;
-
-    template<typename ForwardIterator>
-    static void publish_vptrs(ForwardIterator first, ForwardIterator last) {
-        for (auto iter = first; iter != last; ++iter) {
-            for (auto type_iter = iter->type_id_begin();
-                 type_iter != iter->type_id_end(); ++type_iter) {
-                vptrs[*type_iter] = iter->vptr();
-            }
-        }
-    }
-
-    template<class Class>
-    static auto dynamic_vptr(const Class& arg) {
-        return vptrs.find(Policy::dynamic_type(arg))->second;
-    }
-};
-
-template<class Policy, class Map>
-Map vptr_map<Policy, Map>::vptrs;
-
-template<class Policy>
-struct yOMM2_API_gcc basic_indirect_vptr : virtual indirect_vptr {
-    static std::vector<std::uintptr_t const* const*> indirect_vptrs;
-};
-
-template<class Policy>
-std::vector<std::uintptr_t const* const*>
-    basic_indirect_vptr<Policy>::indirect_vptrs;
-
-template<class Policy, typename Stream = detail::ostderr>
-struct yOMM2_API_gcc basic_error_output : virtual error_output {
-    static Stream error_stream;
-};
-
-template<class Policy, typename Stream>
-Stream basic_error_output<Policy, Stream>::error_stream;
-
-template<class Policy, typename Stream = detail::ostderr>
-struct yOMM2_API_gcc basic_trace_output : virtual trace_output {
-    static Stream trace_stream;
-    static bool trace_enabled;
-};
-
-template<class Policy, typename Stream>
-Stream basic_trace_output<Policy, Stream>::trace_stream;
-
-template<class Policy, typename Stream>
-bool basic_trace_output<Policy, Stream>::trace_enabled([]() {
-    auto env = getenv("YOMM2_TRACE");
-    return env && *env++ == '1' && *env++ == 0;
-}());
-
-template<class Policy>
-struct yOMM2_API_gcc fast_perfect_hash : virtual type_hash {
-    struct report {
-        std::size_t method_table_size, dispatch_table_size;
-        std::size_t hash_search_attempts;
-    };
-
-    static type_id hash_mult;
-    static std::size_t hash_shift;
-    static std::size_t hash_length;
-    static std::size_t hash_min;
-    static std::size_t hash_max;
-
-#ifdef _MSC_VER
-    __forceinline
-#endif
-        static type_id
-        hash_type_id(type_id type) {
-        return (hash_mult * type) >> hash_shift;
-    }
-
-    template<typename ForwardIterator>
-    static void hash_initialize(ForwardIterator first, ForwardIterator last) {
-        std::vector<type_id> buckets;
-        hash_initialize(first, last, buckets);
-    }
-
-    template<typename ForwardIterator>
-    static void hash_initialize(
-        ForwardIterator first, ForwardIterator last,
-        std::vector<type_id>& buckets);
-};
-
-template<class Policy>
-template<typename ForwardIterator>
-void fast_perfect_hash<Policy>::hash_initialize(
-    ForwardIterator first, ForwardIterator last,
-    std::vector<type_id>& buckets) {
-    using namespace policy;
-
-    constexpr bool trace_enabled = Policy::template has_facet<trace_output>;
-    const auto N = std::distance(first, last);
-
-    if constexpr (trace_enabled) {
-        if (Policy::trace_enabled) {
-            Policy::trace_stream << "Finding hash factor for " << N
-                                 << " boost::mp11::mp_list\n";
-        }
-    }
-
-    std::default_random_engine rnd(13081963);
-    std::size_t total_attempts = 0;
-    std::size_t M = 1;
-
-    for (auto size = N * 5 / 4; size >>= 1;) {
-        ++M;
-    }
-
-    std::uniform_int_distribution<type_id> uniform_dist;
-
-    for (std::size_t pass = 0; pass < 4; ++pass, ++M) {
-        hash_shift = 8 * sizeof(type_id) - M;
-        auto hash_size = 1 << M;
-
-        if constexpr (trace_enabled) {
-            if (Policy::trace_enabled) {
-                Policy::trace_stream << "  trying with M = " << M << ", "
-                                     << hash_size << " buckets\n";
-            }
-        }
-
-        bool found = false;
-        std::size_t attempts = 0;
-        buckets.resize(hash_size);
-        hash_length = 0;
-
-        while (!found && attempts < 100000) {
-            std::fill(buckets.begin(), buckets.end(), static_cast<type_id>(-1));
-            ++attempts;
-            ++total_attempts;
-            found = true;
-            hash_mult = uniform_dist(rnd) | 1;
-
-            for (auto iter = first; iter != last; ++iter) {
-                for (auto type_iter = iter->type_id_begin();
-                     type_iter != iter->type_id_end(); ++type_iter) {
-                    auto type = *type_iter;
-                    auto index = (type * hash_mult) >> hash_shift;
-                    hash_min = (std::min)(hash_min, index);
-                    hash_max = (std::max)(hash_max, index);
-
-                    if (buckets[index] != static_cast<type_id>(-1)) {
-                        found = false;
-                        break;
-                    }
-
-                    buckets[index] = type;
-                }
-            }
-        }
-
-        // metrics.hash_search_attempts = total_attempts;
-        // metrics.hash_search_time =
-        //     std::chrono::steady_clock::now() - start_time;
-        // metrics.hash_table_size = hash_size;
-
-        if (found) {
-            hash_length = hash_max + 1;
-
-            if constexpr (trace_enabled) {
-                if (Policy::trace_enabled) {
-                    Policy::trace_stream << "  found " << hash_mult << " after "
-                                         << total_attempts
-                                         << " attempts; min = " << hash_min
-                                         << ", max = " << hash_max << "\n";
-                }
-            }
-
-            return;
-        }
-    }
-
-    hash_search_error error;
-    error.attempts = total_attempts;
-    // error.duration = std::chrono::steady_clock::now() - start_time;
-    error.buckets = 1 << M;
-
-    if constexpr (has_facet<Policy, error_handler>) {
-        Policy::error(error_type(error));
-    }
-
-    abort();
-}
-
-template<class Policy>
-type_id fast_perfect_hash<Policy>::hash_mult;
-template<class Policy>
-std::size_t fast_perfect_hash<Policy>::hash_shift;
-template<class Policy>
-std::size_t fast_perfect_hash<Policy>::hash_length;
-template<class Policy>
-std::size_t fast_perfect_hash<Policy>::hash_min;
-template<class Policy>
-std::size_t fast_perfect_hash<Policy>::hash_max;
-
-template<class Policy>
-struct yOMM2_API_gcc checked_perfect_hash : virtual fast_perfect_hash<Policy>,
-                                            virtual runtime_checks {
-    static std::vector<type_id> control;
-
-    static type_id hash_type_id(type_id type) {
-        auto index = fast_perfect_hash<Policy>::hash_type_id(type);
-
-        if (index >= fast_perfect_hash<Policy>::hash_length ||
-            control[index] != type) {
-            using namespace policy;
-
-            if constexpr (Policy::template has_facet<error_handler>) {
-                unknown_class_error error;
-                error.context = unknown_class_error::update;
-                error.type = type;
-                Policy::error(error);
-            }
-
-            abort();
-        }
-
-        return index;
-    }
-
-    template<typename ForwardIterator>
-    static void hash_initialize(ForwardIterator first, ForwardIterator last) {
-        fast_perfect_hash<Policy>::hash_initialize(first, last, control);
-        control.resize(fast_perfect_hash<Policy>::hash_length);
-    }
-};
-
-template<class Policy>
-std::vector<type_id> checked_perfect_hash<Policy>::control;
-
-#ifdef __cpp_exceptions
-struct yOMM2_API_gcc throw_error : virtual error_handler {
-    static void error(const error_type& error_v) {
-        std::visit([](auto&& arg) { throw arg; }, error_v);
-    }
-};
-#endif
-
-template<class Policy, typename DefaultHandlerProvider = void>
-struct yOMM2_API_gcc vectored_error : virtual error_handler {
-    static error_handler_type error;
-
-    static void default_error_handler(const error_type& error_v) {
-        using namespace detail;
-        using namespace policy;
-
-        if constexpr (Policy::template has_facet<error_output>) {
-            if (auto error = std::get_if<resolution_error>(&error_v)) {
-                const char* explanation[] = {
-                    "no applicable definition", "ambiguous call"};
-                Policy::error_stream
-                    << explanation
-                           [error->status - resolution_error::no_definition]
-                    << " for " << error->method_name << "(";
-                auto comma = "";
-
-                for (auto ti : range{
-                         error->types,
-                         error->types + error->arity}) {
-                    Policy::error_stream << comma;
-                    Policy::type_name(ti, Policy::error_stream);
-                    comma = ", ";
-                }
-
-                Policy::error_stream << ")\n";
-            } else if (
-                auto error = std::get_if<unknown_class_error>(&error_v)) {
-                Policy::error_stream << "unknown class ";
-                Policy::type_name(error->type, Policy::error_stream);
-                Policy::error_stream << "\n";
-            } else if (auto error = std::get_if<method_table_error>(&error_v)) {
-                Policy::error_stream << "invalid method table for ";
-                Policy::type_name(error->type, Policy::error_stream);
-                Policy::error_stream << "\n";
-            } else if (auto error = std::get_if<hash_search_error>(&error_v)) {
-                Policy::error_stream << "could not find hash factors after "
-                                     << error->attempts << "s using "
-                                     << error->buckets << " buckets\n";
-            }
-        }
-    }
-};
-
-template<class Policy, typename DefaultHandlerProvider>
-error_handler_type vectored_error<Policy, DefaultHandlerProvider>::error =
-    std::conditional_t<
-        std::is_same_v<DefaultHandlerProvider, void>, vectored_error<Policy>,
-        DefaultHandlerProvider>::default_error_handler;
-
 struct yOMM2_API_gcc release
     : basic_policy<
           release, std_rtti, fast_perfect_hash<release>, vptr_vector<release>,
@@ -511,40 +42,6 @@ struct yOMM2_API_gcc debug
           basic_error_output<debug>, basic_trace_output<debug>,
           vectored_error<debug>> {};
 
-#if defined(_MSC_VER) && !defined(yOMM2_DLL)
-extern template class __declspec(dllimport) basic_domain<debug_shared>;
-extern template class __declspec(dllimport) vptr_vector<debug_shared>;
-extern template class __declspec(dllimport) fast_perfect_hash<debug_shared>;
-extern template class __declspec(dllimport) checked_perfect_hash<debug_shared>;
-extern template class __declspec(dllimport)
-basic_trace_output<debug_shared, detail::ostderr>;
-extern template class __declspec(dllimport)
-basic_error_output<debug_shared, detail::ostderr>;
-extern template class __declspec(dllimport) checked_perfect_hash<debug_shared>;
-extern template class __declspec(dllimport) vectored_error<debug_shared>;
-extern template class __declspec(dllimport) basic_policy<
-    debug_shared, vptr_vector<debug_shared>, std_rtti,
-    checked_perfect_hash<debug_shared>, basic_error_output<debug_shared>,
-    basic_trace_output<debug_shared>, vectored_error<debug_shared>>;
-#endif
-
-#ifndef BOOST_NO_RTTI
-struct yOMM2_API_gcc debug_shared
-    : basic_policy<
-          debug_shared, std_rtti, checked_perfect_hash<debug_shared>,
-          vptr_vector<debug_shared>, basic_error_output<debug_shared>,
-          basic_trace_output<debug_shared>, vectored_error<debug_shared>> {};
-
-struct yOMM2_API_gcc release_shared : debug_shared {
-    template<class Class>
-    static const std::uintptr_t* dynamic_vptr(const Class& arg) {
-        auto index = dynamic_type(arg);
-        index = fast_perfect_hash<debug_shared>::hash_type_id(index);
-        return vptrs[index];
-    }
-};
-#endif
-
 #ifdef NDEBUG
 using default_static = policy::release;
 #else
diff --git a/include/yorel/yomm2/templates.hpp b/include/yorel/yomm2/templates.hpp
index cd5c240c..f8e37573 100644
--- a/include/yorel/yomm2/templates.hpp
+++ b/include/yorel/yomm2/templates.hpp
@@ -14,32 +14,32 @@
 
 namespace yorel { namespace yomm2 {
 
-using boost::mp11::mp_list;
+using detail::types;
 
 struct not_defined {};
 
 template<template<typename...> typename Template>
 struct template_ {
     template<typename... Ts>
-    using fn = boost::mp11::mp_apply<Template, mp_list<Ts...>>;
+    using fn = boost::mp11::mp_apply<Template, types<Ts...>>;
     // using fn = Template<Ts...> would not work because Template is not
     // necessarily variadic, but mp_apply can cope with this situation.
 };
 
 template<template<typename...> typename... Templates>
-using templates = mp_list<template_<Templates>...>;
+using templates = types<template_<Templates>...>;
 
 namespace detail {
 
 // template <template <typename...> typename... F>
-// using mp_list_q = boost::mp11::mp_list<boost::mp11::mp_quote<F>...>;
+// using mp_list_q = types<boost::mp11::mp_quote<F>...>;
 
 template<typename...>
 struct product_impl;
 
 template<typename... Ts, typename... TypeLists>
-struct product_impl<mp_list<Ts...>, TypeLists...> {
-    using type = boost::mp11::mp_product<mp_list, mp_list<Ts...>, TypeLists...>;
+struct product_impl<types<Ts...>, TypeLists...> {
+    using type = mp11::mp_product<types, types<Ts...>, TypeLists...>;
 };
 
 template<typename...>
@@ -47,9 +47,9 @@ struct apply_product_impl;
 
 template<template<typename...> typename... Templates, typename... TypeLists>
 struct apply_product_impl<templates<Templates...>, TypeLists...> {
-    using type = boost::mp11::mp_product<
-        boost::mp11::mp_invoke_q,
-        mp_list<boost::mp11::mp_quote<Templates>...>,
+    using type = mp11::mp_product<
+        mp11::mp_invoke_q,
+        types<boost::mp11::mp_quote<Templates>...>,
         TypeLists...
     >;
 };
@@ -57,7 +57,7 @@ struct apply_product_impl<templates<Templates...>, TypeLists...> {
 }
 
 template<typename... TypeLists>
-using product = boost::mp11::mp_product<mp_list, TypeLists...>;
+using product = boost::mp11::mp_product<types, TypeLists...>;
 
 template<typename... Lists>
 using apply_product = typename detail::apply_product_impl<Lists...>::type;
@@ -70,7 +70,7 @@ using transform_product = boost::mp11::mp_apply<
             boost::mp11::mp_apply_q,
             boost::mp11::mp_quote<F>
         >,
-        boost::mp11::mp_product<mp_list, TypeLists...>
+        boost::mp11::mp_product<types, TypeLists...>
     >
 >;
 
@@ -105,18 +105,18 @@ struct use_definition {
 
     template<typename TypeList>
     using fn = typename impl<
-        has_method<boost::mp11::mp_apply<Definition, TypeList>>,
-        boost::mp11::mp_apply<Definition, TypeList>
+        has_method<mp11::mp_apply<Definition, TypeList>>,
+        mp11::mp_apply<Definition, TypeList>
     >::type;
 };
 
 template<template<typename...> typename Definition>
 struct is_defined {
     template<typename TypeList>
-    using fn = boost::mp11::mp_bool<
+    using fn = mp11::mp_bool<
         !std::is_base_of_v<
             not_defined,
-            boost::mp11::mp_apply<Definition, TypeList>
+            mp11::mp_apply<Definition, TypeList>
         >
     >;
 };
@@ -128,8 +128,8 @@ struct is_defined {
 
 template<typename... T>
 struct large_aggregate : std::tuple<
-    boost::mp11::mp_apply<aggregate, boost::mp11::mp_take_c<mp_list<T...>, sizeof...(T) / 2>>,
-    boost::mp11::mp_apply<aggregate, boost::mp11::mp_drop_c<mp_list<T...>, sizeof...(T) / 2>>
+    mp11::mp_apply<aggregate, mp11::mp_take_c<types<T...>, sizeof...(T) / 2>>,
+    mp11::mp_apply<aggregate, mp11::mp_drop_c<types<T...>, sizeof...(T) / 2>>
 > {
 };
 
@@ -143,7 +143,7 @@ struct aggregate : boost::mp11::mp_if_c<
 >::type {};
 
 template<typename... T>
-struct aggregate<mp_list<T...>> : aggregate<T...> {};
+struct aggregate<types<T...>> : aggregate<T...> {};
 
 template<template<typename...> typename Definition, typename LoL>
 using use_definitions = boost::mp11::mp_apply<
diff --git a/tests/test_core.cpp b/tests/test_core.cpp
index fc1c27cf..c4182c23 100644
--- a/tests/test_core.cpp
+++ b/tests/test_core.cpp
@@ -34,9 +34,9 @@ static_assert(
     std::is_same_v<
         mp_filter<
             is_virtual,
-            mp_list< virtual_<a&>, b, virtual_<c&> >
+            types< virtual_<a&>, b, virtual_<c&> >
         >,
-        mp_list< virtual_<a&>, virtual_<c&> >
+        types< virtual_<a&>, virtual_<c&> >
     >);
 
 static_assert(
@@ -55,9 +55,9 @@ static_assert(
     std::is_same_v<
         mp_transform<
             remove_virtual,
-            mp_list< virtual_<a&>, virtual_<c&> >
+            types< virtual_<a&>, virtual_<c&> >
         >,
-        mp_list<a&, c&>
+        types<a&, c&>
     >);
 
 static_assert(
@@ -66,10 +66,10 @@ static_assert(
             mp_bind_front<polymorphic_type, default_policy>,
             mp_transform<
                 remove_virtual,
-                mp_list< virtual_<a&>, virtual_<c&> >
+                types< virtual_<a&>, virtual_<c&> >
             >
         >,
-        mp_list<a, c>
+        types<a, c>
     >);
 
 static_assert(
@@ -80,31 +80,31 @@ static_assert(
                 remove_virtual,
                 mp_filter<
                     is_virtual,
-                    mp_list< virtual_<a&>, b, virtual_<c&> >
+                    types< virtual_<a&>, b, virtual_<c&> >
                 >
             >
         >,
-        mp_list<a, c>
+        types<a, c>
     >);
 
 static_assert(
     std::is_same_v<
-        polymorphic_types<mp_list<virtual_<a&>, b, virtual_<c&>>>,
-        mp_list<a&, c&>>);
+        polymorphic_types<types<virtual_<a&>, b, virtual_<c&>>>,
+        types<a&, c&>>);
 
 static_assert(
     std::is_same_v<
-        polymorphic_types<mp_list<
+        polymorphic_types<types<
             virtual_<std::shared_ptr<a>>, b, virtual_<std::shared_ptr<c>>>>,
-        mp_list<std::shared_ptr<a>, std::shared_ptr<c>>>);
+        types<std::shared_ptr<a>, std::shared_ptr<c>>>);
 
 static_assert(
     std::is_same_v<
         spec_polymorphic_types<
             default_policy,
-            mp_list<virtual_<a&>, b, virtual_<c&>>,
-            mp_list<d&, e, f&>>,
-        mp_list<d, f>>);
+            types<virtual_<a&>, b, virtual_<c&>>,
+            types<d&, e, f&>>,
+        types<d, f>>);
 
 static_assert(
     std::is_same_v<
@@ -115,15 +115,15 @@ static_assert(
     std::is_same_v<
         spec_polymorphic_types<
             default_policy,
-            mp_list<
+            types<
                 virtual_<std::shared_ptr<a>>, b, virtual_<std::shared_ptr<c>>>,
-            mp_list<std::shared_ptr<d>, e, std::shared_ptr<f>>>,
-        mp_list<d, f>>);
+            types<std::shared_ptr<d>, e, std::shared_ptr<f>>>,
+        types<d, f>>);
 
 BOOST_AUTO_TEST_CASE(test_type_id_list) {
     type_id expected[] = {type_id(&typeid(a)), type_id(&typeid(b))};
-    auto iter = type_id_list<default_policy, mp_list<a&, b&>>::begin;
-    auto last = type_id_list<default_policy, mp_list<a&, b&>>::end;
+    auto iter = type_id_list<default_policy, types<a&, b&>>::begin;
+    auto last = type_id_list<default_policy, types<a&, b&>>::end;
     BOOST_TEST_REQUIRE(last - iter == 2);
     BOOST_TEST_REQUIRE(*iter++ == type_id(&typeid(a)));
     BOOST_TEST_REQUIRE(*iter++ == type_id(&typeid(b)));
@@ -198,19 +198,19 @@ BOOST_AUTO_TEST_CASE(casts) {
     base_address = thunk<
         default_policy,
         voidp(virtual_<const Animal&>), mammal_this,
-        mp_list<const Mammal&>>::fn(animal);
+        types<const Mammal&>>::fn(animal);
     BOOST_TEST(base_address == &mammal);
 
     base_address = thunk<
         default_policy,
         voidp(virtual_<const Animal&>), carnivore_this,
-        mp_list<const Carnivore&>>::fn(animal);
+        types<const Carnivore&>>::fn(animal);
     BOOST_TEST(base_address == &carnivore);
 
     base_address = thunk<
         default_policy,
         voidp(virtual_<const Animal&>), mammal_this,
-        mp_list<const Dog&>>::fn(animal);
+        types<const Dog&>>::fn(animal);
     BOOST_TEST(base_address == &dog);
 }
 
@@ -227,12 +227,12 @@ struct Dolphin : public Animal {};
 static_assert(
     std::is_same_v<
         inheritance_map<Animal, Dog, Bulldog, Cat, Dolphin>,
-        mp_list<
-            mp_list<Animal, Animal>,
-            mp_list<Dog, Animal, Dog>,
-            mp_list<Bulldog, Animal, Dog, Bulldog>,
-            mp_list<Cat, Animal, Cat>,
-            mp_list<Dolphin, Animal, Dolphin>
+        types<
+            types<Animal, Animal>,
+            types<Dog, Animal, Dog>,
+            types<Bulldog, Animal, Dog, Bulldog>,
+            types<Cat, Animal, Cat>,
+            types<Dolphin, Animal, Dolphin>
         >
 >);
 
@@ -240,11 +240,11 @@ static_assert(
     std::is_same_v<
         use_classes<Animal, Dog, Bulldog, Cat, Dolphin>,
         std::tuple<
-            class_declaration_aux<default_policy, mp_list<Animal, Animal>>,
-            class_declaration_aux<default_policy, mp_list<Dog, Animal, Dog>>,
-            class_declaration_aux<default_policy, mp_list<Bulldog, Animal, Dog, Bulldog>>,
-            class_declaration_aux<default_policy, mp_list<Cat, Animal, Cat>>,
-            class_declaration_aux<default_policy, mp_list<Dolphin, Animal, Dolphin>>
+            class_declaration_aux<default_policy, types<Animal, Animal>>,
+            class_declaration_aux<default_policy, types<Dog, Animal, Dog>>,
+            class_declaration_aux<default_policy, types<Bulldog, Animal, Dog, Bulldog>>,
+            class_declaration_aux<default_policy, types<Cat, Animal, Cat>>,
+            class_declaration_aux<default_policy, types<Dolphin, Animal, Dolphin>>
         >
 >);
 
@@ -252,7 +252,7 @@ static_assert(
     std::is_same_v<
         use_classes_macro<Animal, default_policy>,
         std::tuple<
-            class_declaration_aux<default_policy, mp_list<Animal, Animal>>
+            class_declaration_aux<default_policy, types<Animal, Animal>>
         >
 >);
 
@@ -262,7 +262,7 @@ static_assert(
     std::is_same_v<
         use_classes_macro<Animal, my_policy, default_policy>,
         std::tuple<
-            class_declaration_aux<my_policy, mp_list<Animal, Animal>>
+            class_declaration_aux<my_policy, types<Animal, Animal>>
         >
 >);
 
@@ -270,7 +270,7 @@ static_assert(
     std::is_same_v<
         use_classes_macro<Animal, my_policy>,
         std::tuple<
-            class_declaration_aux<my_policy, mp_list<Animal, Animal>>
+            class_declaration_aux<my_policy, types<Animal, Animal>>
         >
 >);
 
@@ -299,12 +299,12 @@ struct policy3 : policy1::rebind<policy3>::replace<std_rtti, alt_rtti> {};
 
 static_assert(std::is_same_v<
     policy2::facets,
-    mp_list<std_rtti>
+    types<std_rtti>
 >);
 
 static_assert(std::is_same_v<
     policy3::facets,
-    mp_list<alt_rtti>
+    types<alt_rtti>
 >);
 
 // static_assert(std::is_same_v<
@@ -318,7 +318,7 @@ void f(char, int) {}
 
 static_assert(std::is_same_v<
     parameter_type_list_t<decltype(f)>,
-    mp_list<char, int>
+    types<char, int>
 >);
 
 // -----------------------------------------------------------------------------
diff --git a/tests/test_templates.cpp b/tests/test_templates.cpp
index aaa2a245..fee21577 100644
--- a/tests/test_templates.cpp
+++ b/tests/test_templates.cpp
@@ -12,7 +12,7 @@
 // clang-format off
 
 using namespace yorel::yomm2;
-using boost::mp11::mp_list;
+using detail::types;
 
 namespace test_product {
 
@@ -22,16 +22,16 @@ struct n;
 static_assert(
     std::is_same_v<
         product<
-            mp_list<n<1>, n<2> >,
-            mp_list< n<3>, n<4>, n<5> >
+            types<n<1>, n<2> >,
+            types< n<3>, n<4>, n<5> >
         >,
-        mp_list<
-            mp_list<n<1>, n<3>>,
-            mp_list<n<1>, n<4>>,
-            mp_list<n<1>, n<5>>,
-            mp_list<n<2>, n<3>>,
-            mp_list<n<2>, n<4>>,
-            mp_list<n<2>, n<5>>
+        types<
+            types<n<1>, n<3>>,
+            types<n<1>, n<4>>,
+            types<n<1>, n<5>>,
+            types<n<2>, n<3>>,
+            types<n<2>, n<4>>,
+            types<n<2>, n<5>>
         >
     >);
 
@@ -42,10 +42,10 @@ static_assert(
     std::is_same_v<
         apply_product<
             templates<bin1, bin2>,
-            mp_list<n<1>, n<2>>,
-            mp_list<n<3>, n<4>, n<5>>
+            types<n<1>, n<2>>,
+            types<n<3>, n<4>, n<5>>
         >,
-        mp_list<
+        types<
             bin1<n<1>, n<3>>,
             bin1<n<1>, n<4>>,
             bin1<n<1>, n<5>>,
@@ -68,7 +68,7 @@ template<typename T>
 struct square_matrix;
 
 template<typename T>
-using matrix_types = mp_list<ordinary_matrix<T>, square_matrix<T>>;
+using matrix_types = types<ordinary_matrix<T>, square_matrix<T>>;
 
 template<typename T1, typename T2>
 struct add;
@@ -80,8 +80,8 @@ template<typename T1, typename T2>
 using binary_operations = product<
     apply_product<
         templates<add, multiply>,
-        mp_list<T1>,
-        mp_list<T2>
+        types<T1>,
+        types<T2>
     >,
     matrix_types<T1>,
     matrix_types<T2>
@@ -91,42 +91,42 @@ static_assert(
     std::is_same_v<
         transform_product<
             binary_operations,
-            mp_list<int, double>,
-            mp_list<int, double>
+            types<int, double>,
+            types<int, double>
         >,
-        mp_list<
-            mp_list<add<int, int>, ordinary_matrix<int>, ordinary_matrix<int>>,
-            mp_list<add<int, int>, ordinary_matrix<int>, square_matrix<int>>,
-            mp_list<add<int, int>, square_matrix<int>, ordinary_matrix<int>>,
-            mp_list<add<int, int>, square_matrix<int>, square_matrix<int>>,
-            mp_list<multiply<int, int>, ordinary_matrix<int>, ordinary_matrix<int>>,
-            mp_list<multiply<int, int>, ordinary_matrix<int>, square_matrix<int>>,
-            mp_list<multiply<int, int>, square_matrix<int>, ordinary_matrix<int>>,
-            mp_list<multiply<int, int>, square_matrix<int>, square_matrix<int>>,
-            mp_list<add<int, double>, ordinary_matrix<int>, ordinary_matrix<double>>,
-            mp_list<add<int, double>, ordinary_matrix<int>, square_matrix<double>>,
-            mp_list<add<int, double>, square_matrix<int>, ordinary_matrix<double>>,
-            mp_list<add<int, double>, square_matrix<int>, square_matrix<double>>,
-            mp_list<multiply<int, double>, ordinary_matrix<int>, ordinary_matrix<double>>,
-            mp_list<multiply<int, double>, ordinary_matrix<int>, square_matrix<double>>,
-            mp_list<multiply<int, double>, square_matrix<int>, ordinary_matrix<double>>,
-            mp_list<multiply<int, double>, square_matrix<int>, square_matrix<double>>,
-            mp_list<add<double, int>, ordinary_matrix<double>, ordinary_matrix<int>>,
-            mp_list<add<double, int>, ordinary_matrix<double>, square_matrix<int>>,
-            mp_list<add<double, int>, square_matrix<double>, ordinary_matrix<int>>,
-            mp_list<add<double, int>, square_matrix<double>, square_matrix<int>>,
-            mp_list<multiply<double, int>, ordinary_matrix<double>, ordinary_matrix<int>>,
-            mp_list<multiply<double, int>, ordinary_matrix<double>, square_matrix<int>>,
-            mp_list<multiply<double, int>, square_matrix<double>, ordinary_matrix<int>>,
-            mp_list<multiply<double, int>, square_matrix<double>, square_matrix<int>>,
-            mp_list<add<double, double>, ordinary_matrix<double>, ordinary_matrix<double>>,
-            mp_list<add<double, double>, ordinary_matrix<double>, square_matrix<double>>,
-            mp_list<add<double, double>, square_matrix<double>, ordinary_matrix<double>>,
-            mp_list<add<double, double>, square_matrix<double>, square_matrix<double>>,
-            mp_list<multiply<double, double>, ordinary_matrix<double>, ordinary_matrix<double>>,
-            mp_list<multiply<double, double>, ordinary_matrix<double>, square_matrix<double>>,
-            mp_list<multiply<double, double>, square_matrix<double>, ordinary_matrix<double>>,
-            mp_list<multiply<double, double>, square_matrix<double>, square_matrix<double>>>
+        types<
+            types<add<int, int>, ordinary_matrix<int>, ordinary_matrix<int>>,
+            types<add<int, int>, ordinary_matrix<int>, square_matrix<int>>,
+            types<add<int, int>, square_matrix<int>, ordinary_matrix<int>>,
+            types<add<int, int>, square_matrix<int>, square_matrix<int>>,
+            types<multiply<int, int>, ordinary_matrix<int>, ordinary_matrix<int>>,
+            types<multiply<int, int>, ordinary_matrix<int>, square_matrix<int>>,
+            types<multiply<int, int>, square_matrix<int>, ordinary_matrix<int>>,
+            types<multiply<int, int>, square_matrix<int>, square_matrix<int>>,
+            types<add<int, double>, ordinary_matrix<int>, ordinary_matrix<double>>,
+            types<add<int, double>, ordinary_matrix<int>, square_matrix<double>>,
+            types<add<int, double>, square_matrix<int>, ordinary_matrix<double>>,
+            types<add<int, double>, square_matrix<int>, square_matrix<double>>,
+            types<multiply<int, double>, ordinary_matrix<int>, ordinary_matrix<double>>,
+            types<multiply<int, double>, ordinary_matrix<int>, square_matrix<double>>,
+            types<multiply<int, double>, square_matrix<int>, ordinary_matrix<double>>,
+            types<multiply<int, double>, square_matrix<int>, square_matrix<double>>,
+            types<add<double, int>, ordinary_matrix<double>, ordinary_matrix<int>>,
+            types<add<double, int>, ordinary_matrix<double>, square_matrix<int>>,
+            types<add<double, int>, square_matrix<double>, ordinary_matrix<int>>,
+            types<add<double, int>, square_matrix<double>, square_matrix<int>>,
+            types<multiply<double, int>, ordinary_matrix<double>, ordinary_matrix<int>>,
+            types<multiply<double, int>, ordinary_matrix<double>, square_matrix<int>>,
+            types<multiply<double, int>, square_matrix<double>, ordinary_matrix<int>>,
+            types<multiply<double, int>, square_matrix<double>, square_matrix<int>>,
+            types<add<double, double>, ordinary_matrix<double>, ordinary_matrix<double>>,
+            types<add<double, double>, ordinary_matrix<double>, square_matrix<double>>,
+            types<add<double, double>, square_matrix<double>, ordinary_matrix<double>>,
+            types<add<double, double>, square_matrix<double>, square_matrix<double>>,
+            types<multiply<double, double>, ordinary_matrix<double>, ordinary_matrix<double>>,
+            types<multiply<double, double>, ordinary_matrix<double>, square_matrix<double>>,
+            types<multiply<double, double>, square_matrix<double>, ordinary_matrix<double>>,
+            types<multiply<double, double>, square_matrix<double>, square_matrix<double>>>
     >);
 
 }
@@ -142,7 +142,7 @@ template<typename...>
 struct definition {};
 
 static_assert(std::is_same_v<
-    detail::use_definition<definition>::fn<mp_list<method, int>>,
+    detail::use_definition<definition>::fn<types<method, int>>,
     method::add_definition<definition<method, int>>
 
 >);