feat: Add binary operation/apply cross-type overload of the binary version

Author: FrozenLemonTee

src/operations/operators.cppm

@@ -1,6 +1,7 @@
 module;
 
 #include <compare>
+#include <concepts>
 #include <expected>
 #include <type_traits>
 #include <utility>
@@ -67,6 +68,21 @@ using primitive_dispatch_result_t = std::expected<meta::make_primitive_t<
         typename meta::traits<Lhs>::policies>,
     ErrorPayload>;
 
+template <typename T>
+concept underlying_operand = underlying_type<std::remove_cvref_t<T>>;
+
+template <primitive_instance Primitive, underlying_operand Underlying>
+using mixed_bridge_primitive_t = meta::make_primitive_t<
+    std::remove_cvref_t<Underlying>, typename meta::traits<Primitive>::policies>;
+
+template <operation OpTag, primitive_instance Primitive,
+          underlying_operand Underlying,
+          typename ErrorPayload = policy::error::kind>
+using mixed_primitive_dispatch_result_t =
+    primitive_dispatch_result_t<OpTag, Primitive,
+                                mixed_bridge_primitive_t<Primitive, Underlying>,
+                                ErrorPayload>;
+
 template <primitive_instance Lhs, primitive_instance Rhs,
           typename ErrorPayload = policy::error::kind>
 using three_way_dispatch_result_t = std::expected<
@@ -75,6 +91,25 @@ using three_way_dispatch_result_t = std::expected<
                                  ErrorPayload>::common_rep>,
     ErrorPayload>;
 
+template <primitive_instance Primitive, underlying_operand Underlying,
+          typename ErrorPayload = policy::error::kind>
+using mixed_three_way_dispatch_result_t =
+    three_way_dispatch_result_t<Primitive,
+                                mixed_bridge_primitive_t<Primitive, Underlying>,
+                                ErrorPayload>;
+
+template <operation OpTag, underlying_operand Underlying,
+          primitive_instance Primitive,
+          typename ErrorPayload = policy::error::kind>
+using flipped_mixed_primitive_dispatch_result_t = primitive_dispatch_result_t<
+    OpTag, mixed_bridge_primitive_t<Primitive, Underlying>, Primitive,
+    ErrorPayload>;
+
+template <underlying_operand Underlying, primitive_instance Primitive,
+          typename ErrorPayload = policy::error::kind>
+using flipped_mixed_three_way_dispatch_result_t = three_way_dispatch_result_t<
+    mixed_bridge_primitive_t<Primitive, Underlying>, Primitive, ErrorPayload>;
+
 template <operation OpTag, primitive_instance Lhs, primitive_instance Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto apply(Lhs const &lhs, Rhs const &rhs)
@@ -91,48 +126,158 @@ constexpr auto apply(Lhs const &lhs, Rhs const &rhs)
   return result_primitive{*raw};
 }
 
+template <operation OpTag, primitive_instance Lhs, underlying_operand Rhs,
+          typename ErrorPayload = policy::error::kind>
+constexpr auto apply(Lhs const &lhs, Rhs const &rhs)
+    -> mixed_primitive_dispatch_result_t<OpTag, Lhs, Rhs, ErrorPayload> {
+  using bridge_rhs_t = mixed_bridge_primitive_t<Lhs, Rhs>;
+  auto const bridge_rhs = bridge_rhs_t{rhs};
+  return apply<OpTag, Lhs, bridge_rhs_t, ErrorPayload>(lhs, bridge_rhs);
+}
+
+template <operation OpTag, underlying_operand Lhs, primitive_instance Rhs,
+          typename ErrorPayload = policy::error::kind>
+constexpr auto apply(Lhs const &lhs, Rhs const &rhs)
+    -> flipped_mixed_primitive_dispatch_result_t<OpTag, Lhs, Rhs,
+                                                 ErrorPayload> {
+  using bridge_lhs_t = mixed_bridge_primitive_t<Rhs, Lhs>;
+  auto const bridge_lhs = bridge_lhs_t{lhs};
+  return apply<OpTag, bridge_lhs_t, Rhs, ErrorPayload>(bridge_lhs, rhs);
+}
+
 template <primitive_instance Lhs, primitive_instance Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto add(Lhs const &lhs, Rhs const &rhs)
     -> primitive_dispatch_result_t<Addition, Lhs, Rhs, ErrorPayload> {
   return apply<Addition, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
+template <primitive_instance Lhs, underlying_operand Rhs,
+          typename ErrorPayload = policy::error::kind>
+constexpr auto add(Lhs const &lhs, Rhs const &rhs)
+    -> mixed_primitive_dispatch_result_t<Addition, Lhs, Rhs, ErrorPayload> {
+  return apply<Addition, Lhs, Rhs, ErrorPayload>(lhs, rhs);
+}
+
+template <underlying_operand Lhs, primitive_instance Rhs,
+          typename ErrorPayload = policy::error::kind>
+constexpr auto add(Lhs const &lhs, Rhs const &rhs)
+    -> flipped_mixed_primitive_dispatch_result_t<Addition, Lhs, Rhs,
+                                                 ErrorPayload> {
+  return apply<Addition, Lhs, Rhs, ErrorPayload>(lhs, rhs);
+}
+
 template <primitive_instance Lhs, primitive_instance Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto sub(Lhs const &lhs, Rhs const &rhs)
     -> primitive_dispatch_result_t<Subtraction, Lhs, Rhs, ErrorPayload> {
   return apply<Subtraction, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
+template <primitive_instance Lhs, underlying_operand Rhs,
+          typename ErrorPayload = policy::error::kind>
+constexpr auto sub(Lhs const &lhs, Rhs const &rhs)
+    -> mixed_primitive_dispatch_result_t<Subtraction, Lhs, Rhs, ErrorPayload> {
+  return apply<Subtraction, Lhs, Rhs, ErrorPayload>(lhs, rhs);
+}
+
+template <underlying_operand Lhs, primitive_instance Rhs,
+          typename ErrorPayload = policy::error::kind>
+constexpr auto sub(Lhs const &lhs, Rhs const &rhs)
+    -> flipped_mixed_primitive_dispatch_result_t<Subtraction, Lhs, Rhs,
+                                                 ErrorPayload> {
+  return apply<Subtraction, Lhs, Rhs, ErrorPayload>(lhs, rhs);
+}
+
 template <primitive_instance Lhs, primitive_instance Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto mul(Lhs const &lhs, Rhs const &rhs)
     -> primitive_dispatch_result_t<Multiplication, Lhs, Rhs, ErrorPayload> {
   return apply<Multiplication, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
+template <primitive_instance Lhs, underlying_operand Rhs,
+          typename ErrorPayload = policy::error::kind>
+constexpr auto mul(Lhs const &lhs, Rhs const &rhs)
+    -> mixed_primitive_dispatch_result_t<Multiplication, Lhs, Rhs,
+                                         ErrorPayload> {
+  return apply<Multiplication, Lhs, Rhs, ErrorPayload>(lhs, rhs);
+}
+
+template <underlying_operand Lhs, primitive_instance Rhs,
+          typename ErrorPayload = policy::error::kind>
+constexpr auto mul(Lhs const &lhs, Rhs const &rhs)
+    -> flipped_mixed_primitive_dispatch_result_t<Multiplication, Lhs, Rhs,
+                                                 ErrorPayload> {
+  return apply<Multiplication, Lhs, Rhs, ErrorPayload>(lhs, rhs);
+}
+
 template <primitive_instance Lhs, primitive_instance Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto div(Lhs const &lhs, Rhs const &rhs)
     -> primitive_dispatch_result_t<Division, Lhs, Rhs, ErrorPayload> {
   return apply<Division, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
+template <primitive_instance Lhs, underlying_operand Rhs,
+          typename ErrorPayload = policy::error::kind>
+constexpr auto div(Lhs const &lhs, Rhs const &rhs)
+    -> mixed_primitive_dispatch_result_t<Division, Lhs, Rhs, ErrorPayload> {
+  return apply<Division, Lhs, Rhs, ErrorPayload>(lhs, rhs);
+}
+
+template <underlying_operand Lhs, primitive_instance Rhs,
+          typename ErrorPayload = policy::error::kind>
+constexpr auto div(Lhs const &lhs, Rhs const &rhs)
+    -> flipped_mixed_primitive_dispatch_result_t<Division, Lhs, Rhs,
+                                                 ErrorPayload> {
+  return apply<Division, Lhs, Rhs, ErrorPayload>(lhs, rhs);
+}
+
 template <primitive_instance Lhs, primitive_instance Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto equal(Lhs const &lhs, Rhs const &rhs)
     -> primitive_dispatch_result_t<Equal, Lhs, Rhs, ErrorPayload> {
   return apply<Equal, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
+template <primitive_instance Lhs, underlying_operand Rhs,
+          typename ErrorPayload = policy::error::kind>
+constexpr auto equal(Lhs const &lhs, Rhs const &rhs)
+    -> mixed_primitive_dispatch_result_t<Equal, Lhs, Rhs, ErrorPayload> {
+  return apply<Equal, Lhs, Rhs, ErrorPayload>(lhs, rhs);
+}
+
+template <underlying_operand Lhs, primitive_instance Rhs,
+          typename ErrorPayload = policy::error::kind>
+constexpr auto equal(Lhs const &lhs, Rhs const &rhs)
+    -> flipped_mixed_primitive_dispatch_result_t<Equal, Lhs, Rhs,
+                                                 ErrorPayload> {
+  return apply<Equal, Lhs, Rhs, ErrorPayload>(lhs, rhs);
+}
+
 template <primitive_instance Lhs, primitive_instance Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto not_equal(Lhs const &lhs, Rhs const &rhs)
     -> primitive_dispatch_result_t<NotEqual, Lhs, Rhs, ErrorPayload> {
   return apply<NotEqual, Lhs, Rhs, ErrorPayload>(lhs, rhs);
 }
 
+template <primitive_instance Lhs, underlying_operand Rhs,
+          typename ErrorPayload = policy::error::kind>
+constexpr auto not_equal(Lhs const &lhs, Rhs const &rhs)
+    -> mixed_primitive_dispatch_result_t<NotEqual, Lhs, Rhs, ErrorPayload> {
+  return apply<NotEqual, Lhs, Rhs, ErrorPayload>(lhs, rhs);
+}
+
+template <underlying_operand Lhs, primitive_instance Rhs,
+          typename ErrorPayload = policy::error::kind>
+constexpr auto not_equal(Lhs const &lhs, Rhs const &rhs)
+    -> flipped_mixed_primitive_dispatch_result_t<NotEqual, Lhs, Rhs,
+                                                 ErrorPayload> {
+  return apply<NotEqual, Lhs, Rhs, ErrorPayload>(lhs, rhs);
+}
+
 template <primitive_instance Lhs, primitive_instance Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto three_way_compare(Lhs const &lhs, Rhs const &rhs)
@@ -151,6 +296,24 @@ constexpr auto three_way_compare(Lhs const &lhs, Rhs const &rhs)
   return details::decode_three_way_code<ordering, common_rep>(*raw);
 }
 
+template <primitive_instance Lhs, underlying_operand Rhs,
+          typename ErrorPayload = policy::error::kind>
+constexpr auto three_way_compare(Lhs const &lhs, Rhs const &rhs)
+    -> mixed_three_way_dispatch_result_t<Lhs, Rhs, ErrorPayload> {
+  using bridge_rhs_t = mixed_bridge_primitive_t<Lhs, Rhs>;
+  auto const bridge_rhs = bridge_rhs_t{rhs};
+  return three_way_compare<Lhs, bridge_rhs_t, ErrorPayload>(lhs, bridge_rhs);
+}
+
+template <underlying_operand Lhs, primitive_instance Rhs,
+          typename ErrorPayload = policy::error::kind>
+constexpr auto three_way_compare(Lhs const &lhs, Rhs const &rhs)
+    -> flipped_mixed_three_way_dispatch_result_t<Lhs, Rhs, ErrorPayload> {
+  using bridge_lhs_t = mixed_bridge_primitive_t<Rhs, Lhs>;
+  auto const bridge_lhs = bridge_lhs_t{lhs};
+  return three_way_compare<bridge_lhs_t, Rhs, ErrorPayload>(bridge_lhs, rhs);
+}
+
 template <operation OpTag, primitive_instance Lhs, primitive_instance Rhs,
           typename ErrorPayload = policy::error::kind>
 constexpr auto apply_assign(Lhs &lhs, Rhs const &rhs)
@@ -223,6 +386,22 @@ constexpr auto operator+(Lhs const &lhs, Rhs const &rhs)
   return operations::add(lhs, rhs);
 }
 
+template <operations::primitive_instance Lhs,
+          operations::underlying_operand Rhs>
+constexpr auto operator+(Lhs const &lhs, Rhs const &rhs)
+    -> operations::mixed_primitive_dispatch_result_t<operations::Addition, Lhs,
+                                                     Rhs> {
+  return operations::add(lhs, rhs);
+}
+
+template <operations::underlying_operand Lhs,
+          operations::primitive_instance Rhs>
+constexpr auto operator+(Lhs const &lhs, Rhs const &rhs)
+    -> operations::flipped_mixed_primitive_dispatch_result_t<
+        operations::Addition, Lhs, Rhs> {
+  return operations::add(lhs, rhs);
+}
+
 template <operations::primitive_instance Lhs,
           operations::primitive_instance Rhs>
 constexpr auto operator-(Lhs const &lhs, Rhs const &rhs)
@@ -231,6 +410,22 @@ constexpr auto operator-(Lhs const &lhs, Rhs const &rhs)
   return operations::sub(lhs, rhs);
 }
 
+template <operations::primitive_instance Lhs,
+          operations::underlying_operand Rhs>
+constexpr auto operator-(Lhs const &lhs, Rhs const &rhs)
+    -> operations::mixed_primitive_dispatch_result_t<operations::Subtraction,
+                                                     Lhs, Rhs> {
+  return operations::sub(lhs, rhs);
+}
+
+template <operations::underlying_operand Lhs,
+          operations::primitive_instance Rhs>
+constexpr auto operator-(Lhs const &lhs, Rhs const &rhs)
+    -> operations::flipped_mixed_primitive_dispatch_result_t<
+        operations::Subtraction, Lhs, Rhs> {
+  return operations::sub(lhs, rhs);
+}
+
 template <operations::primitive_instance Lhs,
           operations::primitive_instance Rhs>
 constexpr auto operator*(Lhs const &lhs, Rhs const &rhs)
@@ -239,34 +434,112 @@ constexpr auto operator*(Lhs const &lhs, Rhs const &rhs)
   return operations::mul(lhs, rhs);
 }
 
+template <operations::primitive_instance Lhs,
+          operations::underlying_operand Rhs>
+constexpr auto operator*(Lhs const &lhs, Rhs const &rhs)
+    -> operations::mixed_primitive_dispatch_result_t<operations::Multiplication,
+                                                     Lhs, Rhs> {
+  return operations::mul(lhs, rhs);
+}
+
+template <operations::underlying_operand Lhs,
+          operations::primitive_instance Rhs>
+constexpr auto operator*(Lhs const &lhs, Rhs const &rhs)
+    -> operations::flipped_mixed_primitive_dispatch_result_t<
+        operations::Multiplication, Lhs, Rhs> {
+  return operations::mul(lhs, rhs);
+}
+
 template <operations::primitive_instance Lhs,
           operations::primitive_instance Rhs>
 constexpr auto operator/(Lhs const &lhs, Rhs const &rhs)
     -> operations::primitive_dispatch_result_t<operations::Division, Lhs, Rhs> {
   return operations::div(lhs, rhs);
 }
 
+template <operations::primitive_instance Lhs,
+          operations::underlying_operand Rhs>
+constexpr auto operator/(Lhs const &lhs, Rhs const &rhs)
+    -> operations::mixed_primitive_dispatch_result_t<operations::Division, Lhs,
+                                                     Rhs> {
+  return operations::div(lhs, rhs);
+}
+
+template <operations::underlying_operand Lhs,
+          operations::primitive_instance Rhs>
+constexpr auto operator/(Lhs const &lhs, Rhs const &rhs)
+    -> operations::flipped_mixed_primitive_dispatch_result_t<
+        operations::Division, Lhs, Rhs> {
+  return operations::div(lhs, rhs);
+}
+
 template <operations::primitive_instance Lhs,
           operations::primitive_instance Rhs>
 constexpr auto operator==(Lhs const &lhs, Rhs const &rhs)
     -> operations::primitive_dispatch_result_t<operations::Equal, Lhs, Rhs> {
   return operations::equal(lhs, rhs);
 }
 
+template <operations::primitive_instance Lhs,
+          operations::underlying_operand Rhs>
+constexpr auto operator==(Lhs const &lhs, Rhs const &rhs)
+    -> operations::mixed_primitive_dispatch_result_t<operations::Equal, Lhs,
+                                                     Rhs> {
+  return operations::equal(lhs, rhs);
+}
+
+template <operations::underlying_operand Lhs,
+          operations::primitive_instance Rhs>
+constexpr auto operator==(Lhs const &lhs, Rhs const &rhs)
+    -> operations::flipped_mixed_primitive_dispatch_result_t<operations::Equal,
+                                                             Lhs, Rhs> {
+  return operations::equal(lhs, rhs);
+}
+
 template <operations::primitive_instance Lhs,
           operations::primitive_instance Rhs>
 constexpr auto operator!=(Lhs const &lhs, Rhs const &rhs)
     -> operations::primitive_dispatch_result_t<operations::NotEqual, Lhs, Rhs> {
   return operations::not_equal(lhs, rhs);
 }
 
+template <operations::primitive_instance Lhs,
+          operations::underlying_operand Rhs>
+constexpr auto operator!=(Lhs const &lhs, Rhs const &rhs)
+    -> operations::mixed_primitive_dispatch_result_t<operations::NotEqual, Lhs,
+                                                     Rhs> {
+  return operations::not_equal(lhs, rhs);
+}
+
+template <operations::underlying_operand Lhs,
+          operations::primitive_instance Rhs>
+constexpr auto operator!=(Lhs const &lhs, Rhs const &rhs)
+    -> operations::flipped_mixed_primitive_dispatch_result_t<
+        operations::NotEqual, Lhs, Rhs> {
+  return operations::not_equal(lhs, rhs);
+}
+
 template <operations::primitive_instance Lhs,
           operations::primitive_instance Rhs>
 constexpr auto operator<=>(Lhs const &lhs, Rhs const &rhs)
     -> operations::three_way_dispatch_result_t<Lhs, Rhs> {
   return operations::three_way_compare(lhs, rhs);
 }
 
+template <operations::primitive_instance Lhs,
+          operations::underlying_operand Rhs>
+constexpr auto operator<=>(Lhs const &lhs, Rhs const &rhs)
+    -> operations::mixed_three_way_dispatch_result_t<Lhs, Rhs> {
+  return operations::three_way_compare(lhs, rhs);
+}
+
+template <operations::underlying_operand Lhs,
+          operations::primitive_instance Rhs>
+constexpr auto operator<=>(Lhs const &lhs, Rhs const &rhs)
+    -> operations::flipped_mixed_three_way_dispatch_result_t<Lhs, Rhs> {
+  return operations::three_way_compare(lhs, rhs);
+}
+
 template <operations::primitive_instance Lhs,
           operations::primitive_instance Rhs>
 constexpr auto operator+=(Lhs &lhs, Rhs const &rhs)