From 982f7026342b80ad68c2055d6d92895ba6579e21 Mon Sep 17 00:00:00 2001
From: Mingxin Wang <mingxwa@microsoft.com>
Date: Fri, 31 May 2024 22:10:44 +0800
Subject: [PATCH 1/6] Implement operator dispatch prototype

---
 README.md                        |  55 ++--
 proxy.h                          | 506 ++++++++++++++++++++++++-----
 tests/CMakeLists.txt             |   1 +
 tests/proxy_creation_tests.cpp   |  96 +++---
 tests/proxy_dispatch_tests.cpp   | 538 +++++++++++++++++++++++++++++++
 tests/proxy_invocation_tests.cpp |  52 +--
 tests/proxy_reflection_tests.cpp |  26 +-
 7 files changed, 1062 insertions(+), 212 deletions(-)
 create mode 100644 tests/proxy_dispatch_tests.cpp

diff --git a/README.md b/README.md
index 0c712850..6594e5f9 100644
--- a/README.md
+++ b/README.md
@@ -22,13 +22,13 @@ The majority of the library is defined in namespace `pro`. Some macros are provi
 
 ```cpp
 // Specifications of abstraction
-namespace spec {
+PRO_DEF_MEM_DISPATCH(MemDraw, Draw);
+PRO_DEF_MEM_DISPATCH(MemArea, Area);
 
-PRO_DEF_MEMBER_DISPATCH(Draw, void(std::ostream& out));
-PRO_DEF_MEMBER_DISPATCH(Area, double() noexcept);
-PRO_DEF_FACADE(Drawable, PRO_MAKE_DISPATCH_PACK(Draw, Area));
-
-}  // namespace spec
+struct Drawable : pro::facade_builder
+    ::add_convention<MemDraw, void(std::ostream& output)>
+    ::add_convention<MemArea, double() noexcept>
+    ::build {};
 
 // Implementation
 class Rectangle {
@@ -45,7 +45,7 @@ class Rectangle {
 };
 
 // Client - Consumer
-std::string PrintDrawableToString(pro::proxy<spec::Drawable> p) {
+std::string PrintDrawableToString(pro::proxy<Drawable> p) {
   std::stringstream result;
   result << "shape = ";
   p.Draw(result);  // Polymorphic call
@@ -54,11 +54,11 @@ std::string PrintDrawableToString(pro::proxy<spec::Drawable> p) {
 }
 
 // Client - Producer
-pro::proxy<spec::Drawable> CreateRectangleAsDrawable(int width, int height) {
+pro::proxy<Drawable> CreateRectangleAsDrawable(int width, int height) {
   Rectangle rect;
   rect.SetWidth(width);
   rect.SetHeight(height);
-  return pro::make_proxy<spec::Drawable>(rect);
+  return pro::make_proxy<Drawable>(rect);
 }
 ```
 
@@ -66,15 +66,16 @@ Here is another demo showing how to define overloads in a dispatch: just to add
 
 ```cpp
 // Specifications of abstraction
-namespace spec {
-
-PRO_DEF_MEMBER_DISPATCH(Log, void(const char*), void(const char*, const std::exception&));
-PRO_DEF_FACADE(Logger, Log);
+PRO_DEF_MEM_DISPATCH(MemLog, Log);
 
-}  // namespace spec
+struct Logger : pro::facade_builder
+    ::add_convention<MemLog,
+        void(const char* message),
+        void(const char* message, const std::exception& ex)>
+    ::build {};
 
 // Client - Consumer
-void MyVerboseFunction(pro::proxy<spec::Logger> logger) {
+void MyVerboseFunction(pro::proxy<Logger> logger) {
   logger.Log("hello");
   try {
     throw std::runtime_error{"runtime error!"};
@@ -101,27 +102,29 @@ int main() {
 }
 ```
 
-By design, the body of a dispatch could be any code. While member function is one useful pattern supported by macro `PRO_DEF_MEMBER_DISPATCH`, free function is also supported with another macro `PRO_DEF_FREE_DISPATCH`. The following example uses `PRO_DEF_FREE_DISPATCH` and `std::invoke` to implement similar function wrapper as `std::function` and `std::move_only_function` and supports multiple overloads.  Note that `.Call` can be omitted when only 1 dispatch is defined in a facade:
+By design, the body of a dispatch could be any code. While member function is one useful pattern supported by macro `PRO_DEF_MEM_DISPATCH`, free function and operators are also supported with macros `PRO_DEF_FREE_DISPATCH` and `PRO_DEF_OPERATOR_DISPATCH`. The following example uses `PRO_DEF_OPERATOR_DISPATCH` to implement similar function wrapper as `std::function` and `std::move_only_function` and supports multiple overloads:
 
 ```cpp
 // Specifications of abstraction
-namespace spec {
+PRO_DEF_OPERATOR_DISPATCH(OpCall, "()");
 
 template <class... Overloads>
-PRO_DEF_FREE_DISPATCH(Call, std::invoke, Overloads...);
-template <class... Overloads>
-PRO_DEF_FACADE(MovableCallable, Call<Overloads...>);
-template <class... Overloads>
-PRO_DEF_FACADE(CopyableCallable, Call<Overloads...>, pro::copyable_ptr_constraints);
+struct MovableCallable : pro::facade_builder
+    ::add_convention<OpCall, Overloads...>
+    ::build {};
 
-}  // namespace spec
+template <class... Overloads>
+struct CopyableCallable : pro::facade_builder
+    ::support_copy<pro::constraint_level::nontrivial>
+    ::add_facade<MovableCallable<Overloads...>>  // Facade inheritance
+    ::build {};
 
 // MyFunction has similar functionality as std::function but supports multiple overloads
 // MyMoveOnlyFunction has similar functionality as std::move_only_function but supports multiple overloads
 template <class... Overloads>
-using MyFunction = pro::proxy<spec::CopyableCallable<Overloads...>>;
+using MyFunction = pro::proxy<CopyableCallable<Overloads...>>;
 template <class... Overloads>
-using MyMoveOnlyFunction = pro::proxy<spec::MovableCallable<Overloads...>>;
+using MyMoveOnlyFunction = pro::proxy<MovableCallable<Overloads...>>;
 
 int main() {
   auto f = [](auto&&... v) {
@@ -139,7 +142,7 @@ int main() {
 }
 ```
 
-Please find more details and discussions in the spec. The complete version of the "drawable" demo could be found in [tests/proxy_integration_tests.cpp](tests/proxy_integration_tests.cpp) (also available on [Compiler Explorer](https://godbolt.org/z/4cK8PPTE1)).
+Please find more details and discussions in the spec. The complete version of the "drawable" demo could be found in [tests/proxy_integration_tests.cpp](tests/proxy_integration_tests.cpp) (also available on [Compiler Explorer](https://godbolt.org/z/zro9dd3Eo)).
 
 ## Minimum requirements for compilers
 
diff --git a/proxy.h b/proxy.h
index 7eac149f..e1a8277e 100644
--- a/proxy.h
+++ b/proxy.h
@@ -9,6 +9,7 @@
 #include <concepts>
 #include <initializer_list>
 #include <memory>
+#include <string_view>
 #include <tuple>
 #include <type_traits>
 #include <utility>
@@ -34,6 +35,10 @@ struct conditional_traits { static constexpr bool applicable = A; };
 using applicable_traits = conditional_traits<true>;
 using inapplicable_traits = conditional_traits<false>;
 
+template <class T, class...> struct lazy_eval_traits : std::type_identity<T> {};
+template <class U, class... T>
+using lazy_eval_t = typename lazy_eval_traits<U, T...>::type;
+
 template <template <class, class> class R, class O, class... Is>
 struct recursive_reduction : std::type_identity<O> {};
 template <template <class, class> class R, class O, class... Is>
@@ -486,6 +491,18 @@ struct meta_ptr<M> : M {
   const M* operator->() const noexcept { return this; }
 };
 
+template <class F>
+struct proxy_helper {
+  template <class M>
+  static const M& get_meta(const proxy<F>& p) noexcept
+      { return *static_cast<const M*>(p.meta_.operator->()); }
+  static inline const std::byte* get_ptr(const proxy<F>& p) noexcept
+      { return p.ptr_; }
+};
+template <class F, class D, class... Args>
+using proxy_overload = typename facade_traits<
+    lazy_eval_t<F, D, Args...>>::template matched_overload<D, Args...>;
+
 }  // namespace details
 
 template <class F>
@@ -497,11 +514,9 @@ concept proxiable = facade<F> && details::ptr_traits<P>::applicable &&
 
 template <class F>
 class proxy : public details::facade_traits<F>::base {
+  friend struct details::proxy_helper<F>;
   using Traits = details::facade_traits<F>;
   static_assert(Traits::applicable);
-  template <class D, class... Args>
-  using MatchedOverload =
-      typename Traits::template matched_overload<D, Args...>;
 
   template <class P, class... Args>
   static constexpr bool HasNothrowPolyConstructor = std::conditional_t<
@@ -542,9 +557,6 @@ class proxy : public details::facade_traits<F>::base {
   static constexpr bool HasNothrowMoveAssignment = HasNothrowMoveConstructor &&
       HasNothrowDestructor;
   static constexpr bool HasMoveAssignment = HasMoveConstructor && HasDestructor;
-  template <class D, class... Args>
-  static constexpr bool HasNothrowInvocation =
-      details::overload_traits<MatchedOverload<D, Args...>>::is_noexcept;
 
  public:
   proxy() noexcept = default;
@@ -682,17 +694,6 @@ class proxy : public details::facade_traits<F>::base {
     reset();
     return initialize<P>(il, std::forward<Args>(args)...);
   }
-  template <class D, class... Args>
-  decltype(auto) invoke(Args&&... args) const
-      noexcept(HasNothrowInvocation<D, Args...>)
-      requires(requires { typename MatchedOverload<D, Args...>; }) {
-    return meta_->template dispatcher_meta<typename details::overload_traits<
-        MatchedOverload<D, Args...>>::template meta_provider<D>>
-        ::dispatcher(ptr_, std::forward<Args>(args)...);
-  }
-  template <class R>
-  const R& reflect() const noexcept requires(Traits::template has_refl<R>)
-      { return *static_cast<const R*>(meta_.operator->()); }
 
  private:
   template <class P, class... Args>
@@ -706,6 +707,24 @@ class proxy : public details::facade_traits<F>::base {
   alignas(F::constraints.max_align) std::byte ptr_[F::constraints.max_size];
 };
 
+template <class D, class F, class... Args>
+decltype(auto) proxy_invoke(const proxy<F>& p, Args&&... args)
+    noexcept(details::overload_traits<details::proxy_overload<F, D, Args...>>
+        ::is_noexcept)
+    requires(requires { typename details::proxy_overload<F, D, Args...>; }) {
+  return details::proxy_helper<F>
+      ::template get_meta<details::dispatcher_meta<
+          typename details::overload_traits<details::proxy_overload<
+              F, D, Args...>>::template meta_provider<D>>>(p)
+      .dispatcher(details::proxy_helper<F>::get_ptr(p),
+          std::forward<Args>(args)...);
+}
+
+template <class R, class F>
+const R& proxy_reflect(const proxy<F>& p) noexcept
+    requires(details::facade_traits<F>::template has_refl<R>)
+    { return details::proxy_helper<F>::template get_meta<R>(p); }
+
 namespace details {
 
 template <class T>
@@ -883,58 +902,45 @@ proxy<F> make_proxy(T&& value) {
 // convention, and facade types prior to C++26
 namespace details {
 
-template <class... Args> void invalid_call(Args&&...) = delete;
-template <class T, class...> struct lazy_eval_traits : std::type_identity<T> {};
-
 constexpr std::size_t invalid_size = static_cast<std::size_t>(-1);
 constexpr constraint_level invalid_cl = static_cast<constraint_level>(-1);
 consteval auto normalize(proxiable_ptr_constraints value) {
-  if (value.max_size == invalid_size) {
-    value.max_size = sizeof(ptr_prototype);
-  }
-  if (value.max_align == invalid_size) {
-    value.max_align = alignof(ptr_prototype);
-  }
-  if (value.copyability == invalid_cl) {
-    value.copyability = constraint_level::none;
-  }
-  if (value.relocatability == invalid_cl) {
-    value.relocatability = constraint_level::nothrow;
-  }
-  if (value.destructibility == invalid_cl) {
-    value.destructibility = constraint_level::nothrow;
-  }
+  if (value.max_size == invalid_size)
+      { value.max_size = sizeof(ptr_prototype); }
+  if (value.max_align == invalid_size)
+      { value.max_align = alignof(ptr_prototype); }
+  if (value.copyability == invalid_cl)
+      { value.copyability = constraint_level::none; }
+  if (value.relocatability == invalid_cl)
+      { value.relocatability = constraint_level::nothrow; }
+  if (value.destructibility == invalid_cl)
+      { value.destructibility = constraint_level::nothrow; }
   return value;
 }
 consteval auto make_restricted_layout(proxiable_ptr_constraints value,
     std::size_t max_size, std::size_t max_align) {
-  if (value.max_size == invalid_size || value.max_size > max_size) {
-    value.max_size = max_size;
-  }
-  if (value.max_align == invalid_size || value.max_align > max_align) {
-    value.max_align = max_align;
-  }
+  if (value.max_size == invalid_size || value.max_size > max_size)
+      { value.max_size = max_size; }
+  if (value.max_align == invalid_size || value.max_align > max_align)
+      { value.max_align = max_align; }
   return value;
 }
 consteval auto make_copyable(proxiable_ptr_constraints value,
     constraint_level cl) {
-  if (value.copyability == invalid_cl || value.copyability < cl) {
-    value.copyability = cl;
-  }
+  if (value.copyability == invalid_cl || value.copyability < cl)
+      { value.copyability = cl; }
   return value;
 }
 consteval auto make_relocatable(proxiable_ptr_constraints value,
     constraint_level cl) {
-  if (value.relocatability == invalid_cl || value.relocatability < cl) {
-    value.relocatability = cl;
-  }
+  if (value.relocatability == invalid_cl || value.relocatability < cl)
+      { value.relocatability = cl; }
   return value;
 }
 consteval auto make_destructible(proxiable_ptr_constraints value,
     constraint_level cl) {
-  if (value.destructibility == invalid_cl || value.destructibility < cl) {
-    value.destructibility = cl;
-  }
+  if (value.destructibility == invalid_cl || value.destructibility < cl)
+      { value.destructibility = cl; }
   return value;
 }
 consteval auto merge_constraints(proxiable_ptr_constraints a,
@@ -1027,12 +1033,6 @@ struct facade_builder_impl {
 
 }  // namespace details
 
-template <class U, class... T>
-using lazy_eval_t = typename details::lazy_eval_traits<U, T...>::type;
-template <class... T>
-auto lazy_eval(auto& value) noexcept -> lazy_eval_t<decltype(value), T...>
-    { return value; }
-
 using facade_builder = details::facade_builder_impl<std::tuple<>, std::tuple<>,
     proxiable_ptr_constraints{
         .max_size = details::invalid_size,
@@ -1041,54 +1041,396 @@ using facade_builder = details::facade_builder_impl<std::tuple<>, std::tuple<>,
         .relocatability = details::invalid_cl,
         .destructibility = details::invalid_cl}>;
 
-}  // namespace pro
+#define ___PRO_DIRECT_FUNC_IMPL(...) \
+    noexcept(noexcept(__VA_ARGS__)) requires(requires { __VA_ARGS__; }) \
+    { return __VA_ARGS__; }
 
-#define ___PRO_DIRECT_FUNC_IMPL(__EXPR) \
-    noexcept(noexcept(__EXPR)) requires(requires { __EXPR; }) { return __EXPR; }
-#define PRO_DEF_MEM_DISPATCH_WITH_DEFAULT(__NAME, __FUNC, __DEFFUNC) \
+#define ___PRO_DEFAULT_DISPATCH_CALL_IMPL(__DEFFUNC) \
+    template <class... __Args> \
+    decltype(auto) operator()(::std::nullptr_t, __Args&&... __args) \
+        ___PRO_DIRECT_FUNC_IMPL(__DEFFUNC(::std::forward<__Args>(__args)...))
+
+#define ___PRO_DEF_MEM_DISPATCH_IMPL(__NAME, __FUNC, ...) \
     struct __NAME { \
       using __name = __NAME; \
-      template <class __T, class... __Args> \
-      decltype(auto) operator()(__T& __self, __Args&&... __args) \
-          ___PRO_DIRECT_FUNC_IMPL( \
-              __self.__FUNC(::std::forward<__Args>(__args)...)) \
       template <class... __Args> \
-      decltype(auto) operator()(std::nullptr_t, __Args&&... __args) \
+      decltype(auto) operator()(auto& __self, __Args&&... __args) \
           ___PRO_DIRECT_FUNC_IMPL( \
-              __DEFFUNC(::std::forward<__Args>(__args)...)) \
+              __self.__FUNC(::std::forward<__Args>(__args)...)) \
       template <class __P> \
       struct accessor { \
         template <class... __Args> \
         decltype(auto) __FUNC(__Args&&... __args) const \
-            ___PRO_DIRECT_FUNC_IMPL((static_cast< \
-                ::pro::lazy_eval_t<const __P&, __Args...>>(*this) \
-                .template invoke<__name>(::std::forward<__Args>(__args)...))) \
+            ___PRO_DIRECT_FUNC_IMPL(::pro::proxy_invoke<__name>( \
+                static_cast<::pro::details::lazy_eval_t<const __P&, \
+                    __Args...>>(*this), ::std::forward<__Args>(__args)...)) \
       }; \
+      __VA_ARGS__ \
     }
-#define PRO_DEF_FREE_DISPATCH_WITH_DEFAULT(__NAME, __FNAME, __FUNC, __DEFFUNC) \
+
+#define ___PRO_DEF_FREE_DISPATCH_IMPL(__NAME, __FNAME, __FUNC, ...) \
     struct __NAME { \
       using __name = __NAME; \
-      template <class __T, class... __Args> \
-      decltype(auto) operator()(__T& __self, __Args&&... __args) \
-          ___PRO_DIRECT_FUNC_IMPL( \
-              __FUNC(__self, ::std::forward<__Args>(__args)...)) \
       template <class... __Args> \
-      decltype(auto) operator()(std::nullptr_t, __Args&&... __args) \
+      decltype(auto) operator()(auto& __self, __Args&&... __args) \
           ___PRO_DIRECT_FUNC_IMPL( \
-              __DEFFUNC(::std::forward<__Args>(__args)...)) \
+              __FUNC(__self, ::std::forward<__Args>(__args)...)) \
       template <class __P> \
       struct accessor { \
         template <class... __Args> \
         friend decltype(auto) __FNAME(const __P& __self, __Args&&... __args) \
-            ___PRO_DIRECT_FUNC_IMPL((::pro::lazy_eval<__Args...>(__self) \
-                .template invoke<__name>(::std::forward<__Args>(__args)...))) \
+            ___PRO_DIRECT_FUNC_IMPL(::pro::proxy_invoke<__name>( \
+                __self, ::std::forward<__Args>(__args)...)) \
       }; \
+      __VA_ARGS__ \
     }
+
 #define PRO_DEF_MEM_DISPATCH(__NAME, __FUNC) \
-    PRO_DEF_MEM_DISPATCH_WITH_DEFAULT( \
-        __NAME, __FUNC, ::pro::details::invalid_call)
+    ___PRO_DEF_MEM_DISPATCH_IMPL(__NAME, __FUNC)
+
+#define PRO_DEF_MEM_DISPATCH_WITH_DEFAULT(__NAME, __FUNC, __DEFFUNC) \
+    ___PRO_DEF_MEM_DISPATCH_IMPL( \
+        __NAME, __FUNC, ___PRO_DEFAULT_DISPATCH_CALL_IMPL(__DEFFUNC))
+
 #define PRO_DEF_FREE_DISPATCH(__NAME, __FNAME, __FUNC) \
-    PRO_DEF_FREE_DISPATCH_WITH_DEFAULT( \
-        __NAME, __FNAME, __FUNC, ::pro::details::invalid_call)
+    ___PRO_DEF_FREE_DISPATCH_IMPL(__NAME, __FNAME, __FUNC)
+
+#define PRO_DEF_FREE_DISPATCH_WITH_DEFAULT(__NAME, __FNAME, __FUNC, __DEFFUNC) \
+    ___PRO_DEF_FREE_DISPATCH_IMPL( \
+        __NAME, __FNAME, __FUNC, ___PRO_DEFAULT_DISPATCH_CALL_IMPL(__DEFFUNC))
+
+namespace details {
+
+enum class sign_type {
+  none, plus, minus, asterisk, slash, percent, increment, decrement,
+  equal_to, not_equal_to, greater_than, less_than, greater_than_or_equal_to,
+  less_than_or_equal_to, spaceship, logical_not, logical_and, logical_or,
+  tilde, ampersand, pipe, caret, left_shift, right_shift, plus_assignment,
+  minus_assignment, multiplication_assignment, division_assignment,
+  bitwise_and_assignment, bitwise_or_assignment, bitwise_xor_assignment,
+  left_shift_assignment, right_shift_assignment, comma, arrow, parentheses,
+  brackets,
+};
+
+enum class sign_pos_type { none, left, right };
+
+consteval sign_type parse_sign(std::string_view str) {
+  if (str == "+") { return sign_type::plus; }
+  if (str == "-") { return sign_type::minus; }
+  if (str == "*") { return sign_type::asterisk; }
+  if (str == "/") { return sign_type::slash; }
+  if (str == "%") { return sign_type::percent; }
+  if (str == "++") { return sign_type::increment; }
+  if (str == "--") { return sign_type::decrement; }
+  if (str == "==") { return sign_type::equal_to; }
+  if (str == "!=") { return sign_type::not_equal_to; }
+  if (str == ">") { return sign_type::greater_than; }
+  if (str == "<") { return sign_type::less_than; }
+  if (str == ">=") { return sign_type::greater_than_or_equal_to; }
+  if (str == "<=") { return sign_type::less_than_or_equal_to; }
+  if (str == "<=>") { return sign_type::spaceship; }
+  if (str == "!") { return sign_type::logical_not; }
+  if (str == "&&") { return sign_type::logical_and; }
+  if (str == "||") { return sign_type::logical_or; }
+  if (str == "~") { return sign_type::tilde; }
+  if (str == "&") { return sign_type::ampersand; }
+  if (str == "|") { return sign_type::pipe; }
+  if (str == "^") { return sign_type::caret; }
+  if (str == "<<") { return sign_type::left_shift; }
+  if (str == ">>") { return sign_type::right_shift; }
+  if (str == "+=") { return sign_type::plus_assignment; }
+  if (str == "-=") { return sign_type::minus_assignment; }
+  if (str == "*=") { return sign_type::multiplication_assignment; }
+  if (str == "/=") { return sign_type::division_assignment; }
+  if (str == "&=") { return sign_type::bitwise_and_assignment; }
+  if (str == "|=") { return sign_type::bitwise_or_assignment; }
+  if (str == "^=") { return sign_type::bitwise_xor_assignment; }
+  if (str == "<<=") { return sign_type::left_shift_assignment; }
+  if (str == ">>=") { return sign_type::right_shift_assignment; }
+  if (str == ",") { return sign_type::comma; }
+  if (str == "->") { return sign_type::arrow; }
+  if (str == "()") { return sign_type::parentheses; }
+  if (str == "[]") { return sign_type::brackets; }
+  return sign_type::none;
+}
+
+template <sign_type SIGN, sign_pos_type POS>
+struct op_dispatch_traits_impl : inapplicable_traits {};
+
+#define ___PRO_OPERATOR_DISPATCH_TRAITS_PREFIX_0_IMPL(SIGN, ...) \
+    template <> \
+    struct op_dispatch_traits_impl<sign_type::SIGN, sign_pos_type::left> \
+        : applicable_traits { \
+      struct base { \
+        decltype(auto) operator()(auto& self) \
+            ___PRO_DIRECT_FUNC_IMPL(__VA_ARGS__ self) \
+      }; \
+      template <class D, class P> \
+      struct accessor { \
+        template <class Barrier = void> \
+        decltype(auto) operator __VA_ARGS__ () const \
+            ___PRO_DIRECT_FUNC_IMPL(proxy_invoke<D>( \
+                static_cast<lazy_eval_t<const P&, Barrier>>(*this))) \
+      }; \
+    };
+
+#define ___PRO_OPERATOR_DISPATCH_TRAITS_PREFIX_1_IMPL(SIGN, ...) \
+    template <> \
+    struct op_dispatch_traits_impl<sign_type::SIGN, sign_pos_type::left> \
+        : applicable_traits { \
+      struct base { \
+        template <class Arg> \
+        decltype(auto) operator()(auto& self, Arg&& arg) \
+            ___PRO_DIRECT_FUNC_IMPL(std::forward<Arg>(arg) __VA_ARGS__ self) \
+      }; \
+      template <class D, class P> \
+      struct accessor { \
+        template <class Arg> \
+        friend decltype(auto) operator __VA_ARGS__ (Arg&& arg, const P& self) \
+            ___PRO_DIRECT_FUNC_IMPL( \
+                proxy_invoke<D>(self, std::forward<Arg>(arg))) \
+      }; \
+    };
+
+#define ___PRO_OPERATOR_DISPATCH_TRAITS_PREFIX_0_OR_1_IMPL(SIGN, ...) \
+    template <> \
+    struct op_dispatch_traits_impl<sign_type::SIGN, sign_pos_type::left> \
+        : applicable_traits { \
+      struct base { \
+        decltype(auto) operator()(auto& self) \
+            ___PRO_DIRECT_FUNC_IMPL(__VA_ARGS__ self) \
+        template <class Arg> \
+        decltype(auto) operator()(auto& self, Arg&& arg) \
+            ___PRO_DIRECT_FUNC_IMPL(std::forward<Arg>(arg) __VA_ARGS__ self) \
+      }; \
+      template <class D, class P> \
+      struct accessor { \
+        template <class Barrier = void> \
+        decltype(auto) operator __VA_ARGS__ () const \
+            ___PRO_DIRECT_FUNC_IMPL(proxy_invoke<D>( \
+                static_cast<lazy_eval_t<const P&, Barrier>>(*this))) \
+        template <class Arg> \
+        friend decltype(auto) operator __VA_ARGS__ (Arg&& arg, const P& self) \
+            ___PRO_DIRECT_FUNC_IMPL( \
+                proxy_invoke<D>(self, std::forward<Arg>(arg))) \
+      }; \
+    };
+
+#define ___PRO_OPERATOR_DISPATCH_TRAITS_POSTFIX_0_IMPL(SIGN, ...) \
+    template <> \
+    struct op_dispatch_traits_impl<sign_type::SIGN, sign_pos_type::right> \
+        : applicable_traits { \
+      struct base { \
+        decltype(auto) operator()(auto& self) \
+            ___PRO_DIRECT_FUNC_IMPL(self __VA_ARGS__) \
+      }; \
+      template <class D, class P> \
+      struct accessor { \
+        template <class Barrier = void> \
+        decltype(auto) operator __VA_ARGS__ (int) const \
+            ___PRO_DIRECT_FUNC_IMPL(proxy_invoke<D>( \
+                static_cast<lazy_eval_t<const P&, Barrier>>(*this))) \
+      }; \
+    };
+
+#define ___PRO_OPERATOR_DISPATCH_TRAITS_POSTFIX_1_IMPL(SIGN, ...) \
+    template <> \
+    struct op_dispatch_traits_impl<sign_type::SIGN, sign_pos_type::right> \
+        : applicable_traits { \
+      struct base { \
+        template <class Arg> \
+        decltype(auto) operator()(auto& self, Arg&& arg) \
+            ___PRO_DIRECT_FUNC_IMPL(self __VA_ARGS__ std::forward<Arg>(arg)) \
+      }; \
+      template <class D, class P> \
+      struct accessor { \
+        template <class Arg> \
+        decltype(auto) operator __VA_ARGS__ (Arg&& arg) const \
+            ___PRO_DIRECT_FUNC_IMPL(proxy_invoke<D>(static_cast< \
+                lazy_eval_t<const P&, Arg>>(*this), std::forward<Arg>(arg))) \
+      }; \
+    };
+
+#define ___PRO_OPERATOR_DISPATCH_TRAITS_ASSIGNMENT_IMPL(SIGN, ...) \
+    template <> \
+    struct op_dispatch_traits_impl<sign_type::SIGN, sign_pos_type::right> \
+        : applicable_traits { \
+      struct base { \
+        template <class Arg> \
+        decltype(auto) operator()(auto& self, Arg&& arg) \
+            ___PRO_DIRECT_FUNC_IMPL(self __VA_ARGS__ std::forward<Arg>(arg)) \
+      }; \
+      template <class D, class P> \
+      struct accessor { \
+        template <class Arg> \
+        const P& operator __VA_ARGS__ (Arg&& arg) const \
+            ___PRO_DIRECT_FUNC_IMPL(proxy_invoke<D>(static_cast< \
+                lazy_eval_t<const P&, Arg>>(*this), std::forward<Arg>(arg)), \
+                static_cast<lazy_eval_t<const P&, Arg>>(*this)) \
+      }; \
+    };
+
+#define ___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(SIGN, ...) \
+    ___PRO_OPERATOR_DISPATCH_TRAITS_PREFIX_1_IMPL(SIGN, __VA_ARGS__) \
+    ___PRO_OPERATOR_DISPATCH_TRAITS_POSTFIX_1_IMPL(SIGN, __VA_ARGS__)
+
+#define ___PRO_OPERATOR_DISPATCH_TRAITS_EXTENDED_BINARY_IMPL(SIGN, ...) \
+    ___PRO_OPERATOR_DISPATCH_TRAITS_PREFIX_0_OR_1_IMPL(SIGN, __VA_ARGS__) \
+    ___PRO_OPERATOR_DISPATCH_TRAITS_POSTFIX_1_IMPL(SIGN, __VA_ARGS__)
+
+___PRO_OPERATOR_DISPATCH_TRAITS_EXTENDED_BINARY_IMPL(plus, +)
+___PRO_OPERATOR_DISPATCH_TRAITS_EXTENDED_BINARY_IMPL(minus, -)
+___PRO_OPERATOR_DISPATCH_TRAITS_EXTENDED_BINARY_IMPL(asterisk, *)
+___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(slash, /)
+___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(percent, %)
+___PRO_OPERATOR_DISPATCH_TRAITS_PREFIX_0_IMPL(increment, ++)
+___PRO_OPERATOR_DISPATCH_TRAITS_POSTFIX_0_IMPL(increment, ++)
+___PRO_OPERATOR_DISPATCH_TRAITS_PREFIX_0_IMPL(decrement, --)
+___PRO_OPERATOR_DISPATCH_TRAITS_POSTFIX_0_IMPL(decrement, --)
+___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(equal_to, ==)
+___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(not_equal_to, !=)
+___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(greater_than, >)
+___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(less_than, <)
+___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(greater_than_or_equal_to, >=)
+___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(less_than_or_equal_to, <=)
+___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(spaceship, <=>)
+___PRO_OPERATOR_DISPATCH_TRAITS_PREFIX_0_IMPL(logical_not, !)
+___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(logical_and, &&)
+___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(logical_or, ||)
+___PRO_OPERATOR_DISPATCH_TRAITS_PREFIX_0_IMPL(tilde, ~)
+___PRO_OPERATOR_DISPATCH_TRAITS_EXTENDED_BINARY_IMPL(ampersand, &)
+___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(pipe, |)
+___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(caret, ^)
+___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(left_shift, <<)
+___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(right_shift, >>)
+___PRO_OPERATOR_DISPATCH_TRAITS_ASSIGNMENT_IMPL(plus_assignment, +=)
+___PRO_OPERATOR_DISPATCH_TRAITS_ASSIGNMENT_IMPL(minus_assignment, -=)
+___PRO_OPERATOR_DISPATCH_TRAITS_ASSIGNMENT_IMPL(multiplication_assignment, *=)
+___PRO_OPERATOR_DISPATCH_TRAITS_ASSIGNMENT_IMPL(division_assignment, /=)
+___PRO_OPERATOR_DISPATCH_TRAITS_ASSIGNMENT_IMPL(bitwise_and_assignment, &=)
+___PRO_OPERATOR_DISPATCH_TRAITS_ASSIGNMENT_IMPL(bitwise_or_assignment, |=)
+___PRO_OPERATOR_DISPATCH_TRAITS_ASSIGNMENT_IMPL(bitwise_xor_assignment, ^=)
+___PRO_OPERATOR_DISPATCH_TRAITS_ASSIGNMENT_IMPL(left_shift_assignment, <<=)
+___PRO_OPERATOR_DISPATCH_TRAITS_ASSIGNMENT_IMPL(right_shift_assignment, >>=)
+___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(comma, ,)
+
+#undef ___PRO_OPERATOR_DISPATCH_TRAITS_EXTENDED_BINARY_IMPL
+#undef ___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL
+#undef ___PRO_OPERATOR_DISPATCH_TRAITS_ASSIGNMENT_IMPL
+#undef ___PRO_OPERATOR_DISPATCH_TRAITS_POSTFIX_1_IMPL
+#undef ___PRO_OPERATOR_DISPATCH_TRAITS_POSTFIX_0_IMPL
+#undef ___PRO_OPERATOR_DISPATCH_TRAITS_PREFIX_0_OR_1_IMPL
+#undef ___PRO_OPERATOR_DISPATCH_TRAITS_PREFIX_1_IMPL
+#undef ___PRO_OPERATOR_DISPATCH_TRAITS_PREFIX_0_IMPL
+
+template <>
+struct op_dispatch_traits_impl<sign_type::arrow, sign_pos_type::right>
+    : applicable_traits {
+  struct base
+      { auto operator()(auto& self) noexcept { return std::addressof(self); } };
+  template <class D, class P>
+  struct accessor {
+    template <class Barrier = void>
+    decltype(auto) operator->() const
+        ___PRO_DIRECT_FUNC_IMPL(proxy_invoke<D>(static_cast<
+            lazy_eval_t<const P&, Barrier>>(*this)))
+  };
+};
+template <>
+struct op_dispatch_traits_impl<sign_type::parentheses, sign_pos_type::right>
+    : applicable_traits {
+  struct base {
+    template <class... Args>
+    decltype(auto) operator()(auto& self, Args&&... args)
+        ___PRO_DIRECT_FUNC_IMPL(self(std::forward<Args>(args)...))
+  };
+  template <class D, class P>
+  struct accessor {
+    template <class... Args>
+    decltype(auto) operator()(Args&&... args) const
+        ___PRO_DIRECT_FUNC_IMPL(proxy_invoke<D>(static_cast<lazy_eval_t<
+            const P&, Args...>>(*this), std::forward<Args>(args)...))
+  };
+};
+template <>
+struct op_dispatch_traits_impl<sign_type::brackets, sign_pos_type::right>
+    : applicable_traits {
+  struct base {
+#if defined(__cpp_multidimensional_subscript) && __cpp_multidimensional_subscript >= 202110L
+    template <class... Args>
+    decltype(auto) operator()(auto& self, Args&&... args)
+        ___PRO_DIRECT_FUNC_IMPL(self[std::forward<Args>(args)...])
+#else
+    template <class Arg>
+    decltype(auto) operator()(auto& self, Arg&& arg)
+        ___PRO_DIRECT_FUNC_IMPL(self[std::forward<Arg>(arg)])
+#endif  // defined(__cpp_multidimensional_subscript) && __cpp_multidimensional_subscript >= 202110L
+  };
+  template <class D, class P>
+  struct accessor {
+    template <class... Args>
+    decltype(auto) operator[](Args&&... args) const
+        ___PRO_DIRECT_FUNC_IMPL(proxy_invoke<D>(static_cast<lazy_eval_t<
+            const P&, Args...>>(*this), std::forward<Args>(args)...))
+  };
+};
+
+template <sign_type SIGN, sign_pos_type POS>
+struct op_dispatch_traits : op_dispatch_traits_impl<SIGN, POS>
+    { static_assert(op_dispatch_traits::applicable, "Unexpected operator"); };
+template <sign_type SIGN>
+    requires(op_dispatch_traits_impl<SIGN, sign_pos_type::right>::applicable)
+struct op_dispatch_traits<SIGN, sign_pos_type::none>
+    : op_dispatch_traits_impl<SIGN, sign_pos_type::right> {};
+template <sign_type SIGN>
+    requires(!op_dispatch_traits_impl<SIGN, sign_pos_type::right>::applicable &&
+        op_dispatch_traits_impl<SIGN, sign_pos_type::left>::applicable)
+struct op_dispatch_traits<SIGN, sign_pos_type::none>
+    : op_dispatch_traits_impl<SIGN, sign_pos_type::left> {};
+
+template <sign_type SIGN, sign_pos_type POS>
+using op_dispatch_base = typename op_dispatch_traits<SIGN, POS>::base;
+template <sign_type SIGN, sign_pos_type POS, class D, class P>
+using op_dispatch_accessor = typename op_dispatch_traits<SIGN, POS>
+    ::template accessor<D, P>;
+
+}  // namespace details
+
+#define ___PRO_MAKE_SIGN_PARAMS(__SIGN, __POS) \
+    ::pro::details::parse_sign(__SIGN), ::pro::details::sign_pos_type::__POS
+
+#define ___PRO_DEF_OPERATOR_DISPATCH_IMPL(__NAME, __SIGN, __POS, ...) \
+    struct __NAME : ::pro::details::op_dispatch_base< \
+        ___PRO_MAKE_SIGN_PARAMS(__SIGN, __POS)> { \
+      using ::pro::details::op_dispatch_base< \
+          ___PRO_MAKE_SIGN_PARAMS(__SIGN, __POS)>::operator(); \
+      template <class __P> \
+      using accessor = ::pro::details::op_dispatch_accessor< \
+          ___PRO_MAKE_SIGN_PARAMS(__SIGN, __POS), __NAME, __P>; \
+      __VA_ARGS__ \
+    };
+
+#define PRO_DEF_OPERATOR_DISPATCH_WITH_DEFAULT(__NAME, __SIGN, __DEFFUNC) \
+    ___PRO_DEF_OPERATOR_DISPATCH_IMPL( \
+        __NAME, __SIGN, none, ___PRO_DEFAULT_DISPATCH_CALL_IMPL(__DEFFUNC))
+
+#define PRO_DEF_OPERATOR_DISPATCH(__NAME, __SIGN) \
+    ___PRO_DEF_OPERATOR_DISPATCH_IMPL(__NAME, __SIGN, none)
+
+#define PRO_DEF_PRE_OPERATOR_DISPATCH_WITH_DEFAULT(__NAME, __SIGN, __DEFFUNC) \
+    ___PRO_DEF_OPERATOR_DISPATCH_IMPL( \
+        __NAME, __SIGN, left, ___PRO_DEFAULT_DISPATCH_CALL_IMPL(__DEFFUNC))
+
+#define PRO_DEF_PRE_OPERATOR_DISPATCH(__NAME, __SIGN) \
+    ___PRO_DEF_OPERATOR_DISPATCH_IMPL(__NAME, __SIGN, left)
+
+#define PRO_DEF_POST_OPERATOR_DISPATCH_WITH_DEFAULT(__NAME, __SIGN, __DEFFUNC) \
+    ___PRO_DEF_OPERATOR_DISPATCH_IMPL( \
+        __NAME, __SIGN, right, ___PRO_DEFAULT_DISPATCH_CALL_IMPL(__DEFFUNC))
+
+#define PRO_DEF_POST_OPERATOR_DISPATCH(__NAME, __SIGN) \
+    ___PRO_DEF_OPERATOR_DISPATCH_IMPL(__NAME, __SIGN, right)
+
+}  // namespace pro
 
 #endif  // _MSFT_PROXY_
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 72182f1f..bd5d82d3 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -1,6 +1,7 @@
 project(msft_proxy_tests)
 add_executable(msft_proxy_tests
   proxy_creation_tests.cpp
+  proxy_dispatch_tests.cpp
   proxy_integration_tests.cpp
   proxy_invocation_tests.cpp
   proxy_lifetime_tests.cpp
diff --git a/tests/proxy_creation_tests.cpp b/tests/proxy_creation_tests.cpp
index b11e7694..ce677769 100644
--- a/tests/proxy_creation_tests.cpp
+++ b/tests/proxy_creation_tests.cpp
@@ -87,7 +87,7 @@ TEST(ProxyCreationTests, TestMakeProxyInplace_FromValue) {
     auto p = pro::make_proxy_inplace<spec::TestLargeStringable>(session);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(p), "Session 2");
-    ASSERT_TRUE(p.reflect<SboObserver>().SboEnabled);
+    ASSERT_TRUE(pro::proxy_reflect<SboObserver>(p).SboEnabled);
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -102,7 +102,7 @@ TEST(ProxyCreationTests, TestMakeProxyInplace_InPlace) {
     auto p = pro::make_proxy_inplace<spec::TestLargeStringable, utils::LifetimeTracker::Session>(&tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(p), "Session 1");
-    ASSERT_TRUE(p.reflect<SboObserver>().SboEnabled);
+    ASSERT_TRUE(pro::proxy_reflect<SboObserver>(p).SboEnabled);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -117,7 +117,7 @@ TEST(ProxyCreationTests, TestMakeProxyInplace_InPlaceInitializerList) {
     auto p = pro::make_proxy_inplace<spec::TestLargeStringable, utils::LifetimeTracker::Session>({ 1, 2, 3 }, &tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(p), "Session 1");
-    ASSERT_TRUE(p.reflect<SboObserver>().SboEnabled);
+    ASSERT_TRUE(pro::proxy_reflect<SboObserver>(p).SboEnabled);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kInitializerListConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -134,10 +134,10 @@ TEST(ProxyCreationTests, TestMakeProxyInplace_Lifetime_Copy) {
     auto p2 = p1;
     ASSERT_TRUE(p1.has_value());
     ASSERT_EQ(ToString(p1), "Session 1");
-    ASSERT_TRUE(p1.reflect<SboObserver>().SboEnabled);
+    ASSERT_TRUE(pro::proxy_reflect<SboObserver>(p1).SboEnabled);
     ASSERT_TRUE(p2.has_value());
     ASSERT_EQ(ToString(p2), "Session 2");
-    ASSERT_TRUE(p2.reflect<SboObserver>().SboEnabled);
+    ASSERT_TRUE(pro::proxy_reflect<SboObserver>(p2).SboEnabled);
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -156,7 +156,7 @@ TEST(ProxyCreationTests, TestMakeProxyInplace_Lifetime_Move) {
     ASSERT_FALSE(p1.has_value());
     ASSERT_TRUE(p2.has_value());
     ASSERT_EQ(ToString(p2), "Session 2");
-    ASSERT_TRUE(p2.reflect<SboObserver>().SboEnabled);
+    ASSERT_TRUE(pro::proxy_reflect<SboObserver>(p2).SboEnabled);
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kMoveConstruction);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -174,8 +174,8 @@ TEST(ProxyCreationTests, TestAllocateProxy_DirectAllocator_FromValue) {
     auto p = pro::allocate_proxy<spec::TestSmallStringable>(std::allocator<void>{}, session);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(p), "Session 2");
-    ASSERT_FALSE(p.reflect<SboObserver>().SboEnabled);
-    ASSERT_FALSE(p.reflect<SboObserver>().AllocatorAllocatesForItself);
+    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p).SboEnabled);
+    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p).AllocatorAllocatesForItself);
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -190,8 +190,8 @@ TEST(ProxyCreationTests, TestAllocateProxy_DirectAllocator_InPlace) {
     auto p = pro::allocate_proxy<spec::TestSmallStringable, utils::LifetimeTracker::Session>(std::allocator<void>{}, & tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(p), "Session 1");
-    ASSERT_FALSE(p.reflect<SboObserver>().SboEnabled);
-    ASSERT_FALSE(p.reflect<SboObserver>().AllocatorAllocatesForItself);
+    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p).SboEnabled);
+    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p).AllocatorAllocatesForItself);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -206,8 +206,8 @@ TEST(ProxyCreationTests, TestAllocateProxy_DirectAllocator_InPlaceInitializerLis
     auto p = pro::allocate_proxy<spec::TestSmallStringable, utils::LifetimeTracker::Session>(std::allocator<void>{}, { 1, 2, 3 }, & tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(p), "Session 1");
-    ASSERT_FALSE(p.reflect<SboObserver>().SboEnabled);
-    ASSERT_FALSE(p.reflect<SboObserver>().AllocatorAllocatesForItself);
+    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p).SboEnabled);
+    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p).AllocatorAllocatesForItself);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kInitializerListConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -224,12 +224,12 @@ TEST(ProxyCreationTests, TestAllocateProxy_DirectAllocator_Lifetime_Copy) {
     auto p2 = p1;
     ASSERT_TRUE(p1.has_value());
     ASSERT_EQ(ToString(p1), "Session 1");
-    ASSERT_FALSE(p1.reflect<SboObserver>().SboEnabled);
-    ASSERT_FALSE(p1.reflect<SboObserver>().AllocatorAllocatesForItself);
+    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p1).SboEnabled);
+    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p1).AllocatorAllocatesForItself);
     ASSERT_TRUE(p2.has_value());
     ASSERT_EQ(ToString(p2), "Session 2");
-    ASSERT_FALSE(p2.reflect<SboObserver>().SboEnabled);
-    ASSERT_FALSE(p2.reflect<SboObserver>().AllocatorAllocatesForItself);
+    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p2).SboEnabled);
+    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p2).AllocatorAllocatesForItself);
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -248,8 +248,8 @@ TEST(ProxyCreationTests, TestAllocateProxy_DirectAllocator_Lifetime_Move) {
     ASSERT_FALSE(p1.has_value());
     ASSERT_TRUE(p2.has_value());
     ASSERT_EQ(ToString(p2), "Session 1");
-    ASSERT_FALSE(p2.reflect<SboObserver>().SboEnabled);
-    ASSERT_FALSE(p2.reflect<SboObserver>().AllocatorAllocatesForItself);
+    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p2).SboEnabled);
+    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p2).AllocatorAllocatesForItself);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
   expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
@@ -266,8 +266,8 @@ TEST(ProxyCreationTests, TestAllocateProxy_IndirectAllocator_FromValue) {
     auto p = pro::allocate_proxy<spec::TestSmallStringable>(std::pmr::polymorphic_allocator<>{&memory_pool}, session);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(p), "Session 2");
-    ASSERT_FALSE(p.reflect<SboObserver>().SboEnabled);
-    ASSERT_TRUE(p.reflect<SboObserver>().AllocatorAllocatesForItself);
+    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p).SboEnabled);
+    ASSERT_TRUE(pro::proxy_reflect<SboObserver>(p).AllocatorAllocatesForItself);
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -283,8 +283,8 @@ TEST(ProxyCreationTests, TestAllocateProxy_IndirectAllocator_InPlace) {
     auto p = pro::allocate_proxy<spec::TestSmallStringable, utils::LifetimeTracker::Session>(std::pmr::polymorphic_allocator<>{&memory_pool}, & tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(p), "Session 1");
-    ASSERT_FALSE(p.reflect<SboObserver>().SboEnabled);
-    ASSERT_TRUE(p.reflect<SboObserver>().AllocatorAllocatesForItself);
+    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p).SboEnabled);
+    ASSERT_TRUE(pro::proxy_reflect<SboObserver>(p).AllocatorAllocatesForItself);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -300,8 +300,8 @@ TEST(ProxyCreationTests, TestAllocateProxy_IndirectAllocator_InPlaceInitializerL
     auto p = pro::allocate_proxy<spec::TestSmallStringable, utils::LifetimeTracker::Session>(std::pmr::polymorphic_allocator<>{&memory_pool}, { 1, 2, 3 }, & tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(p), "Session 1");
-    ASSERT_FALSE(p.reflect<SboObserver>().SboEnabled);
-    ASSERT_TRUE(p.reflect<SboObserver>().AllocatorAllocatesForItself);
+    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p).SboEnabled);
+    ASSERT_TRUE(pro::proxy_reflect<SboObserver>(p).AllocatorAllocatesForItself);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kInitializerListConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -319,12 +319,12 @@ TEST(ProxyCreationTests, TestAllocateProxy_IndirectAllocator_Lifetime_Copy) {
     auto p2 = p1;
     ASSERT_TRUE(p1.has_value());
     ASSERT_EQ(ToString(p1), "Session 1");
-    ASSERT_FALSE(p1.reflect<SboObserver>().SboEnabled);
-    ASSERT_TRUE(p1.reflect<SboObserver>().AllocatorAllocatesForItself);
+    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p1).SboEnabled);
+    ASSERT_TRUE(pro::proxy_reflect<SboObserver>(p1).AllocatorAllocatesForItself);
     ASSERT_TRUE(p2.has_value());
     ASSERT_EQ(ToString(p2), "Session 2");
-    ASSERT_FALSE(p2.reflect<SboObserver>().SboEnabled);
-    ASSERT_TRUE(p2.reflect<SboObserver>().AllocatorAllocatesForItself);
+    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p2).SboEnabled);
+    ASSERT_TRUE(pro::proxy_reflect<SboObserver>(p2).AllocatorAllocatesForItself);
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -344,8 +344,8 @@ TEST(ProxyCreationTests, TestAllocateProxy_IndirectAllocator_Lifetime_Move) {
     ASSERT_FALSE(p1.has_value());
     ASSERT_TRUE(p2.has_value());
     ASSERT_EQ(ToString(p2), "Session 1");
-    ASSERT_FALSE(p2.reflect<SboObserver>().SboEnabled);
-    ASSERT_TRUE(p2.reflect<SboObserver>().AllocatorAllocatesForItself);
+    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p2).SboEnabled);
+    ASSERT_TRUE(pro::proxy_reflect<SboObserver>(p2).AllocatorAllocatesForItself);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
   expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
@@ -361,7 +361,7 @@ TEST(ProxyCreationTests, TestMakeProxy_WithSBO_FromValue) {
     auto p = pro::make_proxy<spec::TestLargeStringable>(session);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(p), "Session 2");
-    ASSERT_TRUE(p.reflect<SboObserver>().SboEnabled);
+    ASSERT_TRUE(pro::proxy_reflect<SboObserver>(p).SboEnabled);
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -376,7 +376,7 @@ TEST(ProxyCreationTests, TestMakeProxy_WithSBO_InPlace) {
     auto p = pro::make_proxy<spec::TestLargeStringable, utils::LifetimeTracker::Session>(&tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(p), "Session 1");
-    ASSERT_TRUE(p.reflect<SboObserver>().SboEnabled);
+    ASSERT_TRUE(pro::proxy_reflect<SboObserver>(p).SboEnabled);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -391,7 +391,7 @@ TEST(ProxyCreationTests, TestMakeProxy_WithSBO_InPlaceInitializerList) {
     auto p = pro::make_proxy<spec::TestLargeStringable, utils::LifetimeTracker::Session>({ 1, 2, 3 }, &tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(p), "Session 1");
-    ASSERT_TRUE(p.reflect<SboObserver>().SboEnabled);
+    ASSERT_TRUE(pro::proxy_reflect<SboObserver>(p).SboEnabled);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kInitializerListConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -408,10 +408,10 @@ TEST(ProxyCreationTests, TestMakeProxy_WithSBO_Lifetime_Copy) {
     auto p2 = p1;
     ASSERT_TRUE(p1.has_value());
     ASSERT_EQ(ToString(p1), "Session 1");
-    ASSERT_TRUE(p1.reflect<SboObserver>().SboEnabled);
+    ASSERT_TRUE(pro::proxy_reflect<SboObserver>(p1).SboEnabled);
     ASSERT_TRUE(p2.has_value());
     ASSERT_EQ(ToString(p2), "Session 2");
-    ASSERT_TRUE(p2.reflect<SboObserver>().SboEnabled);
+    ASSERT_TRUE(pro::proxy_reflect<SboObserver>(p2).SboEnabled);
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -430,7 +430,7 @@ TEST(ProxyCreationTests, TestMakeProxy_WithSBO_Lifetime_Move) {
     ASSERT_FALSE(p1.has_value());
     ASSERT_TRUE(p2.has_value());
     ASSERT_EQ(ToString(p2), "Session 2");
-    ASSERT_TRUE(p2.reflect<SboObserver>().SboEnabled);
+    ASSERT_TRUE(pro::proxy_reflect<SboObserver>(p2).SboEnabled);
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kMoveConstruction);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
@@ -448,8 +448,8 @@ TEST(ProxyCreationTests, TestMakeProxy_WithoutSBO_FromValue) {
     auto p = pro::make_proxy<spec::TestSmallStringable>(session);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(p), "Session 2");
-    ASSERT_FALSE(p.reflect<SboObserver>().SboEnabled);
-    ASSERT_FALSE(p.reflect<SboObserver>().AllocatorAllocatesForItself);
+    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p).SboEnabled);
+    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p).AllocatorAllocatesForItself);
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -464,8 +464,8 @@ TEST(ProxyCreationTests, TestMakeProxy_WithoutSBO_InPlace) {
     auto p = pro::make_proxy<spec::TestSmallStringable, utils::LifetimeTracker::Session>(&tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(p), "Session 1");
-    ASSERT_FALSE(p.reflect<SboObserver>().SboEnabled);
-    ASSERT_FALSE(p.reflect<SboObserver>().AllocatorAllocatesForItself);
+    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p).SboEnabled);
+    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p).AllocatorAllocatesForItself);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kValueConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -480,8 +480,8 @@ TEST(ProxyCreationTests, TestMakeProxy_WithoutSBO_InPlaceInitializerList) {
     auto p = pro::make_proxy<spec::TestSmallStringable, utils::LifetimeTracker::Session>({ 1, 2, 3 }, &tracker);
     ASSERT_TRUE(p.has_value());
     ASSERT_EQ(ToString(p), "Session 1");
-    ASSERT_FALSE(p.reflect<SboObserver>().SboEnabled);
-    ASSERT_FALSE(p.reflect<SboObserver>().AllocatorAllocatesForItself);
+    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p).SboEnabled);
+    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p).AllocatorAllocatesForItself);
     expected_ops.emplace_back(1, utils::LifetimeOperationType::kInitializerListConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -498,12 +498,12 @@ TEST(ProxyCreationTests, TestMakeProxy_WithoutSBO_Lifetime_Copy) {
     auto p2 = p1;
     ASSERT_TRUE(p1.has_value());
     ASSERT_EQ(ToString(p1), "Session 1");
-    ASSERT_FALSE(p1.reflect<SboObserver>().SboEnabled);
-    ASSERT_FALSE(p1.reflect<SboObserver>().AllocatorAllocatesForItself);
+    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p1).SboEnabled);
+    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p1).AllocatorAllocatesForItself);
     ASSERT_TRUE(p2.has_value());
     ASSERT_EQ(ToString(p2), "Session 2");
-    ASSERT_FALSE(p2.reflect<SboObserver>().SboEnabled);
-    ASSERT_FALSE(p2.reflect<SboObserver>().AllocatorAllocatesForItself);
+    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p2).SboEnabled);
+    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p2).AllocatorAllocatesForItself);
     expected_ops.emplace_back(2, utils::LifetimeOperationType::kCopyConstruction);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
@@ -522,8 +522,8 @@ TEST(ProxyCreationTests, TestMakeProxy_WithoutSBO_Lifetime_Move) {
     ASSERT_FALSE(p1.has_value());
     ASSERT_TRUE(p2.has_value());
     ASSERT_EQ(ToString(p2), "Session 1");
-    ASSERT_FALSE(p2.reflect<SboObserver>().SboEnabled);
-    ASSERT_FALSE(p2.reflect<SboObserver>().AllocatorAllocatesForItself);
+    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p2).SboEnabled);
+    ASSERT_FALSE(pro::proxy_reflect<SboObserver>(p2).AllocatorAllocatesForItself);
     ASSERT_TRUE(tracker.GetOperations() == expected_ops);
   }
   expected_ops.emplace_back(1, utils::LifetimeOperationType::kDestruction);
diff --git a/tests/proxy_dispatch_tests.cpp b/tests/proxy_dispatch_tests.cpp
new file mode 100644
index 00000000..7aae92e5
--- /dev/null
+++ b/tests/proxy_dispatch_tests.cpp
@@ -0,0 +1,538 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include <gtest/gtest.h>
+#include "proxy.h"
+
+namespace {
+
+PRO_DEF_OPERATOR_DISPATCH(OpPlus, "+");
+PRO_DEF_OPERATOR_DISPATCH(OpMinus, "-");
+PRO_DEF_OPERATOR_DISPATCH(OpAsterisk, "*");
+PRO_DEF_OPERATOR_DISPATCH(OpSlash, "/");
+PRO_DEF_OPERATOR_DISPATCH(OpPercent, "%");
+PRO_DEF_OPERATOR_DISPATCH(OpIncrement, "++");
+PRO_DEF_OPERATOR_DISPATCH(OpDecrement, "--");
+PRO_DEF_OPERATOR_DISPATCH(OpEqualTo, "==");
+PRO_DEF_OPERATOR_DISPATCH(OpNotEqualTo, "!=");
+PRO_DEF_OPERATOR_DISPATCH(OpGreaterThan, ">");
+PRO_DEF_OPERATOR_DISPATCH(OpLessThan, "<");
+PRO_DEF_OPERATOR_DISPATCH(OpGreaterThanOrEqualTo, ">=");
+PRO_DEF_OPERATOR_DISPATCH(OpLessThanOrEqualTo, "<=");
+PRO_DEF_OPERATOR_DISPATCH(OpSpaceship, "<=>");
+PRO_DEF_OPERATOR_DISPATCH(OpLogicalNot, "!");
+PRO_DEF_OPERATOR_DISPATCH(OpLogicalAnd, "&&");
+PRO_DEF_OPERATOR_DISPATCH(OpLogicalOr, "||");
+PRO_DEF_OPERATOR_DISPATCH(OpTilde, "~");
+PRO_DEF_OPERATOR_DISPATCH(OpAmpersand, "&");
+PRO_DEF_OPERATOR_DISPATCH(OpPipe, "|");
+PRO_DEF_OPERATOR_DISPATCH(OpCaret, "^");
+PRO_DEF_OPERATOR_DISPATCH(OpLeftShift, "<<");
+PRO_DEF_OPERATOR_DISPATCH(OpRightShift, ">>");
+PRO_DEF_OPERATOR_DISPATCH(OpPlusAssignment, "+=");
+PRO_DEF_OPERATOR_DISPATCH(OpMinusAssignment, "-=");
+PRO_DEF_OPERATOR_DISPATCH(OpMultiplicationAssignment, "*=");
+PRO_DEF_OPERATOR_DISPATCH(OpDivisionAssignment, "/=");
+PRO_DEF_OPERATOR_DISPATCH(OpBitwiseAndAssignment, "&=");
+PRO_DEF_OPERATOR_DISPATCH(OpBitwiseOrAssignment, "|=");
+PRO_DEF_OPERATOR_DISPATCH(OpBitwiseXorAssignment, "^=");
+PRO_DEF_OPERATOR_DISPATCH(OpLeftShiftAssignment, "<<=");
+PRO_DEF_OPERATOR_DISPATCH(OpRightShiftAssignment, ">>=");
+PRO_DEF_OPERATOR_DISPATCH(OpComma, ",");
+PRO_DEF_OPERATOR_DISPATCH(OpArrow, "->");
+PRO_DEF_OPERATOR_DISPATCH(OpParentheses, "()");
+PRO_DEF_OPERATOR_DISPATCH(OpBrackets, "[]");
+
+PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpPlus, "+");
+PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpMinus, "-");
+PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpAsterisk, "*");
+PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpSlash, "/");
+PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpPercent, "%");
+PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpIncrement, "++");
+PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpDecrement, "--");
+PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpEqualTo, "==");
+PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpNotEqualTo, "!=");
+PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpGreaterThan, ">");
+PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpLessThan, "<");
+PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpGreaterThanOrEqualTo, ">=");
+PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpLessThanOrEqualTo, "<=");
+PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpSpaceship, "<=>");
+PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpLogicalAnd, "&&");
+PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpLogicalOr, "||");
+PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpAmpersand, "&");
+PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpPipe, "|");
+PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpCaret, "^");
+PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpLeftShift, "<<");
+PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpRightShift, ">>");
+PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpComma, ",");
+
+struct CommaTester {
+public:
+  explicit CommaTester(int v) : value_(v) {}
+  int operator,(int v) { return value_ + v; }
+  friend int operator,(int v, CommaTester c) { return v * c.value_; }
+
+private:
+  int value_;
+};
+
+}  // namespace
+
+TEST(ProxyDispatchTests, TestOpPlus) {
+  struct TestFacade : pro::facade_builder::add_convention<OpPlus, int(int val)>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(p + 2, 14);
+}
+
+TEST(ProxyDispatchTests, TestOpMinus) {
+  struct TestFacade : pro::facade_builder::add_convention<OpMinus, int(int val)>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(p - 2, 10);
+}
+
+TEST(ProxyDispatchTests, TestOpAsterisk) {
+  struct TestFacade : pro::facade_builder::add_convention<OpAsterisk, int(int val)>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(p * 2, 24);
+}
+
+TEST(ProxyDispatchTests, TestOpSlash) {
+  struct TestFacade : pro::facade_builder::add_convention<OpSlash, int(int val)>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(p / 2, 6);
+}
+
+TEST(ProxyDispatchTests, TestOpPercent) {
+  struct TestFacade : pro::facade_builder::add_convention<OpPercent, int(int val)>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(p % 5, 2);
+}
+
+TEST(ProxyDispatchTests, TestOpIncrement) {
+  struct TestFacade : pro::facade_builder::add_convention<OpIncrement, int()>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(p++, 12);
+  ASSERT_EQ(v, 13);
+}
+
+TEST(ProxyDispatchTests, TestOpDecrement) {
+  struct TestFacade : pro::facade_builder::add_convention<OpDecrement, int()>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(p--, 12);
+  ASSERT_EQ(v, 11);
+}
+
+TEST(ProxyDispatchTests, TestOpEqualTo) {
+  struct TestFacade : pro::facade_builder::add_convention<OpEqualTo, int(int val)>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(p == 12, true);
+  ASSERT_EQ(p == 11, false);
+}
+
+TEST(ProxyDispatchTests, TestOpNotEqualTo) {
+  struct TestFacade : pro::facade_builder::add_convention<OpNotEqualTo, int(int val)>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(p != 12, false);
+  ASSERT_EQ(p != 11, true);
+}
+
+TEST(ProxyDispatchTests, TestOpGreaterThan) {
+  struct TestFacade : pro::facade_builder::add_convention<OpGreaterThan, int(int val)>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(p > 2, true);
+  ASSERT_EQ(p > 20, false);
+}
+
+TEST(ProxyDispatchTests, TestOpLessThan) {
+  struct TestFacade : pro::facade_builder::add_convention<OpLessThan, int(int val)>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(p < 2, false);
+  ASSERT_EQ(p < 20, true);
+}
+
+TEST(ProxyDispatchTests, TestOpGreaterThanOrEqualTo) {
+  struct TestFacade : pro::facade_builder::add_convention<OpGreaterThanOrEqualTo, int(int val)>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(p >= 20, false);
+  ASSERT_EQ(p >= 12, true);
+}
+
+TEST(ProxyDispatchTests, TestOpLessThanOrEqualTo) {
+  struct TestFacade : pro::facade_builder::add_convention<OpLessThanOrEqualTo, int(int val)>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(p <= 2, false);
+  ASSERT_EQ(p <= 12, true);
+}
+
+TEST(ProxyDispatchTests, TestOpSpaceship) {
+  struct TestFacade : pro::facade_builder::add_convention<OpSpaceship, std::strong_ordering(int val)>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(p <=> 2, std::strong_ordering::greater);
+  ASSERT_EQ(p <=> 12, std::strong_ordering::equal);
+  ASSERT_EQ(p <=> 20, std::strong_ordering::less);
+}
+
+TEST(ProxyDispatchTests, TestOpLogicalNot) {
+  struct TestFacade : pro::facade_builder::add_convention<OpLogicalNot, bool()>::build {};
+  int v1 = 12, v2 = 0;
+  pro::proxy<TestFacade> p1 = &v1, p2 = &v2;
+  ASSERT_EQ(!p1, false);
+  ASSERT_EQ(!p2, true);
+}
+
+TEST(ProxyDispatchTests, TestOpLogicalAnd) {
+  struct TestFacade : pro::facade_builder::add_convention<OpLogicalAnd, bool(bool val)>::build {};
+  bool v = true;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(p && true, true);
+  ASSERT_EQ(p && false, false);
+}
+
+TEST(ProxyDispatchTests, TestOpLogicalOr) {
+  struct TestFacade : pro::facade_builder::add_convention<OpLogicalOr, bool(bool val)>::build {};
+  bool v = false;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(v || true, true);
+  ASSERT_EQ(v || false, false);
+}
+
+TEST(ProxyDispatchTests, TestOpTilde) {
+  struct TestFacade : pro::facade_builder::add_convention<OpTilde, int()>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(~v, -13);
+}
+
+TEST(ProxyDispatchTests, TestOpAmpersand) {
+  struct TestFacade : pro::facade_builder::add_convention<OpAmpersand, int(int val)>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(p & 4, 4);
+}
+
+TEST(ProxyDispatchTests, TestOpPipe) {
+  struct TestFacade : pro::facade_builder::add_convention<OpPipe, int(int val)>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(p | 6, 14);
+}
+
+TEST(ProxyDispatchTests, TestOpCaret) {
+  struct TestFacade : pro::facade_builder::add_convention<OpCaret, int(int val)>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(p ^ 5, 9);
+}
+
+TEST(ProxyDispatchTests, TestOpLeftShift) {
+  struct TestFacade : pro::facade_builder::add_convention<OpLeftShift, int(int val)>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(p << 2, 48);
+}
+
+TEST(ProxyDispatchTests, TestOpRightShift) {
+  struct TestFacade : pro::facade_builder::add_convention<OpRightShift, int(int val)>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(p >> 2, 3);
+}
+
+TEST(ProxyDispatchTests, TestOpPlusAssignment) {
+  struct TestFacade : pro::facade_builder::add_convention<OpPlusAssignment, void(int val)>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_TRUE((p += 2).has_value());
+  ASSERT_EQ(v, 14);
+}
+
+TEST(ProxyDispatchTests, TestOpMinusAssignment) {
+  struct TestFacade : pro::facade_builder::add_convention<OpMinusAssignment, void(int val)>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_TRUE((p -= 2).has_value());
+  ASSERT_EQ(v, 10);
+}
+
+TEST(ProxyDispatchTests, TestOpMultiplicationAssignment) {
+  struct TestFacade : pro::facade_builder::add_convention<OpMultiplicationAssignment, void(int val)>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_TRUE((p *= 2).has_value());
+  ASSERT_EQ(v, 24);
+}
+
+TEST(ProxyDispatchTests, TestOpDivisionAssignment) {
+  struct TestFacade : pro::facade_builder::add_convention<OpDivisionAssignment, void(int val)>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_TRUE((p /= 2).has_value());
+  ASSERT_EQ(v, 6);
+}
+
+TEST(ProxyDispatchTests, TestOpBitwiseAndAssignment) {
+  struct TestFacade : pro::facade_builder::add_convention<OpBitwiseAndAssignment, void(int val)>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_TRUE((p &= 6).has_value());
+  ASSERT_EQ(v, 4);
+}
+
+TEST(ProxyDispatchTests, TestOpBitwiseOrAssignment) {
+  struct TestFacade : pro::facade_builder::add_convention<OpBitwiseOrAssignment, void(int val)>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_TRUE((p |= 2).has_value());
+  ASSERT_EQ(v, 14);
+}
+
+TEST(ProxyDispatchTests, TestOpBitwiseXorAssignment) {
+  struct TestFacade : pro::facade_builder::add_convention<OpBitwiseXorAssignment, void(int val)>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_TRUE((p ^= 6).has_value());
+  ASSERT_EQ(v, 10);
+}
+
+TEST(ProxyDispatchTests, TestOpLeftShiftAssignment) {
+  struct TestFacade : pro::facade_builder::add_convention<OpLeftShiftAssignment, void(int val)>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_TRUE((p <<= 2).has_value());
+  ASSERT_EQ(v, 48);
+}
+
+TEST(ProxyDispatchTests, TestOpRightShiftAssignment) {
+  struct TestFacade : pro::facade_builder::add_convention<OpRightShiftAssignment, void(int val)>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_TRUE((p >>= 2).has_value());
+  ASSERT_EQ(v, 3);
+}
+
+TEST(ProxyDispatchTests, TestOpComma) {
+  struct TestFacade : pro::facade_builder::add_convention<OpComma, int(int val)>::build {};
+  CommaTester v{3};
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ((p, 6), 9);
+}
+
+TEST(ProxyDispatchTests, TestOpArrow) {
+  struct TestFacade : pro::facade_builder::add_convention<OpArrow, const void*()>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(std::to_address(p), &v);
+}
+
+TEST(ProxyDispatchTests, TestOpParentheses) {
+  struct TestFacade : pro::facade_builder::add_convention<OpParentheses, int(int a, int b)>::build {};
+  auto v = [](auto&&... args) { return (args + ...); };
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(p(2, 3), 5);
+}
+
+TEST(ProxyDispatchTests, TestOpBrackets) {
+  struct TestFacade : pro::facade_builder::add_convention<OpBrackets, int&(int idx)>::build {};
+  std::unordered_map<int, int> v;
+  pro::proxy<TestFacade> p = &v;
+  p[3] = 12;
+  ASSERT_EQ(v.size(), 1u);
+  ASSERT_EQ(v.at(3), 12);
+}
+
+TEST(ProxyDispatchTests, TestPreOpPlus) {
+  struct TestFacade : pro::facade_builder::add_convention<PreOpPlus, int(), int(int val)>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(+p, 12);
+  ASSERT_EQ(2 + p, 14);
+}
+
+TEST(ProxyDispatchTests, TestPreOpMinus) {
+  struct TestFacade : pro::facade_builder::add_convention<PreOpMinus, int(), int(int val)>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(-p, -12);
+  ASSERT_EQ(2 - p, -10);
+}
+
+TEST(ProxyDispatchTests, TestPreOpAsterisk) {
+  struct TestFacade : pro::facade_builder::add_convention<PreOpAsterisk, int(), int(int val)>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(*p, 12);
+  ASSERT_EQ(2 * p, 24);
+}
+
+TEST(ProxyDispatchTests, TestPreOpSlash) {
+  struct TestFacade : pro::facade_builder::add_convention<PreOpSlash, int(int val)>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(50 / p, 4);
+}
+
+TEST(ProxyDispatchTests, TestPreOpPercent) {
+  struct TestFacade : pro::facade_builder::add_convention<PreOpPercent, int(int val)>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(26 % p, 2);
+}
+
+TEST(ProxyDispatchTests, TestPreOpIncrement) {
+  struct TestFacade : pro::facade_builder::add_convention<PreOpIncrement, int()>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(++p, 13);
+  ASSERT_EQ(v, 13);
+}
+
+TEST(ProxyDispatchTests, TestPreOpDecrement) {
+  struct TestFacade : pro::facade_builder::add_convention<PreOpDecrement, int()>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(--p, 11);
+  ASSERT_EQ(v, 11);
+}
+
+TEST(ProxyDispatchTests, TestPreOpEqualTo) {
+  struct TestFacade : pro::facade_builder::add_convention<PreOpEqualTo, bool(int val)>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(2 == p, false);
+  ASSERT_EQ(12 == p, true);
+}
+
+TEST(ProxyDispatchTests, TestPreOpNotEqualTo) {
+  struct TestFacade : pro::facade_builder::add_convention<PreOpNotEqualTo, bool(int val)>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(2 != p, true);
+  ASSERT_EQ(12 != p, false);
+}
+
+TEST(ProxyDispatchTests, TestPreOpGreaterThan) {
+  struct TestFacade : pro::facade_builder::add_convention<PreOpGreaterThan, bool(int val)>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(12 > p, false);
+  ASSERT_EQ(13 > p, true);
+}
+
+TEST(ProxyDispatchTests, TestPreOpLessThan) {
+  struct TestFacade : pro::facade_builder::add_convention<PreOpLessThan, bool(int val)>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(12 < p, false);
+  ASSERT_EQ(11 < p, true);
+}
+
+TEST(ProxyDispatchTests, TestPreOpGreaterThanOrEqualTo) {
+  struct TestFacade : pro::facade_builder::add_convention<PreOpGreaterThanOrEqualTo, bool(int val)>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(11 >= p, false);
+  ASSERT_EQ(12 >= p, true);
+}
+
+TEST(ProxyDispatchTests, TestPreOpLessThanOrEqualTo) {
+  struct TestFacade : pro::facade_builder::add_convention<PreOpLessThanOrEqualTo, bool(int val)>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(13 <= p, false);
+  ASSERT_EQ(12 <= p, true);
+}
+
+TEST(ProxyDispatchTests, TestPreOpSpaceship) {
+  struct TestFacade : pro::facade_builder::add_convention<PreOpSpaceship, std::strong_ordering(int val)>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(2 <=> p, std::strong_ordering::less);
+  ASSERT_EQ(12 <=> p, std::strong_ordering::equal);
+  ASSERT_EQ(20 <=> p, std::strong_ordering::greater);
+}
+
+TEST(ProxyDispatchTests, TestPreOpLogicalAnd) {
+  struct TestFacade : pro::facade_builder::add_convention<PreOpLogicalAnd, bool(bool val)>::build {};
+  bool v = true;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(true && p, true);
+  ASSERT_EQ(false && p, false);
+}
+
+TEST(ProxyDispatchTests, TestPreOpLogicalOr) {
+  struct TestFacade : pro::facade_builder::add_convention<PreOpLogicalOr, bool(bool val)>::build {};
+  bool v = false;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(false || p, false);
+  ASSERT_EQ(true || p, true);
+}
+
+TEST(ProxyDispatchTests, TestPreOpAmpersand) {
+  struct TestFacade : pro::facade_builder::add_convention<PreOpAmpersand, const void*() noexcept, int(int val)>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(6 & p, 4);
+  ASSERT_EQ(&p, &v);
+}
+
+TEST(ProxyDispatchTests, TestPreOpPipe) {
+  struct TestFacade : pro::facade_builder::add_convention<PreOpPipe, int(int val)>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(6 | p, 14);
+}
+
+TEST(ProxyDispatchTests, TestPreOpCaret) {
+  struct TestFacade : pro::facade_builder::add_convention<PreOpCaret, int(int val)>::build {};
+  int v = 12;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(8 ^ p, 4);
+}
+
+TEST(ProxyDispatchTests, TestPreOpLeftShift) {
+  struct TestFacade : pro::facade_builder::add_convention<PreOpLeftShift, int(int val), std::ostream&(std::ostream& out)>::build {};
+  int v = 2;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(12 << p, 48);
+  std::ostringstream stream;
+  stream << p;
+  ASSERT_EQ(stream.str(), "2");
+}
+
+TEST(ProxyDispatchTests, TestPreOpRightShift) {
+  struct TestFacade : pro::facade_builder::add_convention<PreOpRightShift, int(int val), std::istream&(std::istream& in)>::build {};
+  int v = 1;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(25 >> p, 12);
+  std::istringstream stream("123");
+  stream >> p;
+  ASSERT_EQ(v, 123);
+}
+
+TEST(ProxyDispatchTests, TestPreOpComma) {
+  struct TestFacade : pro::facade_builder::add_convention<PreOpComma, int(int val)>::build {};
+  CommaTester v{3};
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4834)  // False alarm from MSVC: warning C4834: discarding return value of function with [[nodiscard]] attribute
+#endif  // _MSC_VER
+  pro::proxy<TestFacade> p = &v;
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif  // _MSC_VER
+  ASSERT_EQ((7, p), 21);
+}
diff --git a/tests/proxy_invocation_tests.cpp b/tests/proxy_invocation_tests.cpp
index 33cca9cb..a5196d60 100644
--- a/tests/proxy_invocation_tests.cpp
+++ b/tests/proxy_invocation_tests.cpp
@@ -17,27 +17,12 @@ namespace {
 
 namespace spec {
 
-struct Call {
-  template <class T, class... Args>
-  decltype(auto) operator()(T& v, Args&&... args)
-      noexcept(std::is_nothrow_invocable_v<T&, Args...>)
-      requires(std::is_invocable_v<T&, Args...>)
-      { return std::invoke(v, std::forward<Args>(args)...); }
-
-  template <class P>
-  struct accessor {
-    template <class... Args>
-    decltype(auto) operator()(Args&&... args) const
-        noexcept(noexcept(static_cast<const P&>(*this).template invoke<Call>(std::forward<Args>(args)...)))
-        requires(requires { static_cast<pro::lazy_eval_t<const P&, Args...>>(*this).template invoke<Call>(std::forward<Args>(args)...); })
-        { return static_cast<const P&>(*this).template invoke<Call>(std::forward<Args>(args)...); }
-  };
-};
+PRO_DEF_OPERATOR_DISPATCH(OpCall, "()");
 
 template <class... Os>
 struct Callable : pro::facade_builder
     ::support_copy<pro::constraint_level::nontrivial>
-    ::add_convention<Call, Os...>
+    ::add_convention<OpCall, Os...>
     ::build {};
 
 struct Wildcard {
@@ -47,30 +32,11 @@ struct Wildcard {
 
 Wildcard NotImplemented(auto&&...) { throw std::runtime_error{ "Not implemented!" }; }
 
-struct WeakCall {
-  template <class T, class... Args>
-  decltype(auto) operator()(T& v, Args&&... args)
-      noexcept(std::is_nothrow_invocable_v<T&, Args...>)
-      requires(std::is_invocable_v<T&, Args...>)
-      { return std::invoke(v, std::forward<Args>(args)...); }
-
-  template <class... Args>
-  Wildcard operator()(std::nullptr_t, Args&&...) { NotImplemented(); return {}; }
-
-  template <class P>
-  struct accessor {
-    template <class... Args>
-    decltype(auto) operator()(Args&&... args) const
-        noexcept(noexcept(static_cast<const P&>(*this).template invoke<WeakCall>(std::forward<Args>(args)...)))
-        requires(requires { static_cast<pro::lazy_eval_t<const P&, Args...>>(*this).template invoke<WeakCall>(std::forward<Args>(args)...); })
-        { return static_cast<const P&>(*this).template invoke<WeakCall>(std::forward<Args>(args)...); }
-  };
-};
-
+PRO_DEF_OPERATOR_DISPATCH_WITH_DEFAULT(WeakOpCall, "()", NotImplemented);
 template <class... Os>
 struct WeakCallable : pro::facade_builder
     ::support_copy<pro::constraint_level::nontrivial>
-    ::add_convention<WeakCall, Os...>
+    ::add_convention<WeakOpCall, Os...>
     ::build {};
 
 PRO_DEF_FREE_DISPATCH(FreeSize, Size, std::ranges::size);
@@ -138,8 +104,8 @@ struct SharedStringable : pro::facade_builder
 template <class F, class D, bool NE, class... Args>
 concept InvocableWithDispatch =
     requires(const pro::proxy<F> p, Args... args) {
-      { p.template invoke<D>(std::forward<Args>(args)...) };
-      typename std::enable_if_t<NE == noexcept(p.template invoke<D>(std::forward<Args>(args)...))>;
+      { pro::proxy_invoke<D>(p, std::forward<Args>(args)...) };
+      typename std::enable_if_t<NE == noexcept(pro::proxy_invoke<D>(p, std::forward<Args>(args)...))>;
     };
 template <class F, bool NE, class... Args>
 concept InvocableWithoutDispatch =
@@ -149,8 +115,8 @@ concept InvocableWithoutDispatch =
 };
 
 // Static assertions for a facade of a single dispatch
-static_assert(InvocableWithDispatch<spec::Callable<int(double)>, spec::Call, false, double>);
-static_assert(!InvocableWithDispatch<spec::Callable<int(double)>, spec::Call, false, std::nullptr_t>);  // Wrong arguments
+static_assert(InvocableWithDispatch<spec::Callable<int(double)>, spec::OpCall, false, double>);
+static_assert(!InvocableWithDispatch<spec::Callable<int(double)>, spec::OpCall, false, std::nullptr_t>);  // Wrong arguments
 static_assert(!InvocableWithoutDispatch<spec::Callable<int(double)>, false, std::nullptr_t>);  // Wrong arguments
 static_assert(!InvocableWithDispatch<spec::Callable<int(double)>, int(double), false, double>);  // Wrong dispatch
 static_assert(InvocableWithoutDispatch<spec::Callable<int(double)>, false, float>);  // Invoking without specifying a dispatch
@@ -249,7 +215,7 @@ TEST(ProxyInvocationTests, TestRecursiveDefinition) {
 
 TEST(ProxyInvocationTests, TestOverloadResolution) {
   struct OverloadedCallable : pro::facade_builder
-      ::add_convention<spec::Call, void(int), void(double), void(const char*), void(char*), void(std::string, int)>
+      ::add_convention<spec::OpCall, void(int), void(double), void(const char*), void(char*), void(std::string, int)>
       ::build {};
   std::vector<std::type_index> side_effect;
   auto p = pro::make_proxy<OverloadedCallable>([&](auto&&... args)
diff --git a/tests/proxy_reflection_tests.cpp b/tests/proxy_reflection_tests.cpp
index a9b33140..0f4374bd 100644
--- a/tests/proxy_reflection_tests.cpp
+++ b/tests/proxy_reflection_tests.cpp
@@ -10,7 +10,7 @@ namespace {
 
 template <class F, class R>
 concept ReflectionApplicable = requires(pro::proxy<F> p) {
-  { p.template reflect<R>() };
+  { pro::proxy_reflect<R>(p) };
 };
 
 class RttiReflection {
@@ -60,29 +60,29 @@ static_assert(ReflectionApplicable<TestTraitsFacade, TraitsReflection>);
 TEST(ProxyReflectionTests, TestRtti_RawPtr) {
   int foo = 123;
   pro::proxy<TestRttiFacade> p = &foo;
-  ASSERT_EQ(p.reflect<RttiReflection>().GetName(), typeid(int*).name());
+  ASSERT_EQ(pro::proxy_reflect<RttiReflection>(p).GetName(), typeid(int*).name());
 }
 
 TEST(ProxyReflectionTests, TestRtti_FancyPtr) {
   pro::proxy<TestRttiFacade> p = std::make_unique<double>(1.23);
-  ASSERT_EQ(p.reflect<RttiReflection>().GetName(), typeid(std::unique_ptr<double>).name());
+  ASSERT_EQ(pro::proxy_reflect<RttiReflection>(p).GetName(), typeid(std::unique_ptr<double>).name());
 }
 
 TEST(ProxyReflectionTests, TestTraits_RawPtr) {
   int foo = 123;
   pro::proxy<TestTraitsFacade> p = &foo;
-  ASSERT_EQ(p.reflect<TraitsReflection>().is_default_constructible_, true);
-  ASSERT_EQ(p.reflect<TraitsReflection>().is_copy_constructible_, true);
-  ASSERT_EQ(p.reflect<TraitsReflection>().is_nothrow_move_constructible_, true);
-  ASSERT_EQ(p.reflect<TraitsReflection>().is_nothrow_destructible_, true);
-  ASSERT_EQ(p.reflect<TraitsReflection>().is_trivial_, true);
+  ASSERT_EQ(pro::proxy_reflect<TraitsReflection>(p).is_default_constructible_, true);
+  ASSERT_EQ(pro::proxy_reflect<TraitsReflection>(p).is_copy_constructible_, true);
+  ASSERT_EQ(pro::proxy_reflect<TraitsReflection>(p).is_nothrow_move_constructible_, true);
+  ASSERT_EQ(pro::proxy_reflect<TraitsReflection>(p).is_nothrow_destructible_, true);
+  ASSERT_EQ(pro::proxy_reflect<TraitsReflection>(p).is_trivial_, true);
 }
 
 TEST(ProxyReflectionTests, TestTraits_FancyPtr) {
   pro::proxy<TestTraitsFacade> p = std::make_unique<double>(1.23);
-  ASSERT_EQ(p.reflect<TraitsReflection>().is_default_constructible_, true);
-  ASSERT_EQ(p.reflect<TraitsReflection>().is_copy_constructible_, false);
-  ASSERT_EQ(p.reflect<TraitsReflection>().is_nothrow_move_constructible_, true);
-  ASSERT_EQ(p.reflect<TraitsReflection>().is_nothrow_destructible_, true);
-  ASSERT_EQ(p.reflect<TraitsReflection>().is_trivial_, false);
+  ASSERT_EQ(pro::proxy_reflect<TraitsReflection>(p).is_default_constructible_, true);
+  ASSERT_EQ(pro::proxy_reflect<TraitsReflection>(p).is_copy_constructible_, false);
+  ASSERT_EQ(pro::proxy_reflect<TraitsReflection>(p).is_nothrow_move_constructible_, true);
+  ASSERT_EQ(pro::proxy_reflect<TraitsReflection>(p).is_nothrow_destructible_, true);
+  ASSERT_EQ(pro::proxy_reflect<TraitsReflection>(p).is_trivial_, false);
 }

From c26abb5dbe78e7e1cdca00abd2184dba914b8913 Mon Sep 17 00:00:00 2001
From: Mingxin Wang <mingxwa@microsoft.com>
Date: Fri, 31 May 2024 22:21:31 +0800
Subject: [PATCH 2/6] Refactor

---
 proxy.h | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/proxy.h b/proxy.h
index e1a8277e..c9bfe350 100644
--- a/proxy.h
+++ b/proxy.h
@@ -1410,27 +1410,27 @@ using op_dispatch_accessor = typename op_dispatch_traits<SIGN, POS>
       __VA_ARGS__ \
     };
 
+#define PRO_DEF_OPERATOR_DISPATCH(__NAME, __SIGN) \
+    ___PRO_DEF_OPERATOR_DISPATCH_IMPL(__NAME, __SIGN, none)
+
 #define PRO_DEF_OPERATOR_DISPATCH_WITH_DEFAULT(__NAME, __SIGN, __DEFFUNC) \
     ___PRO_DEF_OPERATOR_DISPATCH_IMPL( \
         __NAME, __SIGN, none, ___PRO_DEFAULT_DISPATCH_CALL_IMPL(__DEFFUNC))
 
-#define PRO_DEF_OPERATOR_DISPATCH(__NAME, __SIGN) \
-    ___PRO_DEF_OPERATOR_DISPATCH_IMPL(__NAME, __SIGN, none)
+#define PRO_DEF_PRE_OPERATOR_DISPATCH(__NAME, __SIGN) \
+    ___PRO_DEF_OPERATOR_DISPATCH_IMPL(__NAME, __SIGN, left)
 
 #define PRO_DEF_PRE_OPERATOR_DISPATCH_WITH_DEFAULT(__NAME, __SIGN, __DEFFUNC) \
     ___PRO_DEF_OPERATOR_DISPATCH_IMPL( \
         __NAME, __SIGN, left, ___PRO_DEFAULT_DISPATCH_CALL_IMPL(__DEFFUNC))
 
-#define PRO_DEF_PRE_OPERATOR_DISPATCH(__NAME, __SIGN) \
-    ___PRO_DEF_OPERATOR_DISPATCH_IMPL(__NAME, __SIGN, left)
+#define PRO_DEF_POST_OPERATOR_DISPATCH(__NAME, __SIGN) \
+    ___PRO_DEF_OPERATOR_DISPATCH_IMPL(__NAME, __SIGN, right)
 
 #define PRO_DEF_POST_OPERATOR_DISPATCH_WITH_DEFAULT(__NAME, __SIGN, __DEFFUNC) \
     ___PRO_DEF_OPERATOR_DISPATCH_IMPL( \
         __NAME, __SIGN, right, ___PRO_DEFAULT_DISPATCH_CALL_IMPL(__DEFFUNC))
 
-#define PRO_DEF_POST_OPERATOR_DISPATCH(__NAME, __SIGN) \
-    ___PRO_DEF_OPERATOR_DISPATCH_IMPL(__NAME, __SIGN, right)
-
 }  // namespace pro
 
 #endif  // _MSFT_PROXY_

From 7a670412bb3806a68fd7dae1030c4889aea9e096 Mon Sep 17 00:00:00 2001
From: Mingxin Wang <mingxwa@microsoft.com>
Date: Fri, 31 May 2024 22:59:42 +0800
Subject: [PATCH 3/6] Fix build

---
 tests/proxy_dispatch_tests.cpp | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/tests/proxy_dispatch_tests.cpp b/tests/proxy_dispatch_tests.cpp
index 7aae92e5..3d57a965 100644
--- a/tests/proxy_dispatch_tests.cpp
+++ b/tests/proxy_dispatch_tests.cpp
@@ -2,7 +2,14 @@
 // Licensed under the MIT License.
 
 #include <gtest/gtest.h>
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4834)  // False alarm from MSVC: warning C4834: discarding return value of function with [[nodiscard]] attribute
+#endif  // _MSC_VER
 #include "proxy.h"
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif  // _MSC_VER
 
 namespace {
 
@@ -526,13 +533,6 @@ TEST(ProxyDispatchTests, TestPreOpRightShift) {
 TEST(ProxyDispatchTests, TestPreOpComma) {
   struct TestFacade : pro::facade_builder::add_convention<PreOpComma, int(int val)>::build {};
   CommaTester v{3};
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable: 4834)  // False alarm from MSVC: warning C4834: discarding return value of function with [[nodiscard]] attribute
-#endif  // _MSC_VER
   pro::proxy<TestFacade> p = &v;
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif  // _MSC_VER
   ASSERT_EQ((7, p), 21);
 }

From 82690299a3701b3a03288fffc3b3adebc6f5e890 Mon Sep 17 00:00:00 2001
From: Mingxin Wang <mingxwa@microsoft.com>
Date: Sat, 1 Jun 2024 11:47:13 +0800
Subject: [PATCH 4/6] Implement convertion

---
 proxy.h                        | 22 ++++++++++++++++++++++
 tests/proxy_dispatch_tests.cpp |  9 +++++++++
 2 files changed, 31 insertions(+)

diff --git a/proxy.h b/proxy.h
index c9bfe350..e9207065 100644
--- a/proxy.h
+++ b/proxy.h
@@ -1410,6 +1410,21 @@ using op_dispatch_accessor = typename op_dispatch_traits<SIGN, POS>
       __VA_ARGS__ \
     };
 
+#define ___PRO_DEF_CONVERTION_DISPATCH_IMPL(__NAME, __T, ...) \
+    struct __NAME { \
+      __T operator()(auto& __self) \
+          ___PRO_DIRECT_FUNC_IMPL(static_cast<__T>(__self)) \
+      template <class __P> \
+      struct accessor { \
+        template <class __Barrier = void> \
+        explicit operator __T() const \
+            ___PRO_DIRECT_FUNC_IMPL(::pro::proxy_invoke<__NAME>( \
+                static_cast<::pro::details::lazy_eval_t<const __P&, \
+                    __Barrier>>(*this))) \
+      }; \
+      __VA_ARGS__ \
+    }
+
 #define PRO_DEF_OPERATOR_DISPATCH(__NAME, __SIGN) \
     ___PRO_DEF_OPERATOR_DISPATCH_IMPL(__NAME, __SIGN, none)
 
@@ -1431,6 +1446,13 @@ using op_dispatch_accessor = typename op_dispatch_traits<SIGN, POS>
     ___PRO_DEF_OPERATOR_DISPATCH_IMPL( \
         __NAME, __SIGN, right, ___PRO_DEFAULT_DISPATCH_CALL_IMPL(__DEFFUNC))
 
+#define PRO_DEF_CONVERTION_DISPATCH(__NAME, __T) \
+    ___PRO_DEF_CONVERTION_DISPATCH_IMPL(__NAME, __T)
+
+#define PRO_DEF_CONVERTION_DISPATCH_WITH_DEFAULT(__NAME, __T, __DEFFUNC) \
+    ___PRO_DEF_CONVERTION_DISPATCH_IMPL( \
+        __NAME, __T, ___PRO_DEFAULT_DISPATCH_CALL_IMPL(__DEFFUNC))
+
 }  // namespace pro
 
 #endif  // _MSFT_PROXY_
diff --git a/tests/proxy_dispatch_tests.cpp b/tests/proxy_dispatch_tests.cpp
index 3d57a965..dd62a465 100644
--- a/tests/proxy_dispatch_tests.cpp
+++ b/tests/proxy_dispatch_tests.cpp
@@ -73,6 +73,8 @@ PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpLeftShift, "<<");
 PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpRightShift, ">>");
 PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpComma, ",");
 
+PRO_DEF_CONVERTION_DISPATCH(ConvertToInt, int);
+
 struct CommaTester {
 public:
   explicit CommaTester(int v) : value_(v) {}
@@ -536,3 +538,10 @@ TEST(ProxyDispatchTests, TestPreOpComma) {
   pro::proxy<TestFacade> p = &v;
   ASSERT_EQ((7, p), 21);
 }
+
+TEST(ProxyDispatchTests, TestConvertion) {
+  struct TestFacade : pro::facade_builder::add_convention<ConvertToInt, int()>::build {};
+  double v = 12.3;
+  pro::proxy<TestFacade> p = &v;
+  ASSERT_EQ(static_cast<int>(p), 12);
+}

From 65e28075d399e14d85e557224e5ce79ea5037c62 Mon Sep 17 00:00:00 2001
From: Mingxin Wang <mingxwa@microsoft.com>
Date: Sun, 2 Jun 2024 19:39:00 +0800
Subject: [PATCH 5/6] Improve implementation for sign representation

---
 proxy.h | 195 ++++++++++++++++++++++----------------------------------
 1 file changed, 75 insertions(+), 120 deletions(-)

diff --git a/proxy.h b/proxy.h
index e9207065..a1030ef3 100644
--- a/proxy.h
+++ b/proxy.h
@@ -9,7 +9,6 @@
 #include <concepts>
 #include <initializer_list>
 #include <memory>
-#include <string_view>
 #include <tuple>
 #include <type_traits>
 #include <utility>
@@ -1101,65 +1100,24 @@ using facade_builder = details::facade_builder_impl<std::tuple<>, std::tuple<>,
 
 namespace details {
 
-enum class sign_type {
-  none, plus, minus, asterisk, slash, percent, increment, decrement,
-  equal_to, not_equal_to, greater_than, less_than, greater_than_or_equal_to,
-  less_than_or_equal_to, spaceship, logical_not, logical_and, logical_or,
-  tilde, ampersand, pipe, caret, left_shift, right_shift, plus_assignment,
-  minus_assignment, multiplication_assignment, division_assignment,
-  bitwise_and_assignment, bitwise_or_assignment, bitwise_xor_assignment,
-  left_shift_assignment, right_shift_assignment, comma, arrow, parentheses,
-  brackets,
+template <std::size_t N>
+struct sign {
+  consteval sign(const char (&str)[N])
+      { for (std::size_t i = 0; i < N; ++i) { value[i] = str[i]; } }
+
+  char value[N];
 };
+template <std::size_t N>
+sign(const char (&str)[N]) -> sign<N>;
 
 enum class sign_pos_type { none, left, right };
 
-consteval sign_type parse_sign(std::string_view str) {
-  if (str == "+") { return sign_type::plus; }
-  if (str == "-") { return sign_type::minus; }
-  if (str == "*") { return sign_type::asterisk; }
-  if (str == "/") { return sign_type::slash; }
-  if (str == "%") { return sign_type::percent; }
-  if (str == "++") { return sign_type::increment; }
-  if (str == "--") { return sign_type::decrement; }
-  if (str == "==") { return sign_type::equal_to; }
-  if (str == "!=") { return sign_type::not_equal_to; }
-  if (str == ">") { return sign_type::greater_than; }
-  if (str == "<") { return sign_type::less_than; }
-  if (str == ">=") { return sign_type::greater_than_or_equal_to; }
-  if (str == "<=") { return sign_type::less_than_or_equal_to; }
-  if (str == "<=>") { return sign_type::spaceship; }
-  if (str == "!") { return sign_type::logical_not; }
-  if (str == "&&") { return sign_type::logical_and; }
-  if (str == "||") { return sign_type::logical_or; }
-  if (str == "~") { return sign_type::tilde; }
-  if (str == "&") { return sign_type::ampersand; }
-  if (str == "|") { return sign_type::pipe; }
-  if (str == "^") { return sign_type::caret; }
-  if (str == "<<") { return sign_type::left_shift; }
-  if (str == ">>") { return sign_type::right_shift; }
-  if (str == "+=") { return sign_type::plus_assignment; }
-  if (str == "-=") { return sign_type::minus_assignment; }
-  if (str == "*=") { return sign_type::multiplication_assignment; }
-  if (str == "/=") { return sign_type::division_assignment; }
-  if (str == "&=") { return sign_type::bitwise_and_assignment; }
-  if (str == "|=") { return sign_type::bitwise_or_assignment; }
-  if (str == "^=") { return sign_type::bitwise_xor_assignment; }
-  if (str == "<<=") { return sign_type::left_shift_assignment; }
-  if (str == ">>=") { return sign_type::right_shift_assignment; }
-  if (str == ",") { return sign_type::comma; }
-  if (str == "->") { return sign_type::arrow; }
-  if (str == "()") { return sign_type::parentheses; }
-  if (str == "[]") { return sign_type::brackets; }
-  return sign_type::none;
-}
-
-template <sign_type SIGN, sign_pos_type POS>
+template <sign SIGN, sign_pos_type POS>
 struct op_dispatch_traits_impl : inapplicable_traits {};
 
-#define ___PRO_OPERATOR_DISPATCH_TRAITS_PREFIX_0_IMPL(SIGN, ...) \
+#define ___PRO_OPERATOR_DISPATCH_TRAITS_PREFIX_0_IMPL(...) \
     template <> \
-    struct op_dispatch_traits_impl<sign_type::SIGN, sign_pos_type::left> \
+    struct op_dispatch_traits_impl<#__VA_ARGS__, sign_pos_type::left> \
         : applicable_traits { \
       struct base { \
         decltype(auto) operator()(auto& self) \
@@ -1174,9 +1132,9 @@ struct op_dispatch_traits_impl : inapplicable_traits {};
       }; \
     };
 
-#define ___PRO_OPERATOR_DISPATCH_TRAITS_PREFIX_1_IMPL(SIGN, ...) \
+#define ___PRO_OPERATOR_DISPATCH_TRAITS_PREFIX_1_IMPL(...) \
     template <> \
-    struct op_dispatch_traits_impl<sign_type::SIGN, sign_pos_type::left> \
+    struct op_dispatch_traits_impl<#__VA_ARGS__, sign_pos_type::left> \
         : applicable_traits { \
       struct base { \
         template <class Arg> \
@@ -1192,9 +1150,9 @@ struct op_dispatch_traits_impl : inapplicable_traits {};
       }; \
     };
 
-#define ___PRO_OPERATOR_DISPATCH_TRAITS_PREFIX_0_OR_1_IMPL(SIGN, ...) \
+#define ___PRO_OPERATOR_DISPATCH_TRAITS_PREFIX_0_OR_1_IMPL(...) \
     template <> \
-    struct op_dispatch_traits_impl<sign_type::SIGN, sign_pos_type::left> \
+    struct op_dispatch_traits_impl<#__VA_ARGS__, sign_pos_type::left> \
         : applicable_traits { \
       struct base { \
         decltype(auto) operator()(auto& self) \
@@ -1216,9 +1174,9 @@ struct op_dispatch_traits_impl : inapplicable_traits {};
       }; \
     };
 
-#define ___PRO_OPERATOR_DISPATCH_TRAITS_POSTFIX_0_IMPL(SIGN, ...) \
+#define ___PRO_OPERATOR_DISPATCH_TRAITS_POSTFIX_0_IMPL(...) \
     template <> \
-    struct op_dispatch_traits_impl<sign_type::SIGN, sign_pos_type::right> \
+    struct op_dispatch_traits_impl<#__VA_ARGS__, sign_pos_type::right> \
         : applicable_traits { \
       struct base { \
         decltype(auto) operator()(auto& self) \
@@ -1233,9 +1191,9 @@ struct op_dispatch_traits_impl : inapplicable_traits {};
       }; \
     };
 
-#define ___PRO_OPERATOR_DISPATCH_TRAITS_POSTFIX_1_IMPL(SIGN, ...) \
+#define ___PRO_OPERATOR_DISPATCH_TRAITS_POSTFIX_1_IMPL(...) \
     template <> \
-    struct op_dispatch_traits_impl<sign_type::SIGN, sign_pos_type::right> \
+    struct op_dispatch_traits_impl<#__VA_ARGS__, sign_pos_type::right> \
         : applicable_traits { \
       struct base { \
         template <class Arg> \
@@ -1251,9 +1209,9 @@ struct op_dispatch_traits_impl : inapplicable_traits {};
       }; \
     };
 
-#define ___PRO_OPERATOR_DISPATCH_TRAITS_ASSIGNMENT_IMPL(SIGN, ...) \
+#define ___PRO_OPERATOR_DISPATCH_TRAITS_ASSIGNMENT_IMPL(...) \
     template <> \
-    struct op_dispatch_traits_impl<sign_type::SIGN, sign_pos_type::right> \
+    struct op_dispatch_traits_impl<#__VA_ARGS__, sign_pos_type::right> \
         : applicable_traits { \
       struct base { \
         template <class Arg> \
@@ -1270,49 +1228,49 @@ struct op_dispatch_traits_impl : inapplicable_traits {};
       }; \
     };
 
-#define ___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(SIGN, ...) \
-    ___PRO_OPERATOR_DISPATCH_TRAITS_PREFIX_1_IMPL(SIGN, __VA_ARGS__) \
-    ___PRO_OPERATOR_DISPATCH_TRAITS_POSTFIX_1_IMPL(SIGN, __VA_ARGS__)
-
-#define ___PRO_OPERATOR_DISPATCH_TRAITS_EXTENDED_BINARY_IMPL(SIGN, ...) \
-    ___PRO_OPERATOR_DISPATCH_TRAITS_PREFIX_0_OR_1_IMPL(SIGN, __VA_ARGS__) \
-    ___PRO_OPERATOR_DISPATCH_TRAITS_POSTFIX_1_IMPL(SIGN, __VA_ARGS__)
-
-___PRO_OPERATOR_DISPATCH_TRAITS_EXTENDED_BINARY_IMPL(plus, +)
-___PRO_OPERATOR_DISPATCH_TRAITS_EXTENDED_BINARY_IMPL(minus, -)
-___PRO_OPERATOR_DISPATCH_TRAITS_EXTENDED_BINARY_IMPL(asterisk, *)
-___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(slash, /)
-___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(percent, %)
-___PRO_OPERATOR_DISPATCH_TRAITS_PREFIX_0_IMPL(increment, ++)
-___PRO_OPERATOR_DISPATCH_TRAITS_POSTFIX_0_IMPL(increment, ++)
-___PRO_OPERATOR_DISPATCH_TRAITS_PREFIX_0_IMPL(decrement, --)
-___PRO_OPERATOR_DISPATCH_TRAITS_POSTFIX_0_IMPL(decrement, --)
-___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(equal_to, ==)
-___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(not_equal_to, !=)
-___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(greater_than, >)
-___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(less_than, <)
-___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(greater_than_or_equal_to, >=)
-___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(less_than_or_equal_to, <=)
-___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(spaceship, <=>)
-___PRO_OPERATOR_DISPATCH_TRAITS_PREFIX_0_IMPL(logical_not, !)
-___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(logical_and, &&)
-___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(logical_or, ||)
-___PRO_OPERATOR_DISPATCH_TRAITS_PREFIX_0_IMPL(tilde, ~)
-___PRO_OPERATOR_DISPATCH_TRAITS_EXTENDED_BINARY_IMPL(ampersand, &)
-___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(pipe, |)
-___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(caret, ^)
-___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(left_shift, <<)
-___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(right_shift, >>)
-___PRO_OPERATOR_DISPATCH_TRAITS_ASSIGNMENT_IMPL(plus_assignment, +=)
-___PRO_OPERATOR_DISPATCH_TRAITS_ASSIGNMENT_IMPL(minus_assignment, -=)
-___PRO_OPERATOR_DISPATCH_TRAITS_ASSIGNMENT_IMPL(multiplication_assignment, *=)
-___PRO_OPERATOR_DISPATCH_TRAITS_ASSIGNMENT_IMPL(division_assignment, /=)
-___PRO_OPERATOR_DISPATCH_TRAITS_ASSIGNMENT_IMPL(bitwise_and_assignment, &=)
-___PRO_OPERATOR_DISPATCH_TRAITS_ASSIGNMENT_IMPL(bitwise_or_assignment, |=)
-___PRO_OPERATOR_DISPATCH_TRAITS_ASSIGNMENT_IMPL(bitwise_xor_assignment, ^=)
-___PRO_OPERATOR_DISPATCH_TRAITS_ASSIGNMENT_IMPL(left_shift_assignment, <<=)
-___PRO_OPERATOR_DISPATCH_TRAITS_ASSIGNMENT_IMPL(right_shift_assignment, >>=)
-___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(comma, ,)
+#define ___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(...) \
+    ___PRO_OPERATOR_DISPATCH_TRAITS_PREFIX_1_IMPL(__VA_ARGS__) \
+    ___PRO_OPERATOR_DISPATCH_TRAITS_POSTFIX_1_IMPL(__VA_ARGS__)
+
+#define ___PRO_OPERATOR_DISPATCH_TRAITS_EXTENDED_BINARY_IMPL(...) \
+    ___PRO_OPERATOR_DISPATCH_TRAITS_PREFIX_0_OR_1_IMPL(__VA_ARGS__) \
+    ___PRO_OPERATOR_DISPATCH_TRAITS_POSTFIX_1_IMPL(__VA_ARGS__)
+
+___PRO_OPERATOR_DISPATCH_TRAITS_EXTENDED_BINARY_IMPL(+)
+___PRO_OPERATOR_DISPATCH_TRAITS_EXTENDED_BINARY_IMPL(-)
+___PRO_OPERATOR_DISPATCH_TRAITS_EXTENDED_BINARY_IMPL(*)
+___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(/)
+___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(%)
+___PRO_OPERATOR_DISPATCH_TRAITS_PREFIX_0_IMPL(++)
+___PRO_OPERATOR_DISPATCH_TRAITS_POSTFIX_0_IMPL(++)
+___PRO_OPERATOR_DISPATCH_TRAITS_PREFIX_0_IMPL(--)
+___PRO_OPERATOR_DISPATCH_TRAITS_POSTFIX_0_IMPL(--)
+___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(==)
+___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(!=)
+___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(>)
+___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(<)
+___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(>=)
+___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(<=)
+___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(<=>)
+___PRO_OPERATOR_DISPATCH_TRAITS_PREFIX_0_IMPL(!)
+___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(&&)
+___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(||)
+___PRO_OPERATOR_DISPATCH_TRAITS_PREFIX_0_IMPL(~)
+___PRO_OPERATOR_DISPATCH_TRAITS_EXTENDED_BINARY_IMPL(&)
+___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(|)
+___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(^)
+___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(<<)
+___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(>>)
+___PRO_OPERATOR_DISPATCH_TRAITS_ASSIGNMENT_IMPL(+=)
+___PRO_OPERATOR_DISPATCH_TRAITS_ASSIGNMENT_IMPL(-=)
+___PRO_OPERATOR_DISPATCH_TRAITS_ASSIGNMENT_IMPL(*=)
+___PRO_OPERATOR_DISPATCH_TRAITS_ASSIGNMENT_IMPL(/=)
+___PRO_OPERATOR_DISPATCH_TRAITS_ASSIGNMENT_IMPL(&=)
+___PRO_OPERATOR_DISPATCH_TRAITS_ASSIGNMENT_IMPL(|=)
+___PRO_OPERATOR_DISPATCH_TRAITS_ASSIGNMENT_IMPL(^=)
+___PRO_OPERATOR_DISPATCH_TRAITS_ASSIGNMENT_IMPL(<<=)
+___PRO_OPERATOR_DISPATCH_TRAITS_ASSIGNMENT_IMPL(>>=)
+___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(,)
 
 #undef ___PRO_OPERATOR_DISPATCH_TRAITS_EXTENDED_BINARY_IMPL
 #undef ___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL
@@ -1324,7 +1282,7 @@ ___PRO_OPERATOR_DISPATCH_TRAITS_BINARY_IMPL(comma, ,)
 #undef ___PRO_OPERATOR_DISPATCH_TRAITS_PREFIX_0_IMPL
 
 template <>
-struct op_dispatch_traits_impl<sign_type::arrow, sign_pos_type::right>
+struct op_dispatch_traits_impl<"->", sign_pos_type::right>
     : applicable_traits {
   struct base
       { auto operator()(auto& self) noexcept { return std::addressof(self); } };
@@ -1337,7 +1295,7 @@ struct op_dispatch_traits_impl<sign_type::arrow, sign_pos_type::right>
   };
 };
 template <>
-struct op_dispatch_traits_impl<sign_type::parentheses, sign_pos_type::right>
+struct op_dispatch_traits_impl<"()", sign_pos_type::right>
     : applicable_traits {
   struct base {
     template <class... Args>
@@ -1353,7 +1311,7 @@ struct op_dispatch_traits_impl<sign_type::parentheses, sign_pos_type::right>
   };
 };
 template <>
-struct op_dispatch_traits_impl<sign_type::brackets, sign_pos_type::right>
+struct op_dispatch_traits_impl<"[]", sign_pos_type::right>
     : applicable_traits {
   struct base {
 #if defined(__cpp_multidimensional_subscript) && __cpp_multidimensional_subscript >= 202110L
@@ -1375,38 +1333,35 @@ struct op_dispatch_traits_impl<sign_type::brackets, sign_pos_type::right>
   };
 };
 
-template <sign_type SIGN, sign_pos_type POS>
+template <sign SIGN, sign_pos_type POS>
 struct op_dispatch_traits : op_dispatch_traits_impl<SIGN, POS>
     { static_assert(op_dispatch_traits::applicable, "Unexpected operator"); };
-template <sign_type SIGN>
+template <sign SIGN>
     requires(op_dispatch_traits_impl<SIGN, sign_pos_type::right>::applicable)
 struct op_dispatch_traits<SIGN, sign_pos_type::none>
     : op_dispatch_traits_impl<SIGN, sign_pos_type::right> {};
-template <sign_type SIGN>
+template <sign SIGN>
     requires(!op_dispatch_traits_impl<SIGN, sign_pos_type::right>::applicable &&
         op_dispatch_traits_impl<SIGN, sign_pos_type::left>::applicable)
 struct op_dispatch_traits<SIGN, sign_pos_type::none>
     : op_dispatch_traits_impl<SIGN, sign_pos_type::left> {};
 
-template <sign_type SIGN, sign_pos_type POS>
+template <sign SIGN, sign_pos_type POS>
 using op_dispatch_base = typename op_dispatch_traits<SIGN, POS>::base;
-template <sign_type SIGN, sign_pos_type POS, class D, class P>
+template <sign SIGN, sign_pos_type POS, class D, class P>
 using op_dispatch_accessor = typename op_dispatch_traits<SIGN, POS>
     ::template accessor<D, P>;
 
 }  // namespace details
 
-#define ___PRO_MAKE_SIGN_PARAMS(__SIGN, __POS) \
-    ::pro::details::parse_sign(__SIGN), ::pro::details::sign_pos_type::__POS
-
 #define ___PRO_DEF_OPERATOR_DISPATCH_IMPL(__NAME, __SIGN, __POS, ...) \
     struct __NAME : ::pro::details::op_dispatch_base< \
-        ___PRO_MAKE_SIGN_PARAMS(__SIGN, __POS)> { \
+        __SIGN, ::pro::details::sign_pos_type::__POS> { \
       using ::pro::details::op_dispatch_base< \
-          ___PRO_MAKE_SIGN_PARAMS(__SIGN, __POS)>::operator(); \
+          __SIGN, ::pro::details::sign_pos_type::__POS>::operator(); \
       template <class __P> \
       using accessor = ::pro::details::op_dispatch_accessor< \
-          ___PRO_MAKE_SIGN_PARAMS(__SIGN, __POS), __NAME, __P>; \
+          __SIGN, ::pro::details::sign_pos_type::__POS, __NAME, __P>; \
       __VA_ARGS__ \
     };
 

From fc683002c5c610b1702afd64fe4f9c26cf322b95 Mon Sep 17 00:00:00 2001
From: Mingxin Wang <mingxwa@microsoft.com>
Date: Mon, 3 Jun 2024 21:26:29 +0800
Subject: [PATCH 6/6] Resolve comments

---
 proxy.h                        | 10 ++++----
 tests/proxy_dispatch_tests.cpp | 44 +++++++++++++++++-----------------
 2 files changed, 28 insertions(+), 26 deletions(-)

diff --git a/proxy.h b/proxy.h
index a1030ef3..6d353634 100644
--- a/proxy.h
+++ b/proxy.h
@@ -1387,17 +1387,19 @@ using op_dispatch_accessor = typename op_dispatch_traits<SIGN, POS>
     ___PRO_DEF_OPERATOR_DISPATCH_IMPL( \
         __NAME, __SIGN, none, ___PRO_DEFAULT_DISPATCH_CALL_IMPL(__DEFFUNC))
 
-#define PRO_DEF_PRE_OPERATOR_DISPATCH(__NAME, __SIGN) \
+#define PRO_DEF_PREFIX_OPERATOR_DISPATCH(__NAME, __SIGN) \
     ___PRO_DEF_OPERATOR_DISPATCH_IMPL(__NAME, __SIGN, left)
 
-#define PRO_DEF_PRE_OPERATOR_DISPATCH_WITH_DEFAULT(__NAME, __SIGN, __DEFFUNC) \
+#define PRO_DEF_PREFIX_OPERATOR_DISPATCH_WITH_DEFAULT( \
+    __NAME, __SIGN, __DEFFUNC) \
     ___PRO_DEF_OPERATOR_DISPATCH_IMPL( \
         __NAME, __SIGN, left, ___PRO_DEFAULT_DISPATCH_CALL_IMPL(__DEFFUNC))
 
-#define PRO_DEF_POST_OPERATOR_DISPATCH(__NAME, __SIGN) \
+#define PRO_DEF_POSTFIX_OPERATOR_DISPATCH(__NAME, __SIGN) \
     ___PRO_DEF_OPERATOR_DISPATCH_IMPL(__NAME, __SIGN, right)
 
-#define PRO_DEF_POST_OPERATOR_DISPATCH_WITH_DEFAULT(__NAME, __SIGN, __DEFFUNC) \
+#define PRO_DEF_POSTFIX_OPERATOR_DISPATCH_WITH_DEFAULT( \
+    __NAME, __SIGN, __DEFFUNC) \
     ___PRO_DEF_OPERATOR_DISPATCH_IMPL( \
         __NAME, __SIGN, right, ___PRO_DEFAULT_DISPATCH_CALL_IMPL(__DEFFUNC))
 
diff --git a/tests/proxy_dispatch_tests.cpp b/tests/proxy_dispatch_tests.cpp
index dd62a465..9af4a8ab 100644
--- a/tests/proxy_dispatch_tests.cpp
+++ b/tests/proxy_dispatch_tests.cpp
@@ -50,28 +50,28 @@ PRO_DEF_OPERATOR_DISPATCH(OpArrow, "->");
 PRO_DEF_OPERATOR_DISPATCH(OpParentheses, "()");
 PRO_DEF_OPERATOR_DISPATCH(OpBrackets, "[]");
 
-PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpPlus, "+");
-PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpMinus, "-");
-PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpAsterisk, "*");
-PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpSlash, "/");
-PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpPercent, "%");
-PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpIncrement, "++");
-PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpDecrement, "--");
-PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpEqualTo, "==");
-PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpNotEqualTo, "!=");
-PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpGreaterThan, ">");
-PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpLessThan, "<");
-PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpGreaterThanOrEqualTo, ">=");
-PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpLessThanOrEqualTo, "<=");
-PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpSpaceship, "<=>");
-PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpLogicalAnd, "&&");
-PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpLogicalOr, "||");
-PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpAmpersand, "&");
-PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpPipe, "|");
-PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpCaret, "^");
-PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpLeftShift, "<<");
-PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpRightShift, ">>");
-PRO_DEF_PRE_OPERATOR_DISPATCH(PreOpComma, ",");
+PRO_DEF_PREFIX_OPERATOR_DISPATCH(PreOpPlus, "+");
+PRO_DEF_PREFIX_OPERATOR_DISPATCH(PreOpMinus, "-");
+PRO_DEF_PREFIX_OPERATOR_DISPATCH(PreOpAsterisk, "*");
+PRO_DEF_PREFIX_OPERATOR_DISPATCH(PreOpSlash, "/");
+PRO_DEF_PREFIX_OPERATOR_DISPATCH(PreOpPercent, "%");
+PRO_DEF_PREFIX_OPERATOR_DISPATCH(PreOpIncrement, "++");
+PRO_DEF_PREFIX_OPERATOR_DISPATCH(PreOpDecrement, "--");
+PRO_DEF_PREFIX_OPERATOR_DISPATCH(PreOpEqualTo, "==");
+PRO_DEF_PREFIX_OPERATOR_DISPATCH(PreOpNotEqualTo, "!=");
+PRO_DEF_PREFIX_OPERATOR_DISPATCH(PreOpGreaterThan, ">");
+PRO_DEF_PREFIX_OPERATOR_DISPATCH(PreOpLessThan, "<");
+PRO_DEF_PREFIX_OPERATOR_DISPATCH(PreOpGreaterThanOrEqualTo, ">=");
+PRO_DEF_PREFIX_OPERATOR_DISPATCH(PreOpLessThanOrEqualTo, "<=");
+PRO_DEF_PREFIX_OPERATOR_DISPATCH(PreOpSpaceship, "<=>");
+PRO_DEF_PREFIX_OPERATOR_DISPATCH(PreOpLogicalAnd, "&&");
+PRO_DEF_PREFIX_OPERATOR_DISPATCH(PreOpLogicalOr, "||");
+PRO_DEF_PREFIX_OPERATOR_DISPATCH(PreOpAmpersand, "&");
+PRO_DEF_PREFIX_OPERATOR_DISPATCH(PreOpPipe, "|");
+PRO_DEF_PREFIX_OPERATOR_DISPATCH(PreOpCaret, "^");
+PRO_DEF_PREFIX_OPERATOR_DISPATCH(PreOpLeftShift, "<<");
+PRO_DEF_PREFIX_OPERATOR_DISPATCH(PreOpRightShift, ">>");
+PRO_DEF_PREFIX_OPERATOR_DISPATCH(PreOpComma, ",");
 
 PRO_DEF_CONVERTION_DISPATCH(ConvertToInt, int);