diff --git a/docs.in/reference/method.cpp b/docs.in/reference/method.cpp
index bc34f42e..5ec71daf 100644
--- a/docs.in/reference/method.cpp
+++ b/docs.in/reference/method.cpp
@@ -1,6 +1,6 @@
 /***
 entry: method
-hrefs: method-fn, method-next_type, method-override_fn, method-override, method-use_next
+hrefs: method-fn, method-next_type, method-override, method-override, method-use_next
 headers: yorel/yomm2/core.hpp, yorel/yomm2.hpp
 
 ```c++
@@ -16,7 +16,7 @@ struct method<Name, ReturnType(Args...), Policy>;
 
 `method` provides a static function object, `fn`, that takes a list of arguments
 of type `Args`, *minus* the `virtual_` decorator, and returns `ReturnType`.
-Method definitions can be added with the [`method::override_fn`](#override_fn)
+Method definitions can be added with the [`method::override`](#override)
 and [`method::override`](#override) class templates.
 
 ## Template parameters
@@ -82,17 +82,17 @@ The single instance of `method<Name, ReturnType(Args...)>`. Used to call the met
 
 | Name                              | Description                                               |
 | --------------------------------- | --------------------------------------------------------- |
-| [override_fn](#override_fn)     | add a definition to the method                            |
+| [override](#override)     | add a definition to the method                            |
 | [override](#override) | add a definition container to the method                  |
 | [next_type](#next_type)           | type of a pointer to the next most specialised definition |
 | [use_next](#use_next)             | CRTP base for definitions that use `next`                 |
 
-## override_fn
+## override
 
 ```c++
 template<auto Function>
-struct override_fn {
-    explicit override_fn(next_type* next = nullptr);
+struct override {
+    explicit override(next_type* next = nullptr);
 };
 ```
 
@@ -200,18 +200,18 @@ using kick = yomm2::method<kick_methods(virtual_<Animal&>), std::string>;
 std::string kick_cat(Cat& dog) {
     return "hiss";
 }
-YOMM2_REGISTER(kick::override_fn<kick_cat>);
+YOMM2_REGISTER(kick::override<kick_cat>);
 
 std::string kick_dog(Dog& dog) {
     return "bark";
 }
-YOMM2_REGISTER(kick::override_fn<kick_dog>);
 
-struct kick_bulldog {
-    static std::string fn(Bulldog& dog) {
-        return kick::next<fn>(dog) + " and bite";
-    }
-};
+YOMM2_REGISTER(kick::override<kick_dog>);
+
+std::string kick_bulldog(Bulldog& dog) {
+    return kick::next<kick_bulldog>(dog) + " and bite";
+}
+
 YOMM2_REGISTER(kick::override<kick_bulldog>);
 
 struct YOMM2_METHOD_NAME(pet); // use obfuscated name
@@ -221,12 +221,14 @@ using pet =
 std::string pet_cat(Cat& dog) {
     return "purr";
 }
-YOMM2_REGISTER(pet::override_fn<pet_cat>);
+
+YOMM2_REGISTER(pet::override<pet_cat>);
 
 std::string pet_dog(Dog& dog) {
     return "wag tail";
 }
-YOMM2_REGISTER(pet::override_fn<pet_dog>);
+
+YOMM2_REGISTER(pet::override<pet_dog>);
 
 BOOST_AUTO_TEST_CASE(ref_method_example) {
     yomm2::initialize();
diff --git a/docs.in/reference/use_definitions.cpp b/docs.in/reference/use_definitions.cpp
index 07c6f7ea..156f0bb2 100644
--- a/docs.in/reference/use_definitions.cpp
+++ b/docs.in/reference/use_definitions.cpp
@@ -51,7 +51,7 @@ using same_type = method<same_type_(
 bool same_type_catch_all(const abstract_matrix&, const abstract_matrix&) {
     return false;
 }
-YOMM2_REGISTER(same_type::override_fn<same_type_catch_all>);
+YOMM2_REGISTER(same_type::override<same_type_catch_all>);
 
 // 2
 template<class Method, typename...>
diff --git a/docs.in/tutorials/api.cpp b/docs.in/tutorials/api.cpp
index 6f337128..bcd57583 100644
--- a/docs.in/tutorials/api.cpp
+++ b/docs.in/tutorials/api.cpp
@@ -110,7 +110,7 @@ std::string kick_dog(Dog& dog) {
     return "bark";
 }
 
-kick::override_fn<kick_dog> add_kick_dog;
+kick::override<kick_dog> add_kick_dog;
 // >
 
 // md<
@@ -120,7 +120,7 @@ kick::override_fn<kick_dog> add_kick_dog;
 // appropriate function. Function templates and explicit specialization can also
 // be used for this purpose.
 
-// What about `next`? The constructor of `override_fn` can be passed a pointer
+// What about `next`? The constructor of `override` can be passed a pointer
 // to a function that will be set to the function's next definition by
 // `update`. The pointer type is available in the method as `next_type`.
 
@@ -131,7 +131,7 @@ std::string kick_bulldog(Bulldog& dog) {
     return kick::next<kick_bulldog>(dog) + " and bite back";
 }
 
-kick::override_fn<kick_bulldog> add_kick_bulldog;
+kick::override<kick_bulldog> add_kick_bulldog;
 // >
 
 // md<
@@ -174,7 +174,7 @@ BOOST_AUTO_TEST_CASE(test_synopsis_functions_no_macros) {
 // passing it `declval` arguments for the definition's parameter list. The
 // compiler performs overload resolution, and the macro uses `decltype` to
 // extract the result type, i.e the method's class, and registers the definition
-// and the `next` pointer with `override_fn`.
+// and the `next` pointer with `override`.
 
 // In the process, both macros need to create identifiers for the various static
 // objects, and the name of the function inside the definition wrapper class.
@@ -247,7 +247,7 @@ using kick = method<kick_(virtual_<Animal&>), std::string>;
 
 // md<
 
-// `override_fn` is a workhorse that is intended to be used directly only by
+// `override` is a workhorse that is intended to be used directly only by
 // `define_method`. YOMM2 has another mechanism that is a bit more high level:
 // *definition containers*.
 
@@ -258,11 +258,9 @@ using kick = method<kick_(virtual_<Animal&>), std::string>;
 // >
 
 // code<
-struct kick_dog {
-    static std::string fn(Dog& dog) {
-        return "bark";
-    }
-};
+std::string kick_dog(Dog& dog) {
+    return "bark";
+}
 
 YOMM2_REGISTER(kick::override<kick_dog>);
 // >
@@ -279,11 +277,9 @@ YOMM2_REGISTER(kick::override<kick_dog>);
 // >
 
 // code<
-struct kick_bulldog {
-    static std::string fn(Bulldog& dog) {
-        return kick::next<fn>(dog) + " and bite back";
-    }
-};
+static std::string kick_bulldog(Bulldog& dog) {
+    return kick::next<kick_bulldog>(dog) + " and bite back";
+}
 
 YOMM2_REGISTER(kick::override<kick_bulldog>);
 // >
diff --git a/docs.in/tutorials/templates_tutorial.cpp b/docs.in/tutorials/templates_tutorial.cpp
index eca03a15..b8ae4645 100644
--- a/docs.in/tutorials/templates_tutorial.cpp
+++ b/docs.in/tutorials/templates_tutorial.cpp
@@ -282,7 +282,7 @@ inline bool operator==(const vector& a, const vector& b) {
 // Now we need to provide definitions for these methods. But which ones?
 
 // We could decide *for the user* that only (say) vectors of `double`s and
-// `int`s are supported. We could use `override_fn` or `override` to
+// `int`s are supported. We could use `override` or `override` to
 // define four specializations, covering all the possible combinations (i.e. the
 // Cartesian product):
 
diff --git a/examples/slides.cpp b/examples/slides.cpp
index db0b25e8..7145e07f 100644
--- a/examples/slides.cpp
+++ b/examples/slides.cpp
@@ -188,17 +188,15 @@ using value = method<value_id(virtual_<const Node&>), int>;
 int number_value(const Number& node) {
   return node.val;
 }
-value::override_fn<number_value> add_number_value;
+value::override<number_value> add_number_value;
 
 template<class NodeClass, class Op>
-struct binary_value {
-  static int fn(const NodeClass& expr) {
+int binary_op(const NodeClass& expr) {
     return Op()(value::fn(expr.left), value::fn(expr.right));
-  }
-};
+}
 
-YOMM2_REGISTER(value::override<binary_value<Plus, std::plus<int>>>);
-YOMM2_REGISTER(value::override<binary_value<Times, std::multiplies<int>>>);
+YOMM2_REGISTER(value::override<binary_op<Plus, std::plus<int>>>);
+YOMM2_REGISTER(value::override<binary_op<Times, std::multiplies<int>>>);
 
 }
 
diff --git a/include/yorel/yomm2/core.hpp b/include/yorel/yomm2/core.hpp
index b7b16c5a..e2fd9b57 100644
--- a/include/yorel/yomm2/core.hpp
+++ b/include/yorel/yomm2/core.hpp
@@ -647,44 +647,34 @@ class method<Name(Parameters...), Return, Policy> : public detail::method_info {
     };
 
     template<auto Function>
-    struct override_fn_impl {
-        explicit override_fn_impl(FunctionPointer* next = nullptr);
+    struct override_impl {
+        explicit override_impl(FunctionPointer* next = nullptr);
     };
 
     template<auto Function, typename FunctionType>
-    struct override_fn_aux;
+    struct override_aux;
 
     template<auto Function, typename FnReturnType, typename... FnParameters>
-    struct override_fn_aux<Function, FnReturnType (*)(FnParameters...)>
-        : override_fn_impl<Function> {
+    struct override_aux<Function, FnReturnType (*)(FnParameters...)>
+        : override_impl<Function> {
     };
 
     template<
         auto Function, class FnClass, typename FnReturnType,
         typename... FnParameters>
-    struct override_fn_aux<
+    struct override_aux<
         Function, FnReturnType (FnClass::*)(FnParameters...)> {
         static auto fn(FnClass* this_, FnParameters&&... args) -> FnReturnType {
             return (this_->*Function)(std::forward<FnParameters>(args)...);
         }
 
-        override_fn_impl<fn> impl{&next<Function>};
+        override_impl<fn> impl{&next<Function>};
     };
 
   public:
-    template<auto Function>
-    struct override_fn : override_fn_aux<Function, decltype(Function)> {
-        using override_fn_aux<Function, decltype(Function)>::override_fn_aux;
-    };
-
-    template<auto... F>
-    struct override_fns {
-        std::tuple<override_fn<F>...> fns;
-    };
-
-    template<class Container>
-    struct override : override_fn<Container::fn> {
-        using type = override;
+    template<auto... Function>
+    struct override {
+        std::tuple<override_aux<Function, decltype(Function)>...> impl;
     };
 };
 
@@ -988,8 +978,8 @@ auto method<Name(Parameters...), Return, Policy>::
 
 template<typename Name, typename Return, typename... Parameters, class Policy>
 template<auto Function>
-method<Name(Parameters...), Return, Policy>::override_fn_impl<
-    Function>::override_fn_impl(FunctionPointer* p_next) {
+method<Name(Parameters...), Return, Policy>::override_impl<
+    Function>::override_impl(FunctionPointer* p_next) {
     // Work around MSVC bug: using &next<Function> as a default value
     // for 'next' confuses it about Parameters not being expanded.
     if (!p_next) {
diff --git a/include/yorel/yomm2/macros.hpp b/include/yorel/yomm2/macros.hpp
index a1b6e06c..4abaf07c 100644
--- a/include/yorel/yomm2/macros.hpp
+++ b/include/yorel/yomm2/macros.hpp
@@ -69,7 +69,7 @@
     };                                                                         \
     INLINE YOMM2_REGISTER(                                                     \
         OVERRIDERS<YOREL_YOMM2_DETAIL_RETURN_TYPE(__VA_ARGS__) ARGS>::         \
-            method_type::override_fn<OVERRIDERS<                               \
+            method_type::override<OVERRIDERS<                               \
                 YOREL_YOMM2_DETAIL_RETURN_TYPE(__VA_ARGS__) ARGS>::fn>);       \
     INLINE auto                                                                \
         OVERRIDERS<YOREL_YOMM2_DETAIL_RETURN_TYPE(__VA_ARGS__) ARGS>::fn ARGS  \
diff --git a/include/yorel/yomm2/templates.hpp b/include/yorel/yomm2/templates.hpp
index c0edde88..4ad800aa 100644
--- a/include/yorel/yomm2/templates.hpp
+++ b/include/yorel/yomm2/templates.hpp
@@ -94,12 +94,12 @@ struct use_definition {
 
     template<typename T>
     struct impl<true, T> {
-        using type = typename T::method::template override<T>;
+        using type = typename T::method::template override<T::fn>;
     };
 
     template<typename First, typename... Rest>
     struct impl<false, Definition<First, Rest...>> {
-        using type = typename First::template override<Definition<First, Rest...>>;
+        using type = typename First::template override<Definition<First, Rest...>::fn>;
     };
 
     template<typename TypeList>
diff --git a/tests/benchmarks.cpp b/tests/benchmarks.cpp
index 91b930a3..30c51311 100644
--- a/tests/benchmarks.cpp
+++ b/tests/benchmarks.cpp
@@ -377,24 +377,24 @@ struct population : abstract_population {
         template<typename T>
         static void fn1(T&) {
         }
-        typename method1::template override_fn<fn1<intermediate<0>>>
+        typename method1::template override<fn1<intermediate<0>>>
             YOMM2_GENSYM;
-        typename method1::template override_fn<fn1<intermediate<1>>>
+        typename method1::template override<fn1<intermediate<1>>>
             YOMM2_GENSYM;
 
         template<typename T, typename U>
         static void fn2(T&, U&) {
         }
-        typename method2::template override_fn<
+        typename method2::template override<
             fn2<intermediate<0>, intermediate<0>>>
             YOMM2_GENSYM;
-        typename method2::template override_fn<
+        typename method2::template override<
             fn2<intermediate<0>, intermediate<1>>>
             YOMM2_GENSYM;
-        typename method2::template override_fn<
+        typename method2::template override<
             fn2<intermediate<1>, intermediate<0>>>
             YOMM2_GENSYM;
-        typename method2::template override_fn<
+        typename method2::template override<
             fn2<intermediate<1>, intermediate<1>>>
             YOMM2_GENSYM;
     };
@@ -416,24 +416,24 @@ struct population : abstract_population {
         template<typename T>
         static void fn1(vptr<T>) {
         }
-        typename method1::template override_fn<fn1<intermediate<0>>>
+        typename method1::template override<fn1<intermediate<0>>>
             YOMM2_GENSYM;
-        typename method1::template override_fn<fn1<intermediate<1>>>
+        typename method1::template override<fn1<intermediate<1>>>
             YOMM2_GENSYM;
 
         template<typename T, typename U>
         static void fn2(vptr<T>, vptr<U>) {
         }
-        typename method2::template override_fn<
+        typename method2::template override<
             fn2<intermediate<0>, intermediate<0>>>
             YOMM2_GENSYM;
-        typename method2::template override_fn<
+        typename method2::template override<
             fn2<intermediate<0>, intermediate<1>>>
             YOMM2_GENSYM;
-        typename method2::template override_fn<
+        typename method2::template override<
             fn2<intermediate<1>, intermediate<0>>>
             YOMM2_GENSYM;
-        typename method2::template override_fn<
+        typename method2::template override<
             fn2<intermediate<1>, intermediate<1>>>
             YOMM2_GENSYM;
     };
diff --git a/tests/test_blackbox.cpp b/tests/test_blackbox.cpp
index 6ad06d10..a4716780 100644
--- a/tests/test_blackbox.cpp
+++ b/tests/test_blackbox.cpp
@@ -210,13 +210,13 @@ std::string kick_dog(Dog& dog) {
     return "bark";
 }
 
-YOMM2_REGISTER(kick::override_fn<kick_dog>);
+YOMM2_REGISTER(kick::override<kick_dog>);
 
 std::string kick_bulldog(Bulldog& dog) {
     return kick::next<kick_bulldog>(dog) + " and bite back";
 }
 
-YOMM2_REGISTER(kick::override_fn<kick_bulldog>);
+YOMM2_REGISTER(kick::override<kick_bulldog>);
 
 BOOST_AUTO_TEST_CASE(test_next_fn) {
     initialize();
@@ -369,31 +369,31 @@ BOOST_AUTO_TEST_CASE(update_report) {
     // 'meet' dispatch table is one cell, containing 'not_implemented'
     BOOST_TEST(report.cells == 1);
 
-    YOMM2_REGISTER(kick::override_fn<fn<Animal>>);
+    YOMM2_REGISTER(kick::override<fn<Animal>>);
     report = initialize<test_policy>().report;
     BOOST_TEST(report.not_implemented == 2);
 
-    YOMM2_REGISTER(pet::override_fn<fn<Cat>>);
-    YOMM2_REGISTER(pet::override_fn<fn<Dog>>);
+    YOMM2_REGISTER(pet::override<fn<Cat>>);
+    YOMM2_REGISTER(pet::override<fn<Dog>>);
     report = initialize<test_policy>().report;
     BOOST_TEST(report.not_implemented == 2);
 
     // create ambiguity
-    YOMM2_REGISTER(meet::override_fn<fn<Animal, Cat>>);
-    YOMM2_REGISTER(meet::override_fn<fn<Dog, Animal>>);
+    YOMM2_REGISTER(meet::override<fn<Animal, Cat>>);
+    YOMM2_REGISTER(meet::override<fn<Dog, Animal>>);
     report = initialize<test_policy>().report;
     BOOST_TEST(report.cells == 4);
     BOOST_TEST(report.ambiguous == 1);
 
-    YOMM2_REGISTER(meet::override_fn<fn<Cat, Cat>>);
+    YOMM2_REGISTER(meet::override<fn<Cat, Cat>>);
     report = initialize<test_policy>().report;
     BOOST_TEST(report.cells == 6);
     BOOST_TEST(report.ambiguous == 1);
 
     // shadow ambiguity
-    YOMM2_REGISTER(meet::override_fn<fn<Dog, Dog>>);
-    YOMM2_REGISTER(meet::override_fn<fn<Dog, Cat>>);
-    YOMM2_REGISTER(meet::override_fn<fn<Cat, Dog>>);
+    YOMM2_REGISTER(meet::override<fn<Dog, Dog>>);
+    YOMM2_REGISTER(meet::override<fn<Dog, Cat>>);
+    YOMM2_REGISTER(meet::override<fn<Cat, Dog>>);
     report = initialize<test_policy>().report;
     BOOST_TEST(report.cells == 9);
     BOOST_TEST(report.ambiguous == 0);
diff --git a/tests/test_generator_forward_decls.cpp b/tests/test_generator_forward_decls.cpp
index 2c85adc7..837cc3b7 100644
--- a/tests/test_generator_forward_decls.cpp
+++ b/tests/test_generator_forward_decls.cpp
@@ -188,11 +188,11 @@ BOOST_AUTO_TEST_CASE(test_generate_offsets) {
         YOMM2_REGISTER(use_classes<foo, policy>);
 
         using baz1 = method<baz_key(virtual_<foo&>, int), void, policy>;
-        YOMM2_REGISTER(baz1::override_fn<baz1_def>);
+        YOMM2_REGISTER(baz1::override<baz1_def>);
 
         using baz2 =
             method<baz_key(virtual_<foo&>, virtual_<foo&>), void, policy>;
-        YOMM2_REGISTER(baz2::override_fn<baz2_def>);
+        YOMM2_REGISTER(baz2::override<baz2_def>);
 
         initialize<policy>();
 
diff --git a/tests/test_member_method.cpp b/tests/test_member_method.cpp
index 590da373..21b7e8ca 100644
--- a/tests/test_member_method.cpp
+++ b/tests/test_member_method.cpp
@@ -45,7 +45,7 @@ struct Payroll {
     }
 
   public:
-    using pay_functions = Payroll::pay_method::override_fns<
+    using pay_functions = Payroll::pay_method::override<
         &Payroll::pay_employee, &Payroll::pay_manager>;
 };
 
diff --git a/tests/test_templates.cpp b/tests/test_templates.cpp
index 5f1ebe01..5b9f6510 100644
--- a/tests/test_templates.cpp
+++ b/tests/test_templates.cpp
@@ -133,19 +133,28 @@ static_assert(
 
 namespace test_add_definition {
 
-struct method {
-    using self_type = method;
-    template<class Container> struct override;
-};
+struct Number {};
+struct Fraction : Number {};
+
+struct negate_;
+using negate = method<negate_(virtual_<const Number&>), Number>;
+
 
 template<typename...>
-struct definition {};
+struct definition;
 
-static_assert(std::is_same_v<
-    detail::use_definition<definition>::fn<types<method, int>>,
-    method::override<definition<method, int>>
+template<class Derived>
+struct definition<negate, Derived> {
+    static auto fn(const Derived&) {
+        return Derived();
+    }
+};
 
+static_assert(std::is_same_v<
+    detail::use_definition<definition>::fn<types<negate, Fraction>>,
+    negate::override<definition<negate, Fraction>::fn>
 >);
+
 }
 
 int main() {
diff --git a/tests/test_virtual_ptr_all.cpp b/tests/test_virtual_ptr_all.cpp
index b23148df..3d0fd079 100644
--- a/tests/test_virtual_ptr_all.cpp
+++ b/tests/test_virtual_ptr_all.cpp
@@ -71,7 +71,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(
     static use_classes<Player, Warrior, Object, Axe, Bear, Policy> YOMM2_GENSYM;
     using kick = method<
         YOMM2_METHOD_NAME(kick)(virtual_ptr<Player, Policy>), std::string, Policy>;
-    static typename kick::template override_fn<
+    static typename kick::template override<
         kick_bear<virtual_ptr<Player, Policy>>>
         YOMM2_GENSYM;
 
@@ -128,7 +128,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(
 
     using kick = method<
         YOMM2_METHOD_NAME(kick)(virtual_ptr<Player, Policy>), std::string, Policy>;
-    static typename kick::template override_fn<
+    static typename kick::template override<
         kick_bear<virtual_ptr<Player, Policy>>>
         YOMM2_GENSYM;
 
@@ -137,7 +137,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(
             virtual_ptr<Player, Policy>, virtual_ptr<Object, Policy>,
             virtual_ptr<Player, Policy>),
         std::string, Policy>;
-    static typename fight::template override_fn<fight_bear<
+    static typename fight::template override<fight_bear<
         virtual_ptr<Player, Policy>, virtual_ptr<Object, Policy>,
         virtual_ptr<Player, Policy>>>
         YOMM2_GENSYM;
@@ -178,7 +178,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(
         YOMM2_METHOD_NAME(kick)(virtual_shared_ptr<Player, Policy>), std::string,
         Policy>;
 
-    static typename kick::template override_fn<
+    static typename kick::template override<
         kick_bear<virtual_shared_ptr<Player, Policy>>>
         YOMM2_GENSYM;
 
@@ -189,7 +189,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(
             virtual_shared_ptr<Player, Policy>),
         std::string, Policy>;
 
-    static typename fight::template override_fn<fight_bear<
+    static typename fight::template override<fight_bear<
         virtual_shared_ptr<Player, Policy>, virtual_shared_ptr<Object, Policy>,
         virtual_shared_ptr<Player, Policy>>>
         YOMM2_GENSYM;
diff --git a/tests/test_virtual_ptr_basic.cpp b/tests/test_virtual_ptr_basic.cpp
index b9f04958..c5c19e5c 100644
--- a/tests/test_virtual_ptr_basic.cpp
+++ b/tests/test_virtual_ptr_basic.cpp
@@ -78,7 +78,7 @@ void kick_dog(virtual_ptr<Dog>, std::ostream& os) {
 
 struct YOMM2_METHOD_NAME(kick);
 using kick = method<YOMM2_METHOD_NAME(kick)(virtual_ptr<Animal>, std::ostream&), void>;
-YOMM2_REGISTER(kick::override_fn<kick_dog>);
+YOMM2_REGISTER(kick::override<kick_dog>);
 
 BOOST_AUTO_TEST_CASE(test_virtual_ptr_by_ref) {
     yorel::yomm2::initialize();
@@ -156,7 +156,7 @@ void kick_dog(virtual_shared_ptr<Dog>, std::ostream& os) {
 struct YOMM2_METHOD_NAME(kick);
 using kick =
     method<YOMM2_METHOD_NAME(kick)(virtual_shared_ptr<Animal>, std::ostream&), void>;
-YOMM2_REGISTER(kick::override_fn<kick_dog>);
+YOMM2_REGISTER(kick::override<kick_dog>);
 
 BOOST_AUTO_TEST_CASE(test_virtual_shared_by_value) {
     yorel::yomm2::initialize();
@@ -179,7 +179,7 @@ void kick_dog(const virtual_shared_ptr<Dog>&, std::ostream& os) {
 struct YOMM2_METHOD_NAME(kick);
 using kick =
     method<YOMM2_METHOD_NAME(kick)(const virtual_shared_ptr<Animal>&, std::ostream&), void>;
-YOMM2_REGISTER(kick::override_fn<kick_dog>);
+YOMM2_REGISTER(kick::override<kick_dog>);
 
 BOOST_AUTO_TEST_CASE(test_virtual_shared_by_const_reference) {
     yorel::yomm2::initialize();
@@ -208,7 +208,7 @@ void kick_dog(virtual_ptr<Dog>, std::ostream& os) {
 
 struct YOMM2_METHOD_NAME(kick);
 using kick = method<YOMM2_METHOD_NAME(kick)(virtual_ptr<Animal>, std::ostream&), void>;
-YOMM2_REGISTER(kick::override_fn<kick_dog>);
+YOMM2_REGISTER(kick::override<kick_dog>);
 
 BOOST_AUTO_TEST_CASE(test_virtual_ptr_non_polymorphic) {
     yorel::yomm2::initialize();