refactor: convertible_to(U1, U2) renamed to convertible(U1, U2)

src/core/include/mp_units/bits/value_cast.h

@@ -44,7 +44,7 @@ class quantity;
  * @tparam ToU a unit to use for a target quantity
  */
 template<Unit auto ToU, auto R, typename Rep>
-  requires(convertible_to(get_unit(R), ToU))
+  requires(convertible(get_unit(R), ToU))
 [[nodiscard]] constexpr Quantity auto value_cast(const quantity<R, Rep>& q)
 {
   if constexpr (detail::is_specialization_of_reference<std::remove_const_t<decltype(R)>> ||

src/core/include/mp_units/quantity.h

@@ -59,7 +59,7 @@ concept Harmonic =  // exposition only
 template<typename QFrom, typename QTo>
 concept QuantityConvertibleTo =  // exposition only
   Quantity<QFrom> && Quantity<QTo> && implicitly_convertible(QFrom::quantity_spec, QTo::quantity_spec) &&
-  convertible_to(QFrom::unit, QTo::unit) && requires(QFrom q) { detail::sudo_cast<QTo>(q); } &&
+  convertible(QFrom::unit, QTo::unit) && requires(QFrom q) { detail::sudo_cast<QTo>(q); } &&
   (treat_as_floating_point<typename QTo::rep> ||
    (!treat_as_floating_point<typename QFrom::rep> && Harmonic<QFrom::unit, QTo::unit>));
 
@@ -73,9 +73,11 @@ concept InvocableQuantities =
                  typename Q2::rep> &&
   requires { common_reference(Q1::reference, Q2::reference); } &&
   std::constructible_from<quantity<common_reference(Q1::reference, Q2::reference),
-                                   std::invoke_result_t<Func, typename Q1::rep, typename Q2::rep>>, Q1> &&
+                                   std::invoke_result_t<Func, typename Q1::rep, typename Q2::rep>>,
+                          Q1> &&
   std::constructible_from<quantity<common_reference(Q1::reference, Q2::reference),
-                                   std::invoke_result_t<Func, typename Q1::rep, typename Q2::rep>>, Q2>;
+                                   std::invoke_result_t<Func, typename Q1::rep, typename Q2::rep>>,
+                          Q2>;
 
 template<typename Func, Quantity Q1, Quantity Q2>
   requires detail::InvocableQuantities<Func, Q1, Q2>
@@ -523,7 +525,6 @@ public:
 template<mp_units::Quantity Q, typename Value>
   requires(!mp_units::Quantity<Value>) && (Q::dimension == mp_units::dimension_one) && (Q::unit == mp_units::one) &&
           requires { typename common_type_t<typename Q::rep, Value>; }
-struct common_type<Value, Q> : common_type<Q, Value> {
-};
+struct common_type<Value, Q> : common_type<Q, Value> {};
 
 }  // namespace std

src/core/include/mp_units/reference.h

@@ -73,7 +73,7 @@ struct reference {
   }
 
   template<AssociatedUnit U2>
-  [[nodiscard]] friend consteval reference<Q * get_quantity_spec(U2{}), U* U2{}> operator*(reference, U2)
+  [[nodiscard]] friend consteval reference<Q * get_quantity_spec(U2{}), U * U2{}> operator*(reference, U2)
   {
     return {};
   }
@@ -103,21 +103,21 @@ struct reference {
   }
 
   template<auto Q2, auto U2>
-  [[nodiscard]] friend consteval bool convertible_to(reference, reference<Q2, U2>)
+  [[nodiscard]] friend consteval bool convertible(reference, reference<Q2, U2>)
   {
-    return implicitly_convertible(Q, Q2) && convertible_to(U, U2);
+    return implicitly_convertible(Q, Q2) && convertible(U, U2);
   }
 
   template<AssociatedUnit U2>
-  [[nodiscard]] friend consteval bool convertible_to(reference, U2 u2)
+  [[nodiscard]] friend consteval bool convertible(reference, U2 u2)
   {
-    return implicitly_convertible(Q, get_quantity_spec(u2)) && convertible_to(U, u2);
+    return implicitly_convertible(Q, get_quantity_spec(u2)) && convertible(U, u2);
   }
 
   template<AssociatedUnit U1>
-  [[nodiscard]] friend consteval bool convertible_to(U1 u1, reference)
+  [[nodiscard]] friend consteval bool convertible(U1 u1, reference)
   {
-    return implicitly_convertible(get_quantity_spec(u1), Q) && convertible_to(u1, U);
+    return implicitly_convertible(get_quantity_spec(u1), Q) && convertible(u1, U);
   }
 };
 

src/core/include/mp_units/system_reference.h

@@ -62,7 +62,7 @@ struct system_reference {
   static constexpr auto coherent_unit = CoU;
 
   template<Unit U>
-    requires(convertible_to(coherent_unit, U{}))
+    requires(convertible(coherent_unit, U{}))
   [[nodiscard]] constexpr reference<quantity_spec, U{}> operator[](U) const
   {
     return {};

src/core/include/mp_units/unit.h

@@ -596,7 +596,7 @@ inline constexpr struct per_mille : named_unit<basic_symbol_text{"‰", "%o"}, m
 
 
 // convertible_to
-[[nodiscard]] consteval bool convertible_to(Unit auto u1, Unit auto u2)
+[[nodiscard]] consteval bool convertible(Unit auto from, Unit auto to)
 {
   return detail::have_same_canonical_reference_unit(u1, u2);
 }

test/unit_test/static/unit_test.cpp

@@ -128,15 +128,15 @@ static_assert(!NamedUnit<kilometre_>);
 static_assert(is_of_type<metre, metre_>);
 static_assert(is_of_type<get_canonical_unit(metre).reference_unit, metre_>);
 static_assert(get_canonical_unit(metre).mag == mag<1>);
-static_assert(convertible_to(metre, metre));
-static_assert(!convertible_to(metre, second));
+static_assert(convertible(metre, metre));
+static_assert(!convertible(metre, second));
 static_assert(metre == metre);
 static_assert(metre != second);
 
 static_assert(is_of_type<degree_Celsius, degree_Celsius_>);
 static_assert(is_of_type<get_canonical_unit(degree_Celsius).reference_unit, kelvin_>);
 static_assert(get_canonical_unit(degree_Celsius).mag == mag<1>);
-static_assert(convertible_to(degree_Celsius, kelvin));
+static_assert(convertible(degree_Celsius, kelvin));
 static_assert(degree_Celsius == kelvin);
 
 static_assert(is_of_type<radian, radian_>);
@@ -146,28 +146,28 @@ static_assert(get_canonical_unit(radian).mag == mag<1>);
 static_assert(is_of_type<degree, degree_>);
 static_assert(is_of_type<get_canonical_unit(degree).reference_unit, one_>);
 static_assert(get_canonical_unit(degree).mag == mag_pi / mag<180>);
-static_assert(convertible_to(radian, degree));
+static_assert(convertible(radian, degree));
 static_assert(radian != degree);
 
 static_assert(is_of_type<steradian, steradian_>);
 static_assert(is_of_type<get_canonical_unit(steradian).reference_unit, one_>);
 static_assert(get_canonical_unit(steradian).mag == mag<1>);
-static_assert(convertible_to(radian, steradian));  // !!!
+static_assert(convertible(radian, steradian));  // !!!
 static_assert(radian == steradian);             // !!!
 
 static_assert(is_of_type<minute, minute_>);
 static_assert(is_of_type<get_canonical_unit(minute).reference_unit, second_>);
 static_assert(get_canonical_unit(minute).mag == mag<60>);
-static_assert(convertible_to(minute, second));
+static_assert(convertible(minute, second));
 static_assert(minute != second);
 
 static_assert(is_of_type<hour, hour_>);
 static_assert(is_of_type<get_canonical_unit(hour).reference_unit, second_>);
 static_assert(get_canonical_unit(hour).mag == mag<3600>);
-static_assert(convertible_to(hour, second));
+static_assert(convertible(hour, second));
 
-static_assert(convertible_to(hour, minute));
-static_assert(convertible_to(hour, hour));
+static_assert(convertible(hour, minute));
+static_assert(convertible(hour, hour));
 static_assert(hour != second);
 static_assert(hour != minute);
 static_assert(hour == hour);
@@ -176,14 +176,14 @@ static_assert(is_of_type<newton, newton_>);
 static_assert(
   is_of_type<get_canonical_unit(newton).reference_unit, derived_unit<gram_, metre_, per<power<second_, 2>>>>);
 static_assert(get_canonical_unit(newton).mag == mag<1000>);  // !!! (because of kilogram)
-static_assert(convertible_to(newton, newton));
+static_assert(convertible(newton, newton));
 static_assert(newton == newton);
 
 static_assert(is_of_type<joule, joule_>);
 static_assert(
   is_of_type<get_canonical_unit(joule).reference_unit, derived_unit<gram_, power<metre_, 2>, per<power<second_, 2>>>>);
 static_assert(get_canonical_unit(joule).mag == mag<1000>);  // !!! (because of kilogram)
-static_assert(convertible_to(joule, joule));
+static_assert(convertible(joule, joule));
 static_assert(joule == joule);
 static_assert(joule != newton);
 
@@ -194,8 +194,8 @@ static_assert(is_of_type<standard_gravity_unit, standard_gravity_unit_>);
 static_assert(
   is_of_type<get_canonical_unit(standard_gravity_unit).reference_unit, derived_unit<metre_, per<power<second_, 2>>>>);
 static_assert(get_canonical_unit(standard_gravity_unit).mag == mag<ratio{980'665, 100'000}>);
-static_assert(convertible_to(standard_gravity_unit, standard_gravity_unit));
-static_assert(convertible_to(standard_gravity_unit, metre / square<second>));
+static_assert(convertible(standard_gravity_unit, standard_gravity_unit));
+static_assert(convertible(standard_gravity_unit, metre / square<second>));
 static_assert(standard_gravity_unit == standard_gravity_unit);
 static_assert(standard_gravity_unit != metre / square<second>);  // magnitude is different
 static_assert(standard_gravity_unit.symbol == "[g]");
@@ -204,7 +204,7 @@ static_assert(standard_gravity_unit.symbol == "[g]");
 static_assert(is_of_type<kilometre, kilometre_>);
 static_assert(is_of_type<get_canonical_unit(kilometre).reference_unit, metre_>);
 static_assert(get_canonical_unit(kilometre).mag == mag<1000>);
-static_assert(convertible_to(kilometre, metre));
+static_assert(convertible(kilometre, metre));
 static_assert(kilometre != metre);
 static_assert(kilometre.symbol == "km");
 
@@ -212,7 +212,7 @@ static_assert(is_of_type<kilojoule, kilojoule_>);
 static_assert(is_of_type<get_canonical_unit(kilojoule).reference_unit,
                          derived_unit<gram_, power<metre_, 2>, per<power<second_, 2>>>>);
 static_assert(get_canonical_unit(kilojoule).mag == mag<1'000'000>);
-static_assert(convertible_to(kilojoule, joule));
+static_assert(convertible(kilojoule, joule));
 static_assert(kilojoule != joule);
 static_assert(kilojoule.symbol == "kJ");
 
@@ -442,30 +442,30 @@ static_assert(si::kilo<metre> * si::milli<metre> == si::deca<metre> * si::deci<m
 
 // comparisons of equivalent units (named vs unnamed/derived)
 static_assert(1 / second == hertz);
-static_assert(convertible_to(1 / second, hertz));
+static_assert(convertible(1 / second, hertz));
 
 // comparisons of equivalent units of different quantities
 static_assert(hertz == becquerel);
-static_assert(convertible_to(hertz, becquerel));
+static_assert(convertible(hertz, becquerel));
 
 // comparisons of scaled units
 static_assert(si::kilo<metre> == kilometre);
 static_assert(mag<1000> * metre == si::kilo<metre>);
 static_assert(mag<1000> * metre == kilometre);
-static_assert(convertible_to(si::kilo<metre>, kilometre));
-static_assert(convertible_to(mag<1000> * metre, si::kilo<metre>));
-static_assert(convertible_to(mag<1000> * metre, kilometre));
+static_assert(convertible(si::kilo<metre>, kilometre));
+static_assert(convertible(mag<1000> * metre, si::kilo<metre>));
+static_assert(convertible(mag<1000> * metre, kilometre));
 
 static_assert(metre != kilometre);
-static_assert(convertible_to(metre, kilometre));
+static_assert(convertible(metre, kilometre));
 static_assert(mag<100> * metre != kilometre);
-static_assert(convertible_to(mag<100> * metre, kilometre));
+static_assert(convertible(mag<100> * metre, kilometre));
 static_assert(si::milli<metre> != kilometre);
-static_assert(convertible_to(si::milli<metre>, kilometre));
+static_assert(convertible(si::milli<metre>, kilometre));
 
 // comparisons of non-convertible units
 static_assert(metre != metre * metre);
-static_assert(!convertible_to(metre, metre* metre));
+static_assert(!convertible(metre, metre* metre));
 
 // one
 static_assert(is_of_type<metre / metre, one_>);