diff --git a/example/avg_speed.cpp b/example/avg_speed.cpp
index dc2d24d2..11072bb3 100644
--- a/example/avg_speed.cpp
+++ b/example/avg_speed.cpp
@@ -45,26 +45,26 @@ namespace {
 
 using namespace mp_units;
 
-constexpr quantity<si::metre / si::second, int> fixed_int_si_avg_speed(quantity<si::metre, int> d,
-                                                                       quantity<si::second, int> t)
+constexpr quantity<si::metre / si::second, int> fixed_int_si_avg_speed(quantity<(si::metre), int> d,
+                                                                       quantity<(si::second), int> t)
 {
   return d / t;
 }
 
-constexpr quantity<si::metre / si::second> fixed_double_si_avg_speed(quantity<si::metre> d, quantity<si::second> t)
+constexpr quantity<si::metre / si::second> fixed_double_si_avg_speed(quantity<(si::metre)> d, quantity<(si::second)> t)
 {
   return d / t;
 }
 
-constexpr QuantityOf<isq::speed> auto avg_speed(QuantityOf<isq::length> auto d, QuantityOf<isq::time> auto t)
+constexpr QuantityOf<(isq::speed)> auto avg_speed(QuantityOf<(isq::length)> auto d, QuantityOf<(isq::time)> auto t)
 {
   return d / t;
 }
 
-template<QuantityOf<isq::length> D, QuantityOf<isq::time> T, QuantityOf<isq::speed> V>
+template<QuantityOf<(isq::length)> D, QuantityOf<(isq::time)> T, QuantityOf<(isq::speed)> V>
 void print_result(D distance, T duration, V speed)
 {
-  const auto result_in_kmph = speed.force_in(si::kilo<si::metre> / non_si::hour);
+  const auto result_in_kmph = speed.force_in((si::kilo<(si::metre)> / non_si::hour));
   std::cout << "Average speed of a car that makes " << distance << " in " << duration << " is " << result_in_kmph
             << ".\n";
 }
diff --git a/example/capacitor_time_curve.cpp b/example/capacitor_time_curve.cpp
index 4cf363fe..2f2f7fdb 100644
--- a/example/capacitor_time_curve.cpp
+++ b/example/capacitor_time_curve.cpp
@@ -48,7 +48,7 @@ int main()
   constexpr auto RR = isq::resistance(4.7 * si::kilo<si::ohm>);
 
   for (auto tt = 0 * ms; tt <= 50 * ms; ++tt) {
-    const QuantityOf<isq::voltage> auto Vt = V0 * exp(dimensionless(-tt / (RR * CC)));
+    const QuantityOf<(isq::voltage)> auto Vt = V0 * exp(dimensionless(-tt / (RR * CC)));
     // TODO try to make the below work instead
     // const QuantityOf<isq::voltage> auto Vt = V0 * exp(-tt / (RR * CC));
 
diff --git a/example/clcpp_response.cpp b/example/clcpp_response.cpp
index 42ed6d0b..9a74de52 100644
--- a/example/clcpp_response.cpp
+++ b/example/clcpp_response.cpp
@@ -44,8 +44,8 @@ void simple_quantities()
   using namespace mp_units::si;
   using namespace mp_units::international;
 
-  using distance = quantity<isq::distance[kilo<metre>]>;
-  using duration = quantity<isq::duration[second]>;
+  using distance = quantity<(isq::distance[kilo<metre>])>;
+  using duration = quantity<(isq::duration[second])>;
 
   constexpr distance km = 1. * kilo<metre>;
   constexpr distance miles = 1. * mile;
diff --git a/example/currency.cpp b/example/currency.cpp
index 6f280659..0eb46040 100644
--- a/example/currency.cpp
+++ b/example/currency.cpp
@@ -90,11 +90,11 @@ template<Unit auto From, Unit auto To>
 
 #endif
 
-template<ReferenceOf<currency> auto To, ReferenceOf<currency> auto From, typename Rep>
-quantity<To, Rep> exchange_to(quantity<From, Rep> q)
-{
-  return static_cast<Rep>(exchange_rate<q.unit, get_unit(To)>() * q.numerical_value()) * To;
-}
+// template<ReferenceOf<currency> auto To, ReferenceOf<currency> auto From, typename Rep>
+// quantity<To, Rep> exchange_to(quantity<From, Rep> q)
+// {
+//   return static_cast<Rep>(exchange_rate<q.unit, get_unit(To)>() * q.numerical_value()) * To;
+// }
 
 template<ReferenceOf<currency> auto To, ReferenceOf<currency> auto From, auto PO, typename Rep>
 quantity_point<To, PO, Rep> exchange_to(quantity_point<From, PO, Rep> q)
@@ -107,8 +107,8 @@ int main()
 {
   using namespace unit_symbols;
 
-  const quantity_point price_usd{100 * USD};
-  const quantity_point price_euro = exchange_to<euro>(price_usd);
+  const mp_units::quantity_point price_usd{100 * USD};
+  const mp_units::quantity_point<euro, default_point_origin(euro), int> price_euro = exchange_to<euro>(price_usd);
 
   std::cout << price_usd.quantity_from_zero() << " -> " << price_euro.quantity_from_zero() << "\n";
   // std::cout << price_usd.quantity_from_zero() + price_euro.quantity_from_zero() << "\n";  // does
diff --git a/example/glide_computer.cpp b/example/glide_computer.cpp
index 133a7713..f06062fe 100644
--- a/example/glide_computer.cpp
+++ b/example/glide_computer.cpp
@@ -169,7 +169,7 @@ void example()
   const auto gliders = get_gliders();
   const auto waypoints = get_waypoints();
   const auto weather_conditions = get_weather_conditions();
-  const task t = {waypoints[0], waypoints[1], waypoints[0]};
+  const task glider_task = {waypoints[0], waypoints[1], waypoints[0]};
   const aircraft_tow tow = {400 * m, 1.6 * m / s};
   const timestamp start_time(std::chrono::system_clock::now());
 
@@ -177,16 +177,16 @@ void example()
   print(gliders);
   print(waypoints);
   print(weather_conditions);
-  print(t);
+  print(glider_task);
   print(tow);
 
-  for (const auto& g : gliders) {
+  for (const auto& glider : gliders) {
     for (const auto& c : weather_conditions) {
-      const std::string txt = "Scenario: Glider = " + g.name + ", Weather = " + c.first;
+      const std::string txt = "Scenario: Glider = " + glider.name + ", Weather = " + c.first;
       std::cout << txt << "\n";
       std::cout << MP_UNITS_STD_FMT::format("{0:=^{1}}\n\n", "", txt.size());
 
-      estimate(start_time, g, c.second, t, sfty, tow);
+      estimate(start_time, glider, c.second, glider_task, sfty, tow);
 
       std::cout << "\n\n";
     }
diff --git a/example/glide_computer_lib/include/glide_computer_lib.h b/example/glide_computer_lib/include/glide_computer_lib.h
index 5e2ac4db..e8fafbf3 100644
--- a/example/glide_computer_lib/include/glide_computer_lib.h
+++ b/example/glide_computer_lib/include/glide_computer_lib.h
@@ -90,7 +90,7 @@ struct glider {
   std::array<polar_point, 1> polar;
 };
 
-constexpr mp_units::QuantityOf<mp_units::dimensionless> auto glide_ratio(const glider::polar_point& polar)
+constexpr mp_units::QuantityOf<(mp_units::dimensionless)> auto glide_ratio(const glider::polar_point& polar)
 {
   return polar.v / -polar.climb;
 }
diff --git a/example/hello_units.cpp b/example/hello_units.cpp
index e635bc25..95b5e6d6 100644
--- a/example/hello_units.cpp
+++ b/example/hello_units.cpp
@@ -45,7 +45,7 @@ import mp_units;
 
 using namespace mp_units;
 
-constexpr QuantityOf<isq::speed> auto avg_speed(QuantityOf<isq::length> auto d, QuantityOf<isq::time> auto t)
+constexpr QuantityOf<(isq::speed)> auto avg_speed(QuantityOf<(isq::length)> auto d, QuantityOf<(isq::time)> auto t)
 {
   return d / t;
 }
diff --git a/example/include/geographic.h b/example/include/geographic.h
index ba26b3f1..4f7ca94a 100644
--- a/example/include/geographic.h
+++ b/example/include/geographic.h
@@ -79,10 +79,10 @@ inline constexpr struct prime_meridian final : mp_units::absolute_point_origin<m
 
 
 template<typename T = double>
-using latitude = mp_units::quantity_point<mp_units::si::degree, equator, ranged_representation<T, -90, 90>>;
+using latitude = mp_units::quantity_point<(mp_units::si::degree), equator, ranged_representation<T, -90, 90>>;
 
 template<typename T = double>
-using longitude = mp_units::quantity_point<mp_units::si::degree, prime_meridian, ranged_representation<T, -180, 180>>;
+using longitude = mp_units::quantity_point<(mp_units::si::degree), prime_meridian, ranged_representation<T, -180, 180>>;
 
 template<class CharT, class Traits, typename T>
 std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& os, const latitude<T>& lat)
@@ -176,7 +176,7 @@ template<typename T>
 distance spherical_distance(position<T> from, position<T> to)
 {
   using namespace mp_units;
-  constexpr quantity earth_radius = 6'371 * isq::radius[si::kilo<si::metre>];
+  constexpr quantity earth_radius = 6'371 * isq::radius[si::kilo<(si::metre)>];
 
   using si::sin, si::cos, si::asin, si::acos;
 
@@ -193,7 +193,7 @@ distance spherical_distance(position<T> from, position<T> to)
     // const auto central_angle = 2 * asin(sqrt(0.5 - cos(to_lat - from_lat) / 2 + cos(from_lat) * cos(to_lat) * (1
     // - cos(lon2_rad - from_lon)) / 2));
 
-    return quantity_cast<isq::distance>(earth_radius * central_angle);
+    return quantity_cast<(isq::distance)>(earth_radius * central_angle);
   } else {
     // the haversine formula
     const quantity sin_lat = sin((to_lat - from_lat) / 2);
diff --git a/example/kalman_filter/kalman.h b/example/kalman_filter/kalman.h
index 90d0d506..80179790 100644
--- a/example/kalman_filter/kalman.h
+++ b/example/kalman_filter/kalman.h
@@ -116,15 +116,15 @@ template<mp_units::Quantity Q1, mp_units::Quantity Q2>
 }
 
 // state update
-template<typename QP, mp_units::QuantityPoint QM, mp_units::QuantityOf<mp_units::dimensionless> K>
+template<typename QP, mp_units::QuantityPoint QM, mp_units::QuantityOf<(mp_units::dimensionless)> K>
   requires(implicitly_convertible(QM::quantity_spec, QP::quantity_spec))
 [[nodiscard]] constexpr system_state<QP> state_update(const system_state<QP>& predicted, QM measured, K gain)
 {
   return system_state<QP>{get<0>(predicted) + gain * (measured - get<0>(predicted))};
 }
 
-template<typename QP1, typename QP2, mp_units::QuantityPoint QM, mp_units::QuantityOf<mp_units::dimensionless> K,
-         mp_units::QuantityOf<mp_units::isq::time> T>
+template<typename QP1, typename QP2, mp_units::QuantityPoint QM, mp_units::QuantityOf<(mp_units::dimensionless)> K,
+         mp_units::QuantityOf<(mp_units::isq::time)> T>
   requires(implicitly_convertible(QM::quantity_spec, QP1::quantity_spec))
 [[nodiscard]] constexpr system_state<QP1, QP2> state_update(const system_state<QP1, QP2>& predicted, QM measured,
                                                             std::array<K, 2> gain, T interval)
@@ -135,7 +135,7 @@ template<typename QP1, typename QP2, mp_units::QuantityPoint QM, mp_units::Quant
 }
 
 template<typename QP1, typename QP2, typename QP3, mp_units::QuantityPoint QM,
-         mp_units::QuantityOf<mp_units::dimensionless> K, mp_units::QuantityOf<mp_units::isq::time> T>
+         mp_units::QuantityOf<(mp_units::dimensionless)> K, mp_units::QuantityOf<(mp_units::isq::time)> T>
   requires(implicitly_convertible(QM::quantity_spec, QP1::quantity_spec))
 [[nodiscard]] constexpr system_state<QP1, QP2, QP3> state_update(const system_state<QP1, QP2, QP3>& predicted,
                                                                  QM measured, std::array<K, 3> gain, T interval)
@@ -147,13 +147,13 @@ template<typename QP1, typename QP2, typename QP3, mp_units::QuantityPoint QM,
 }
 
 // covariance update
-template<mp_units::Quantity Q, mp_units::QuantityOf<mp_units::dimensionless> K>
+template<mp_units::Quantity Q, mp_units::QuantityOf<(mp_units::dimensionless)> K>
 [[nodiscard]] constexpr Q covariance_update(Q uncertainty, K gain)
 {
   return (1 * mp_units::one - gain) * uncertainty;
 }
 
-template<mp_units::QuantityPoint... QPs, mp_units::QuantityPoint QP, mp_units::QuantityOf<mp_units::dimensionless> K>
+template<mp_units::QuantityPoint... QPs, mp_units::QuantityPoint QP, mp_units::QuantityOf<(mp_units::dimensionless)> K>
 [[nodiscard]] constexpr system_state_estimate<QPs...> state_estimate_update(
   const system_state_estimate<QPs...>& previous, QP measurement, K gain)
 {
@@ -162,7 +162,7 @@ template<mp_units::QuantityPoint... QPs, mp_units::QuantityPoint QP, mp_units::Q
 
 
 // state extrapolation
-template<typename QP1, typename QP2, mp_units::QuantityOf<mp_units::isq::time> T>
+template<typename QP1, typename QP2, mp_units::QuantityOf<(mp_units::isq::time)> T>
 [[nodiscard]] constexpr system_state<QP1, QP2> state_extrapolation(const system_state<QP1, QP2>& estimated, T interval)
 {
   auto to_quantity = [](const auto& qp) { return qp.quantity_ref_from(qp.point_origin); };
@@ -171,7 +171,7 @@ template<typename QP1, typename QP2, mp_units::QuantityOf<mp_units::isq::time> T
   return system_state<QP1, QP2>{qp1, qp2};
 }
 
-template<typename QP1, typename QP2, typename QP3, mp_units::QuantityOf<mp_units::isq::time> T>
+template<typename QP1, typename QP2, typename QP3, mp_units::QuantityOf<(mp_units::isq::time)> T>
 [[nodiscard]] constexpr system_state<QP1, QP2, QP3> state_extrapolation(const system_state<QP1, QP2, QP3>& estimated,
                                                                         T interval)
 {
diff --git a/example/measurement.cpp b/example/measurement.cpp
index b0cf594b..d7650c21 100644
--- a/example/measurement.cpp
+++ b/example/measurement.cpp
@@ -151,7 +151,7 @@ void example()
   const auto acceleration = isq::acceleration(measurement{9.8, 0.1} * m / s2);
   const auto time = measurement{1.2, 0.1} * s;
 
-  const QuantityOf<isq::velocity> auto velocity = acceleration * time;
+  const QuantityOf<(isq::velocity)> auto velocity = acceleration * time;
   std::cout << acceleration << " * " << time << " = " << velocity << " = " << velocity.in(km / h) << '\n';
 
   const auto length = measurement{123., 1.} * m;
diff --git a/example/spectroscopy_units.cpp b/example/spectroscopy_units.cpp
index 3fce6a8b..d618b3b3 100644
--- a/example/spectroscopy_units.cpp
+++ b/example/spectroscopy_units.cpp
@@ -54,8 +54,8 @@ constexpr auto h = 1 * si::si2019::planck_constant;
 constexpr auto kb = 1 * si::si2019::boltzmann_constant;
 
 // prints quantities in the resulting unit
-template<QuantityOf<isq::energy> T1, QuantityOf<isq::wavenumber> T2, QuantityOf<isq::frequency> T3,
-         QuantityOf<isq::thermodynamic_temperature> T4, QuantityOf<isq::wavelength> T5>
+template<QuantityOf<(isq::energy)> T1, QuantityOf<(isq::wavenumber)> T2, QuantityOf<(isq::frequency)> T3,
+         QuantityOf<(isq::thermodynamic_temperature)> T4, QuantityOf<(isq::wavelength)> T5>
 void print_line(const std::tuple<T1, T2, T3, T4, T5>& t)
 {
   std::cout << MP_UNITS_STD_FMT::format(
@@ -65,8 +65,8 @@ void print_line(const std::tuple<T1, T2, T3, T4, T5>& t)
 
 // prints quantities in semi-SI units
 // (eV is not an official SI unit)
-template<QuantityOf<isq::energy> T1, QuantityOf<isq::wavenumber> T2, QuantityOf<isq::frequency> T3,
-         QuantityOf<isq::thermodynamic_temperature> T4, QuantityOf<isq::wavelength> T5>
+template<QuantityOf<(isq::energy)> T1, QuantityOf<(isq::wavenumber)> T2, QuantityOf<(isq::frequency)> T3,
+         QuantityOf<(isq::thermodynamic_temperature)> T4, QuantityOf<(isq::wavelength)> T5>
 void print_line_si(const std::tuple<T1, T2, T3, T4, T5>& t)
 {
   std::cout << MP_UNITS_STD_FMT::format(
diff --git a/example/storage_tank.cpp b/example/storage_tank.cpp
index 86bc32ff..44b24738 100644
--- a/example/storage_tank.cpp
+++ b/example/storage_tank.cpp
@@ -77,10 +77,10 @@ public:
     density_ = density;
   }
 
-  [[nodiscard]] constexpr QuantityOf<isq::weight> auto filled_weight() const
+  [[nodiscard]] constexpr QuantityOf<(isq::weight)> auto filled_weight() const
   {
     const auto volume = isq::volume(base_ * height_);  // TODO check if we can remove that cast
-    const QuantityOf<isq::mass> auto mass = density_ * volume;
+    const QuantityOf<(isq::mass)> auto mass = density_ * volume;
     return isq::weight(mass * g);
   }
 
@@ -130,9 +130,9 @@ int main()
   const quantity spare_capacity = tank.spare_capacity(measured_mass);
   const quantity filled_weight = tank.filled_weight();
 
-  const QuantityOf<isq::mass_change_rate> auto input_flow_rate = measured_mass / fill_time;
-  const QuantityOf<isq::speed> auto float_rise_rate = fill_level / fill_time;
-  const QuantityOf<isq::time> auto fill_time_left = (height / fill_level - 1 * one) * fill_time;
+  const QuantityOf<(isq::mass_change_rate)> auto input_flow_rate = measured_mass / fill_time;
+  const QuantityOf<(isq::speed)> auto float_rise_rate = fill_level / fill_time;
+  const QuantityOf<(isq::time)> auto fill_time_left = (height / fill_level - 1 * one) * fill_time;
 
   const quantity fill_ratio = fill_level / height;
 
diff --git a/example/total_energy.cpp b/example/total_energy.cpp
index 75416bb7..28963f6b 100644
--- a/example/total_energy.cpp
+++ b/example/total_energy.cpp
@@ -45,8 +45,8 @@ namespace {
 
 using namespace mp_units;
 
-QuantityOf<isq::mechanical_energy> auto total_energy(QuantityOf<isq::momentum> auto p, QuantityOf<isq::mass> auto m,
-                                                     QuantityOf<isq::speed> auto c)
+QuantityOf<(isq::mechanical_energy)> auto total_energy(QuantityOf<(isq::momentum)> auto p,
+                                                       QuantityOf<(isq::mass)> auto m, QuantityOf<(isq::speed)> auto c)
 {
   return isq::mechanical_energy(sqrt(pow<2>(p * c) + pow<2>(m * pow<2>(c))));
 }
@@ -59,19 +59,19 @@ void si_example()
   const quantity c2 = pow<2>(c);
 
   const quantity p1 = isq::momentum(4. * GeV / c);
-  const QuantityOf<isq::mass> auto m1 = 3. * GeV / c2;
-  const quantity E = total_energy(p1, m1, c);
+  const QuantityOf<(isq::mass)> auto m1 = 3. * GeV / c2;
+  const quantity E1 = total_energy(p1, m1, c);
 
   std::cout << "\n*** SI units (c = " << c << " = " << c.in(si::metre / s) << ") ***\n";
 
   std::cout << "\n[in `GeV` and `c`]\n"
             << "p = " << p1 << "\n"
             << "m = " << m1 << "\n"
-            << "E = " << E << "\n";
+            << "E = " << E1 << "\n";
 
   const quantity p2 = p1.in(GeV / (m / s));
-  const quantity m2 = m1.in(GeV / pow<2>(m / s));
-  const quantity E2 = total_energy(p2, m2, c).in(GeV);
+  const quantity metre2 = m1.in(GeV / pow<2>(m / s));
+  const quantity E2 = total_energy(p2, metre2, c).in(GeV);
 
   std::cout << "\n[in `GeV`]\n"
             << "p = " << p2 << "\n"
@@ -79,8 +79,8 @@ void si_example()
             << "E = " << E2 << "\n";
 
   const quantity p3 = p1.in(kg * m / s);
-  const quantity m3 = m1.in(kg);
-  const quantity E3 = total_energy(p3, m3, c).in(J);
+  const quantity metre3 = m1.in(kg);
+  const quantity E3 = total_energy(p3, metre3, c).in(J);
 
   std::cout << "\n[in SI base units]\n"
             << "p = " << p3 << "\n"
diff --git a/example/unmanned_aerial_vehicle.cpp b/example/unmanned_aerial_vehicle.cpp
index 064e8055..9cb32bfc 100644
--- a/example/unmanned_aerial_vehicle.cpp
+++ b/example/unmanned_aerial_vehicle.cpp
@@ -70,6 +70,7 @@ constexpr const char* to_text(earth_gravity_model m)
       return "EGM2008-1";
   }
   assert(false && "unsupported enum value");
+  return "unsupported enum value";
 }
 
 template<earth_gravity_model M>
diff --git a/src/core/include/mp-units/bits/hacks.h b/src/core/include/mp-units/bits/hacks.h
index 0099be3d..4aec2a8d 100644
--- a/src/core/include/mp-units/bits/hacks.h
+++ b/src/core/include/mp-units/bits/hacks.h
@@ -124,7 +124,7 @@ inline constexpr from_range_t from_range{};
 #else
 
 #define MP_UNITS_CONSTRAINED_NTTP_WORKAROUND(X) X
-#define MP_UNITS_EXPRESSION_WORKAROUND(x) x
+#define  MP_UNITS_EXPRESSION_WORKAROUND(x) x
 #define MP_UNITS_IS_VALUE_WORKAROUND(x) x
 #define MP_UNITS_IS_CONST_EXPR_WORKAROUND(x) x
 
diff --git a/src/core/include/mp-units/bits/type_list.h b/src/core/include/mp-units/bits/type_list.h
index 636c1df1..61708944 100644
--- a/src/core/include/mp-units/bits/type_list.h
+++ b/src/core/include/mp-units/bits/type_list.h
@@ -68,7 +68,7 @@ struct type_list_map_impl<From<Args...>, To> {
 };
 
 template<TypeList From, template<typename...> typename To>
-using type_list_map = type_list_map_impl<From, To>::type;
+using type_list_map =   type_list_map_impl<From, To>::type;
 
 
 // element
@@ -105,7 +105,7 @@ struct type_list_front_impl<List<T, Ts...>> {
 };
 
 template<TypeList List>
-using type_list_front = type_list_front_impl<List>::type;
+using type_list_front =   type_list_front_impl<List>::type;
 
 // back
 template<TypeList List>
@@ -121,7 +121,7 @@ struct type_list_push_front_impl<List<OldTypes...>, NewTypes...> {
 };
 
 template<TypeList List, typename... Types>
-using type_list_push_front = type_list_push_front_impl<List, Types...>::type;
+using type_list_push_front =   type_list_push_front_impl<List, Types...>::type;
 
 // push_back
 template<typename List, typename... Types>
@@ -133,7 +133,7 @@ struct type_list_push_back_impl<List<OldTypes...>, NewTypes...> {
 };
 
 template<TypeList List, typename... Types>
-using type_list_push_back = type_list_push_back_impl<List, Types...>::type;
+using type_list_push_back =   type_list_push_back_impl<List, Types...>::type;
 
 // join
 template<typename List, typename... Rest>
@@ -143,11 +143,11 @@ struct type_list_join_impl {
 
 template<template<typename...> typename List, typename... First, typename... Second, typename... Rest>
 struct type_list_join_impl<List<First...>, List<Second...>, Rest...> {
-  using type = type_list_join_impl<List<First..., Second...>, Rest...>::type;
+  using type =   type_list_join_impl<List<First..., Second...>, Rest...>::type;
 };
 
 template<TypeList... Lists>
-using type_list_join = type_list_join_impl<Lists...>::type;
+using type_list_join =   type_list_join_impl<Lists...>::type;
 
 // split
 template<typename List, typename First, typename Second>
@@ -195,19 +195,19 @@ template<template<typename...> typename List, typename Lhs1, typename... LhsRest
          template<typename, typename> typename Pred>
   requires Pred<Lhs1, Rhs1>::value
 struct type_list_merge_sorted_impl<List<Lhs1, LhsRest...>, List<Rhs1, RhsRest...>, Pred> {
-  using type = type_list_push_front_impl<
+  using type =   type_list_push_front_impl<
     typename type_list_merge_sorted_impl<List<LhsRest...>, List<Rhs1, RhsRest...>, Pred>::type, Lhs1>::type;
 };
 
 template<template<typename...> typename List, typename Lhs1, typename... LhsRest, typename Rhs1, typename... RhsRest,
          template<typename, typename> typename Pred>
 struct type_list_merge_sorted_impl<List<Lhs1, LhsRest...>, List<Rhs1, RhsRest...>, Pred> {
-  using type = type_list_push_front_impl<
+  using type =   type_list_push_front_impl<
     typename type_list_merge_sorted_impl<List<Lhs1, LhsRest...>, List<RhsRest...>, Pred>::type, Rhs1>::type;
 };
 
 template<TypeList SortedList1, TypeList SortedList2, template<typename, typename> typename Pred>
-using type_list_merge_sorted = type_list_merge_sorted_impl<SortedList1, SortedList2, Pred>::type;
+using type_list_merge_sorted =   type_list_merge_sorted_impl<SortedList1, SortedList2, Pred>::type;
 
 // sort
 template<typename List, template<typename, typename> typename Pred>
@@ -227,13 +227,13 @@ template<template<typename...> typename List, typename... Types, template<typena
 struct type_list_sort_impl<List<Types...>, Pred> {
   using types = List<Types...>;
   using split = type_list_split_half<List<Types...>>;
-  using sorted_left = type_list_sort_impl<typename split::first_list, Pred>::type;
-  using sorted_right = type_list_sort_impl<typename split::second_list, Pred>::type;
-  using type = type_list_merge_sorted_impl<sorted_left, sorted_right, Pred>::type;
+  using sorted_left =   type_list_sort_impl<typename split::first_list, Pred>::type;
+  using sorted_right =   type_list_sort_impl<typename split::second_list, Pred>::type;
+  using type =   type_list_merge_sorted_impl<sorted_left, sorted_right, Pred>::type;
 };
 
 template<TypeList List, template<typename, typename> typename Pred>
-using type_list_sort = type_list_sort_impl<List, Pred>::type;
+using type_list_sort =   type_list_sort_impl<List, Pred>::type;
 
 }  // namespace mp_units::detail
 
diff --git a/src/core/include/mp-units/ext/type_traits.h b/src/core/include/mp-units/ext/type_traits.h
index 2ee78e2a..77f0267b 100644
--- a/src/core/include/mp-units/ext/type_traits.h
+++ b/src/core/include/mp-units/ext/type_traits.h
@@ -56,7 +56,7 @@ struct conditional_impl<true> {
 MP_UNITS_EXPORT_BEGIN
 
 template<bool B, typename T, typename F>
-using conditional = detail::conditional_impl<B>::template type<T, F>;
+using conditional =   detail::conditional_impl<B>::template type<T, F>;
 
 // is_same
 template<class T, class U>
@@ -98,7 +98,7 @@ namespace detail {
 
 template<typename T>
 struct get_value_type {
-  using type = T::value_type;
+  using type =   T::value_type;
 };
 
 template<typename T>
@@ -111,13 +111,13 @@ struct get_element_type {
 template<typename T>
   requires requires { typename T::value_type; } || requires { typename T::element_type; }
 struct wrapped_type {
-  using type =
+  using type =  
     conditional<requires { typename T::value_type; }, detail::get_value_type<T>, detail::get_element_type<T>>::type;
 };
 
 template<typename T>
   requires requires { typename T::value_type; } || requires { typename T::element_type; }
-using wrapped_type_t = wrapped_type<T>::type;
+using wrapped_type_t =   wrapped_type<T>::type;
 
 template<typename T>
 struct value_type {
@@ -127,11 +127,11 @@ struct value_type {
 template<typename T>
   requires requires { typename wrapped_type_t<T>; }
 struct value_type<T> {
-  using type = wrapped_type_t<T>;
+  using type =   wrapped_type_t<T>;
 };
 
 template<typename T>
-using value_type_t = value_type<T>::type;
+using value_type_t =   value_type<T>::type;
 
 template<typename T, typename... Ts>
 concept one_of = (false || ... || std::same_as<T, Ts>);
diff --git a/src/core/include/mp-units/framework/expression_template.h b/src/core/include/mp-units/framework/expression_template.h
index 45d3d4b6..6b5836ff 100644
--- a/src/core/include/mp-units/framework/expression_template.h
+++ b/src/core/include/mp-units/framework/expression_template.h
@@ -122,7 +122,7 @@ struct expr_type_impl<power<T, Ints...>> : std::type_identity<T> {};
 }  // namespace detail
 
 template<typename T>
-using expr_type = detail::expr_type_impl<T>::type;
+using expr_type =   detail::expr_type_impl<T>::type;
 
 namespace detail {
 
@@ -182,24 +182,25 @@ struct expr_consolidate_impl<type_list<T, Rest...>> {
 template<typename T, typename... Rest>
   requires(!is_specialization_of_power<T>)
 struct expr_consolidate_impl<type_list<T, T, Rest...>> {
-  using type = expr_consolidate_impl<type_list<power<T, 2>, Rest...>>::type;
+  using type =   expr_consolidate_impl<type_list<power<T, 2>, Rest...>>::type;
 };
 
 // replaces the instance of a type and a power of it with one with incremented power
 template<typename T, int... Ints, typename... Rest>
 struct expr_consolidate_impl<type_list<T, power<T, Ints...>, Rest...>> {
-  using type = expr_consolidate_impl<type_list<power_or_T<T, power<T, Ints...>::exponent + 1>, Rest...>>::type;
+  using type =
+      expr_consolidate_impl<type_list<power_or_T<T, power<T, Ints...>::exponent + 1>, Rest...>>::type;
 };
 
 // accumulates the powers of instances of the same type (removes the element in case the accumulation result is `0`)
 template<typename T, int... Ints1, int... Ints2, typename... Rest>
 struct expr_consolidate_impl<type_list<power<T, Ints1...>, power<T, Ints2...>, Rest...>> {
   static constexpr ratio r = power<T, Ints1...>::exponent + power<T, Ints2...>::exponent;
-  using type = expr_consolidate_impl<type_list<power_or_T<T, r>, Rest...>>::type;
+  using type =   expr_consolidate_impl<type_list<power_or_T<T, r>, Rest...>>::type;
 };
 
 template<typename List>
-using expr_consolidate = expr_consolidate_impl<List>::type;
+using expr_consolidate =   expr_consolidate_impl<List>::type;
 
 
 /**
diff --git a/src/core/include/mp-units/framework/quantity_spec.h b/src/core/include/mp-units/framework/quantity_spec.h
index 89a35c8f..934aa9b5 100644
--- a/src/core/include/mp-units/framework/quantity_spec.h
+++ b/src/core/include/mp-units/framework/quantity_spec.h
@@ -1343,22 +1343,19 @@ template<QuantitySpec From, QuantitySpec To>
   };
   if constexpr ((NamedQuantitySpec<decltype(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from_kind))> &&
                  NamedQuantitySpec<decltype(MP_UNITS_IS_CONST_EXPR_WORKAROUND(to_kind))>) ||
-                get_complexity(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from_kind)) ==
-                  get_complexity(MP_UNITS_IS_CONST_EXPR_WORKAROUND(to_kind)))
+                get_complexity(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from_kind)) == get_complexity(MP_UNITS_IS_CONST_EXPR_WORKAROUND(to_kind)))
     return convertible_impl(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from_kind), MP_UNITS_IS_CONST_EXPR_WORKAROUND(to_kind));
   else if constexpr (get_complexity(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from_kind)) >
                      get_complexity(MP_UNITS_IS_CONST_EXPR_WORKAROUND(to_kind)))
-    return exploded_kind_result(
-      convertible_impl(get_kind_tree_root(explode<get_complexity(MP_UNITS_IS_CONST_EXPR_WORKAROUND(to_kind))>(
-                                            MP_UNITS_IS_CONST_EXPR_WORKAROUND(from_kind))
-                                            .quantity),
-                       MP_UNITS_IS_CONST_EXPR_WORKAROUND(to_kind)));
+    return exploded_kind_result(convertible_impl(
+      get_kind_tree_root(
+        explode<get_complexity(MP_UNITS_IS_CONST_EXPR_WORKAROUND(to_kind))>(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from_kind)).quantity),
+      MP_UNITS_IS_CONST_EXPR_WORKAROUND(to_kind)));
   else
-    return exploded_kind_result(
-      convertible_impl(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from_kind),
-                       get_kind_tree_root(explode<get_complexity(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from_kind))>(
-                                            MP_UNITS_IS_CONST_EXPR_WORKAROUND(to_kind))
-                                            .quantity)));
+    return exploded_kind_result(convertible_impl(
+      MP_UNITS_IS_CONST_EXPR_WORKAROUND(from_kind),
+      get_kind_tree_root(
+        explode<get_complexity(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from_kind))>(MP_UNITS_IS_CONST_EXPR_WORKAROUND(to_kind)).quantity)));
 }
 
 template<NamedQuantitySpec From, NamedQuantitySpec To>
@@ -1376,12 +1373,10 @@ template<NamedQuantitySpec From, NamedQuantitySpec To>
   else if constexpr (get_complexity(From{}) != get_complexity(To{})) {
     if constexpr (get_complexity(From{}) > get_complexity(To{}))
       return convertible_impl(
-        explode<get_complexity(MP_UNITS_IS_CONST_EXPR_WORKAROUND(to))>(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from))
-          .quantity,
+        explode<get_complexity(MP_UNITS_IS_CONST_EXPR_WORKAROUND(to))>(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from)).quantity,
         MP_UNITS_IS_CONST_EXPR_WORKAROUND(to));
     else {
-      auto res =
-        explode<get_complexity(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from))>(MP_UNITS_IS_CONST_EXPR_WORKAROUND(to));
+      auto res = explode<get_complexity(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from))>(MP_UNITS_IS_CONST_EXPR_WORKAROUND(to));
       return min(res.result, convertible_impl(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from), res.quantity));
     }
   }
@@ -1414,8 +1409,7 @@ template<QuantitySpec From, QuantitySpec To>
       auto eq = explode_to_equation(MP_UNITS_IS_CONST_EXPR_WORKAROUND(to));
       return min(eq.result, convertible_impl(res.quantity, eq.equation));
     } else
-      return are_ingredients_convertible(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from),
-                                         MP_UNITS_IS_CONST_EXPR_WORKAROUND(to));
+      return are_ingredients_convertible(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from), MP_UNITS_IS_CONST_EXPR_WORKAROUND(to));
   } else if constexpr (DerivedQuantitySpec<To>) {
     auto res = explode<get_complexity(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from))>(MP_UNITS_IS_CONST_EXPR_WORKAROUND(to));
     if constexpr (NamedQuantitySpec<decltype(res.quantity)>)
@@ -1423,8 +1417,7 @@ template<QuantitySpec From, QuantitySpec To>
     else if constexpr (requires { MP_UNITS_IS_CONST_EXPR_WORKAROUND(from)._equation_; })
       return min(res.result, convertible_impl(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from)._equation_, res.quantity));
     else
-      return min(res.result, are_ingredients_convertible(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from),
-                                                         MP_UNITS_IS_CONST_EXPR_WORKAROUND(to)));
+      return min(res.result, are_ingredients_convertible(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from), MP_UNITS_IS_CONST_EXPR_WORKAROUND(to)));
   }
   // NOLINTEND(bugprone-branch-clone)
   return no;
diff --git a/src/core/include/mp-units/framework/reference.h b/src/core/include/mp-units/framework/reference.h
index 7dba6475..5a5f8262 100644
--- a/src/core/include/mp-units/framework/reference.h
+++ b/src/core/include/mp-units/framework/reference.h
@@ -87,48 +87,46 @@ struct reference {
   }
 
   template<typename Q2, typename U2>
-  [[nodiscard]] friend consteval detail::reference_t<MP_UNITS_EXPRESSION_WORKAROUND(Q{} * Q2{}),
-                                                     MP_UNITS_EXPRESSION_WORKAROUND(U{} * U2{})>
+  [[nodiscard]] friend consteval detail::reference_t< MP_UNITS_EXPRESSION_WORKAROUND(Q{} * Q2{}),  MP_UNITS_EXPRESSION_WORKAROUND(U{} * U2{})>
   operator*(reference, reference<Q2, U2>)
   {
     return {};
   }
 
   template<AssociatedUnit U2>
-  [[nodiscard]] friend consteval detail::reference_t<(MP_UNITS_EXPRESSION_WORKAROUND(Q{} * get_quantity_spec(U2{}))),
-                                                     MP_UNITS_EXPRESSION_WORKAROUND(U{} * U2{})>
+  [[nodiscard]] friend consteval detail::reference_t<( MP_UNITS_EXPRESSION_WORKAROUND(Q{} * get_quantity_spec(U2{}))),
+                                                      MP_UNITS_EXPRESSION_WORKAROUND(U{} * U2{})>
   operator*(reference, U2)
   {
     return {};
   }
 
   template<AssociatedUnit U1>
-  [[nodiscard]] friend consteval detail::reference_t<MP_UNITS_EXPRESSION_WORKAROUND(get_quantity_spec(U1{}) * Q{}),
-                                                     MP_UNITS_EXPRESSION_WORKAROUND(U1{} * U{})>
+  [[nodiscard]] friend consteval detail::reference_t< MP_UNITS_EXPRESSION_WORKAROUND(get_quantity_spec(U1{}) * Q{}),
+                                                      MP_UNITS_EXPRESSION_WORKAROUND(U1{} * U{})>
   operator*(U1, reference)
   {
     return {};
   }
 
   template<typename Q2, typename U2>
-  [[nodiscard]] friend consteval detail::reference_t<MP_UNITS_EXPRESSION_WORKAROUND(Q{} / Q2{}),
-                                                     MP_UNITS_EXPRESSION_WORKAROUND(U{} / U2{})>
+  [[nodiscard]] friend consteval detail::reference_t< MP_UNITS_EXPRESSION_WORKAROUND(Q{} / Q2{}),  MP_UNITS_EXPRESSION_WORKAROUND(U{} / U2{})>
   operator/(reference, reference<Q2, U2>)
   {
     return {};
   }
 
   template<AssociatedUnit U2>
-  [[nodiscard]] friend consteval detail::reference_t<MP_UNITS_EXPRESSION_WORKAROUND(Q{} / get_quantity_spec(U2{})),
-                                                     MP_UNITS_EXPRESSION_WORKAROUND(U{} / U2{})>
+  [[nodiscard]] friend consteval detail::reference_t< MP_UNITS_EXPRESSION_WORKAROUND(Q{} / get_quantity_spec(U2{})),
+                                                      MP_UNITS_EXPRESSION_WORKAROUND(U{} / U2{})>
   operator/(reference, U2)
   {
     return {};
   }
 
   template<AssociatedUnit U1>
-  [[nodiscard]] friend consteval detail::reference_t<MP_UNITS_EXPRESSION_WORKAROUND(get_quantity_spec(U1{}) / Q{}),
-                                                     MP_UNITS_EXPRESSION_WORKAROUND(U1{} / U{})>
+  [[nodiscard]] friend consteval detail::reference_t< MP_UNITS_EXPRESSION_WORKAROUND(get_quantity_spec(U1{}) / Q{}),
+                                                      MP_UNITS_EXPRESSION_WORKAROUND(U1{} / U{})>
   operator/(U1, reference)
   {
     return {};
@@ -293,11 +291,10 @@ template<Reference R1, Reference R2, Reference... Rest>
     } -> Unit;
   }
 {
-  return detail::reference_t<common_quantity_spec(get_quantity_spec(MP_UNITS_IS_CONST_EXPR_WORKAROUND(r1)),
-                                                  get_quantity_spec(MP_UNITS_IS_CONST_EXPR_WORKAROUND(r2)),
-                                                  get_quantity_spec(rest)...),
-                             common_unit(get_unit(MP_UNITS_IS_CONST_EXPR_WORKAROUND(r1)),
-                                         get_unit(MP_UNITS_IS_CONST_EXPR_WORKAROUND(r2)), get_unit(rest)...)>{};
+  return detail::reference_t<
+    common_quantity_spec(get_quantity_spec(MP_UNITS_IS_CONST_EXPR_WORKAROUND(r1)), get_quantity_spec(MP_UNITS_IS_CONST_EXPR_WORKAROUND(r2)),
+                         get_quantity_spec(rest)...),
+    common_unit(get_unit(MP_UNITS_IS_CONST_EXPR_WORKAROUND(r1)), get_unit(MP_UNITS_IS_CONST_EXPR_WORKAROUND(r2)), get_unit(rest)...)>{};
 }
 
 MP_UNITS_EXPORT_END
diff --git a/src/core/include/mp-units/random.h b/src/core/include/mp-units/random.h
index 5da89966..05251f3f 100644
--- a/src/core/include/mp-units/random.h
+++ b/src/core/include/mp-units/random.h
@@ -61,7 +61,7 @@ std::vector<typename Q::rep> bl_qty_to_rep(std::initializer_list<Q>& bl)
 template<Quantity Q, typename UnaryOperation>
 std::vector<typename Q::rep> fw_bl_pwc(std::initializer_list<Q>& bl, UnaryOperation fw)
 {
-  using rep = Q::rep;
+  using rep =   Q::rep;
   std::vector<rep> w_bl;
   w_bl.reserve(bl.size());
   for (const Q& qty : bl) {
@@ -93,8 +93,8 @@ MP_UNITS_EXPORT_BEGIN
 template<Quantity Q>
   requires std::integral<typename Q::rep>
 struct uniform_int_distribution : public std::uniform_int_distribution<typename Q::rep> {
-  using rep = Q::rep;
-  using base = std::uniform_int_distribution<rep>;
+  using rep =   Q::rep;
+  using base =   std::uniform_int_distribution<rep>;
 
   uniform_int_distribution() : base() {}
   uniform_int_distribution(const Q& a, const Q& b) :
@@ -118,8 +118,8 @@ struct uniform_int_distribution : public std::uniform_int_distribution<typename
 template<Quantity Q>
   requires std::floating_point<typename Q::rep>
 struct uniform_real_distribution : public std::uniform_real_distribution<typename Q::rep> {
-  using rep = Q::rep;
-  using base = std::uniform_real_distribution<rep>;
+  using rep =   Q::rep;
+  using base =   std::uniform_real_distribution<rep>;
 
   uniform_real_distribution() : base() {}
   uniform_real_distribution(const Q& a, const Q& b) :
@@ -143,8 +143,8 @@ struct uniform_real_distribution : public std::uniform_real_distribution<typenam
 template<Quantity Q>
   requires std::integral<typename Q::rep>
 struct binomial_distribution : public std::binomial_distribution<typename Q::rep> {
-  using rep = Q::rep;
-  using base = std::binomial_distribution<rep>;
+  using rep =   Q::rep;
+  using base =   std::binomial_distribution<rep>;
 
   binomial_distribution() : base() {}
   binomial_distribution(const Q& t, double p) : base(t.numerical_value_ref_in(Q::unit), p) {}
@@ -164,8 +164,8 @@ struct binomial_distribution : public std::binomial_distribution<typename Q::rep
 template<Quantity Q>
   requires std::integral<typename Q::rep>
 struct negative_binomial_distribution : public std::negative_binomial_distribution<typename Q::rep> {
-  using rep = Q::rep;
-  using base = std::negative_binomial_distribution<rep>;
+  using rep =   Q::rep;
+  using base =   std::negative_binomial_distribution<rep>;
 
   negative_binomial_distribution() : base() {}
   negative_binomial_distribution(const Q& k, double p) : base(k.numerical_value_ref_in(Q::unit), p) {}
@@ -185,8 +185,8 @@ struct negative_binomial_distribution : public std::negative_binomial_distributi
 template<Quantity Q>
   requires std::integral<typename Q::rep>
 struct geometric_distribution : public std::geometric_distribution<typename Q::rep> {
-  using rep = Q::rep;
-  using base = std::geometric_distribution<rep>;
+  using rep =   Q::rep;
+  using base =   std::geometric_distribution<rep>;
 
   geometric_distribution() : base() {}
   explicit geometric_distribution(double p) : base(p) {}
@@ -204,8 +204,8 @@ struct geometric_distribution : public std::geometric_distribution<typename Q::r
 template<Quantity Q>
   requires std::integral<typename Q::rep>
 struct poisson_distribution : public std::poisson_distribution<typename Q::rep> {
-  using rep = Q::rep;
-  using base = std::poisson_distribution<rep>;
+  using rep =   Q::rep;
+  using base =   std::poisson_distribution<rep>;
 
   poisson_distribution() : base() {}
   explicit poisson_distribution(double p) : base(p) {}
@@ -223,8 +223,8 @@ struct poisson_distribution : public std::poisson_distribution<typename Q::rep>
 template<Quantity Q>
   requires std::floating_point<typename Q::rep>
 struct exponential_distribution : public std::exponential_distribution<typename Q::rep> {
-  using rep = Q::rep;
-  using base = std::exponential_distribution<rep>;
+  using rep =   Q::rep;
+  using base =   std::exponential_distribution<rep>;
 
   exponential_distribution() : base() {}
   explicit exponential_distribution(const rep& lambda) : base(lambda) {}
@@ -242,8 +242,8 @@ struct exponential_distribution : public std::exponential_distribution<typename
 template<Quantity Q>
   requires std::floating_point<typename Q::rep>
 struct gamma_distribution : public std::gamma_distribution<typename Q::rep> {
-  using rep = Q::rep;
-  using base = std::gamma_distribution<rep>;
+  using rep =   Q::rep;
+  using base =   std::gamma_distribution<rep>;
 
   gamma_distribution() : base() {}
   gamma_distribution(const rep& alpha, const rep& beta) : base(alpha, beta) {}
@@ -261,8 +261,8 @@ struct gamma_distribution : public std::gamma_distribution<typename Q::rep> {
 template<Quantity Q>
   requires std::floating_point<typename Q::rep>
 struct weibull_distribution : public std::weibull_distribution<typename Q::rep> {
-  using rep = Q::rep;
-  using base = std::weibull_distribution<rep>;
+  using rep =   Q::rep;
+  using base =   std::weibull_distribution<rep>;
 
   weibull_distribution() : base() {}
   weibull_distribution(const rep& a, const rep& b) : base(a, b) {}
@@ -280,8 +280,8 @@ struct weibull_distribution : public std::weibull_distribution<typename Q::rep>
 template<Quantity Q>
   requires std::floating_point<typename Q::rep>
 struct extreme_value_distribution : public std::extreme_value_distribution<typename Q::rep> {
-  using rep = Q::rep;
-  using base = std::extreme_value_distribution<rep>;
+  using rep =   Q::rep;
+  using base =   std::extreme_value_distribution<rep>;
 
   extreme_value_distribution() : base() {}
   extreme_value_distribution(const Q& a, const rep& b) : base(a.numerical_value_ref_in(Q::unit), b) {}
@@ -301,8 +301,8 @@ struct extreme_value_distribution : public std::extreme_value_distribution<typen
 template<Quantity Q>
   requires std::floating_point<typename Q::rep>
 struct normal_distribution : public std::normal_distribution<typename Q::rep> {
-  using rep = Q::rep;
-  using base = std::normal_distribution<rep>;
+  using rep =   Q::rep;
+  using base =   std::normal_distribution<rep>;
 
   normal_distribution() : base() {}
   normal_distribution(const Q& mean, const Q& stddev) :
@@ -326,8 +326,8 @@ struct normal_distribution : public std::normal_distribution<typename Q::rep> {
 template<Quantity Q>
   requires std::floating_point<typename Q::rep>
 struct lognormal_distribution : public std::lognormal_distribution<typename Q::rep> {
-  using rep = Q::rep;
-  using base = std::lognormal_distribution<rep>;
+  using rep =   Q::rep;
+  using base =   std::lognormal_distribution<rep>;
 
   lognormal_distribution() : base() {}
   lognormal_distribution(const Q& m, const Q& s) :
@@ -351,8 +351,8 @@ struct lognormal_distribution : public std::lognormal_distribution<typename Q::r
 template<Quantity Q>
   requires std::floating_point<typename Q::rep>
 struct chi_squared_distribution : public std::chi_squared_distribution<typename Q::rep> {
-  using rep = Q::rep;
-  using base = std::chi_squared_distribution<rep>;
+  using rep =   Q::rep;
+  using base =   std::chi_squared_distribution<rep>;
 
   chi_squared_distribution() : base() {}
   explicit chi_squared_distribution(const rep& n) : base(n) {}
@@ -370,8 +370,8 @@ struct chi_squared_distribution : public std::chi_squared_distribution<typename
 template<Quantity Q>
   requires std::floating_point<typename Q::rep>
 struct cauchy_distribution : public std::cauchy_distribution<typename Q::rep> {
-  using rep = Q::rep;
-  using base = std::cauchy_distribution<rep>;
+  using rep =   Q::rep;
+  using base =   std::cauchy_distribution<rep>;
 
   cauchy_distribution() : base() {}
   cauchy_distribution(const Q& a, const Q& b) :
@@ -395,8 +395,8 @@ struct cauchy_distribution : public std::cauchy_distribution<typename Q::rep> {
 template<Quantity Q>
   requires std::floating_point<typename Q::rep>
 struct fisher_f_distribution : public std::fisher_f_distribution<typename Q::rep> {
-  using rep = Q::rep;
-  using base = std::fisher_f_distribution<rep>;
+  using rep =   Q::rep;
+  using base =   std::fisher_f_distribution<rep>;
 
   fisher_f_distribution() : base() {}
   fisher_f_distribution(const rep& m, const rep& n) : base(m, n) {}
@@ -414,8 +414,8 @@ struct fisher_f_distribution : public std::fisher_f_distribution<typename Q::rep
 template<Quantity Q>
   requires std::floating_point<typename Q::rep>
 struct student_t_distribution : public std::student_t_distribution<typename Q::rep> {
-  using rep = Q::rep;
-  using base = std::student_t_distribution<rep>;
+  using rep =   Q::rep;
+  using base =   std::student_t_distribution<rep>;
 
   student_t_distribution() : base() {}
   explicit student_t_distribution(const rep& n) : base(n) {}
@@ -433,8 +433,8 @@ struct student_t_distribution : public std::student_t_distribution<typename Q::r
 template<Quantity Q>
   requires std::integral<typename Q::rep>
 struct discrete_distribution : public std::discrete_distribution<typename Q::rep> {
-  using rep = Q::rep;
-  using base = std::discrete_distribution<rep>;
+  using rep =   Q::rep;
+  using base =   std::discrete_distribution<rep>;
 
   discrete_distribution() : base() {}
 
@@ -464,8 +464,8 @@ struct discrete_distribution : public std::discrete_distribution<typename Q::rep
 template<Quantity Q>
   requires std::floating_point<typename Q::rep>
 class piecewise_constant_distribution : public std::piecewise_constant_distribution<typename Q::rep> {
-  using rep = Q::rep;
-  using base = std::piecewise_constant_distribution<rep>;
+  using rep =   Q::rep;
+  using base =   std::piecewise_constant_distribution<rep>;
 
   template<typename InputIt>
   piecewise_constant_distribution(const std::vector<rep>& i, InputIt first_w) : base(i.cbegin(), i.cend(), first_w)
@@ -523,8 +523,8 @@ public:
 template<Quantity Q>
   requires std::floating_point<typename Q::rep>
 class piecewise_linear_distribution : public std::piecewise_linear_distribution<typename Q::rep> {
-  using rep = Q::rep;
-  using base = std::piecewise_linear_distribution<rep>;
+  using rep =   Q::rep;
+  using base =   std::piecewise_linear_distribution<rep>;
 
   template<typename InputIt>
   piecewise_linear_distribution(const std::vector<rep>& i, InputIt first_w) : base(i.cbegin(), i.cend(), first_w)
diff --git a/src/systems/include/mp-units/systems/si/chrono.h b/src/systems/include/mp-units/systems/si/chrono.h
index 0ded9689..c3fb9707 100644
--- a/src/systems/include/mp-units/systems/si/chrono.h
+++ b/src/systems/include/mp-units/systems/si/chrono.h
@@ -137,8 +137,8 @@ template<QuantityPointOf<MP_UNITS_IS_VALUE_WORKAROUND(isq::time)> QP>
   requires is_specialization_of<std::remove_const_t<decltype(QP::absolute_point_origin)>, chrono_point_origin_>
 [[nodiscard]] constexpr auto to_chrono_time_point(const QP& qp)
 {
-  using clock = decltype(QP::absolute_point_origin)::clock;
-  using rep = QP::rep;
+  using clock =   decltype(QP::absolute_point_origin)::clock;
+  using rep =   QP::rep;
   using ret_type =
     std::chrono::time_point<clock,
                             std::chrono::duration<rep, decltype(detail::as_ratio(get_canonical_unit(QP::unit).mag))>>;
diff --git a/src/systems/include/mp-units/systems/si/math.h b/src/systems/include/mp-units/systems/si/math.h
index 80568e37..c91d0df8 100644
--- a/src/systems/include/mp-units/systems/si/math.h
+++ b/src/systems/include/mp-units/systems/si/math.h
@@ -87,8 +87,7 @@ template<ReferenceOf<MP_UNITS_IS_VALUE_WORKAROUND(isq::angular_measure)> auto R,
 
 template<ReferenceOf<dimensionless> auto R, typename Rep>
   requires requires(Rep v) { asin(v); } || requires(Rep v) { std::asin(v); }
-[[nodiscard]] inline QuantityOf<MP_UNITS_IS_VALUE_WORKAROUND(isq::angular_measure)> auto asin(
-  const quantity<R, Rep>& q) noexcept
+[[nodiscard]] inline QuantityOf<MP_UNITS_IS_VALUE_WORKAROUND(isq::angular_measure)> auto asin(const quantity<R, Rep>& q) noexcept
 {
   using std::asin;
   if constexpr (!treat_as_floating_point<Rep>) {
@@ -102,8 +101,7 @@ template<ReferenceOf<dimensionless> auto R, typename Rep>
 
 template<ReferenceOf<dimensionless> auto R, typename Rep>
   requires requires(Rep v) { acos(v); } || requires(Rep v) { std::acos(v); }
-[[nodiscard]] inline QuantityOf<MP_UNITS_IS_VALUE_WORKAROUND(isq::angular_measure)> auto acos(
-  const quantity<R, Rep>& q) noexcept
+[[nodiscard]] inline QuantityOf<MP_UNITS_IS_VALUE_WORKAROUND(isq::angular_measure)> auto acos(const quantity<R, Rep>& q) noexcept
 {
   using std::acos;
   if constexpr (!treat_as_floating_point<Rep>) {
@@ -117,8 +115,7 @@ template<ReferenceOf<dimensionless> auto R, typename Rep>
 
 template<ReferenceOf<dimensionless> auto R, typename Rep>
   requires requires(Rep v) { atan(v); } || requires(Rep v) { std::atan(v); }
-[[nodiscard]] inline QuantityOf<MP_UNITS_IS_VALUE_WORKAROUND(isq::angular_measure)> auto atan(
-  const quantity<R, Rep>& q) noexcept
+[[nodiscard]] inline QuantityOf<MP_UNITS_IS_VALUE_WORKAROUND(isq::angular_measure)> auto atan(const quantity<R, Rep>& q) noexcept
 {
   using std::atan;
   if constexpr (!treat_as_floating_point<Rep>) {
diff --git a/test/runtime/CMakeLists.txt b/test/runtime/CMakeLists.txt
index d79ed54b..70e13650 100644
--- a/test/runtime/CMakeLists.txt
+++ b/test/runtime/CMakeLists.txt
@@ -37,11 +37,11 @@ if(${projectPrefix}BUILD_CXX_MODULES)
 endif()
 target_link_libraries(unit_tests_runtime PRIVATE mp-units::mp-units Catch2::Catch2WithMain)
 
-if(${projectPrefix}DEV_BUILD_LA)
-    find_package(wg21_linear_algebra REQUIRED)
-    target_sources(unit_tests_runtime PRIVATE linear_algebra_test.cpp)
-    target_link_libraries(unit_tests_runtime PRIVATE wg21_linear_algebra::wg21_linear_algebra)
-endif()
+# if(${projectPrefix}DEV_BUILD_LA)
+#     find_package(wg21_linear_algebra REQUIRED)
+#     target_sources(unit_tests_runtime PRIVATE linear_algebra_test.cpp)
+#     target_link_libraries(unit_tests_runtime PRIVATE wg21_linear_algebra::wg21_linear_algebra)
+# endif()
 
 if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
     target_compile_options(
diff --git a/test/static/chrono_test.cpp b/test/static/chrono_test.cpp
index 9f3b1901..2785041f 100644
--- a/test/static/chrono_test.cpp
+++ b/test/static/chrono_test.cpp
@@ -57,41 +57,43 @@ static_assert(!QuantityPoint<sys_seconds>);
 
 // construction - same rep type
 static_assert(
-  std::constructible_from<quantity<isq::time[si::second], std::chrono::seconds::rep>, std::chrono::seconds>);
-static_assert(std::convertible_to<std::chrono::seconds, quantity<isq::time[si::second], std::chrono::seconds::rep>>);
-static_assert(std::constructible_from<quantity<isq::time[si::hour], std::chrono::hours::rep>, std::chrono::hours>);
-static_assert(std::convertible_to<std::chrono::hours, quantity<isq::time[si::hour], std::chrono::hours::rep>>);
-static_assert(std::constructible_from<quantity<isq::time[si::second], std::chrono::hours::rep>, std::chrono::hours>);
-static_assert(std::convertible_to<std::chrono::hours, quantity<isq::time[si::second], std::chrono::hours::rep>>);
-static_assert(!std::constructible_from<quantity<isq::time[si::hour], std::chrono::seconds::rep>, std::chrono::seconds>);
-static_assert(!std::convertible_to<std::chrono::seconds, quantity<isq::time[si::hour], std::chrono::seconds::rep>>);
+  std::constructible_from<quantity<(isq::time[si::second]), std::chrono::seconds::rep>, std::chrono::seconds>);
+static_assert(std::convertible_to<std::chrono::seconds, quantity<(isq::time[si::second]), std::chrono::seconds::rep>>);
+static_assert(std::constructible_from<quantity<(isq::time[si::hour]), std::chrono::hours::rep>, std::chrono::hours>);
+static_assert(std::convertible_to<std::chrono::hours, quantity<(isq::time[si::hour]), std::chrono::hours::rep>>);
+static_assert(std::constructible_from<quantity<(isq::time[si::second]), std::chrono::hours::rep>, std::chrono::hours>);
+static_assert(std::convertible_to<std::chrono::hours, quantity<(isq::time[si::second]), std::chrono::hours::rep>>);
 static_assert(
-  std::constructible_from<time_point<si::second, std::chrono::system_clock, sys_seconds::rep>, sys_seconds>);
+  !std::constructible_from<quantity<(isq::time[si::hour]), std::chrono::seconds::rep>, std::chrono::seconds>);
+static_assert(!std::convertible_to<std::chrono::seconds, quantity<(isq::time[si::hour]), std::chrono::seconds::rep>>);
 static_assert(
-  !std::constructible_from<time_point<si::second, std::chrono::steady_clock, sys_seconds::rep>, sys_seconds>);
-static_assert(std::convertible_to<sys_seconds, time_point<si::second, std::chrono::system_clock, sys_seconds::rep>>);
-static_assert(std::constructible_from<time_point<si::day, std::chrono::system_clock, sys_days::rep>, sys_days>);
-static_assert(!std::constructible_from<time_point<si::day, std::chrono::steady_clock, sys_days::rep>, sys_days>);
-static_assert(std::convertible_to<sys_days, time_point<si::day, std::chrono::system_clock, sys_days::rep>>);
-static_assert(std::constructible_from<time_point<si::second, std::chrono::system_clock, sys_days::rep>, sys_days>);
-static_assert(!std::constructible_from<time_point<si::second, std::chrono::steady_clock, sys_days::rep>, sys_days>);
-static_assert(std::convertible_to<sys_days, time_point<si::second, std::chrono::system_clock, sys_days::rep>>);
-static_assert(!std::constructible_from<time_point<si::day, std::chrono::system_clock, sys_seconds::rep>, sys_seconds>);
-static_assert(!std::convertible_to<sys_seconds, time_point<si::day, std::chrono::system_clock, sys_seconds::rep>>);
+  std::constructible_from<time_point<(si::second), std::chrono::system_clock, sys_seconds::rep>, sys_seconds>);
+static_assert(
+  !std::constructible_from<time_point<(si::second), std::chrono::steady_clock, sys_seconds::rep>, sys_seconds>);
+static_assert(std::convertible_to<sys_seconds, time_point<(si::second), std::chrono::system_clock, sys_seconds::rep>>);
+static_assert(std::constructible_from<time_point<(si::day), std::chrono::system_clock, sys_days::rep>, sys_days>);
+static_assert(!std::constructible_from<time_point<(si::day), std::chrono::steady_clock, sys_days::rep>, sys_days>);
+static_assert(std::convertible_to<sys_days, time_point<(si::day), std::chrono::system_clock, sys_days::rep>>);
+static_assert(std::constructible_from<time_point<(si::second), std::chrono::system_clock, sys_days::rep>, sys_days>);
+static_assert(!std::constructible_from<time_point<(si::second), std::chrono::steady_clock, sys_days::rep>, sys_days>);
+static_assert(std::convertible_to<sys_days, time_point<(si::second), std::chrono::system_clock, sys_days::rep>>);
+static_assert(
+  !std::constructible_from<time_point<(si::day), std::chrono::system_clock, sys_seconds::rep>, sys_seconds>);
+static_assert(!std::convertible_to<sys_seconds, time_point<(si::day), std::chrono::system_clock, sys_seconds::rep>>);
 
 // construction - different rep type (integral to a floating-point)
-static_assert(std::constructible_from<quantity<isq::time[si::second]>, std::chrono::seconds>);
-static_assert(std::convertible_to<std::chrono::seconds, quantity<isq::time[si::second]>>);
-static_assert(std::constructible_from<quantity<isq::time[si::second]>, std::chrono::hours>);
-static_assert(std::convertible_to<std::chrono::hours, quantity<isq::time[si::second]>>);
-static_assert(std::constructible_from<quantity<isq::time[si::hour]>, std::chrono::seconds>);
-static_assert(std::convertible_to<std::chrono::seconds, quantity<isq::time[si::hour]>>);
-static_assert(std::constructible_from<time_point<si::second, std::chrono::system_clock>, sys_seconds>);
-static_assert(std::convertible_to<sys_seconds, time_point<si::second, std::chrono::system_clock>>);
-static_assert(std::constructible_from<time_point<si::second, std::chrono::system_clock>, sys_days>);
-static_assert(std::convertible_to<sys_days, time_point<si::second, std::chrono::system_clock>>);
-static_assert(std::constructible_from<time_point<si::day, std::chrono::system_clock>, sys_seconds>);
-static_assert(std::convertible_to<sys_seconds, time_point<si::day, std::chrono::system_clock>>);
+static_assert(std::constructible_from<quantity<(isq::time[si::second])>, std::chrono::seconds>);
+static_assert(std::convertible_to<std::chrono::seconds, quantity<(isq::time[si::second])>>);
+static_assert(std::constructible_from<quantity<(isq::time[si::second])>, std::chrono::hours>);
+static_assert(std::convertible_to<std::chrono::hours, quantity<(isq::time[si::second])>>);
+static_assert(std::constructible_from<quantity<(isq::time[si::hour])>, std::chrono::seconds>);
+static_assert(std::convertible_to<std::chrono::seconds, quantity<(isq::time[si::hour])>>);
+static_assert(std::constructible_from<time_point<(si::second), std::chrono::system_clock>, sys_seconds>);
+static_assert(std::convertible_to<sys_seconds, time_point<(si::second), std::chrono::system_clock>>);
+static_assert(std::constructible_from<time_point<(si::second), std::chrono::system_clock>, sys_days>);
+static_assert(std::convertible_to<sys_days, time_point<(si::second), std::chrono::system_clock>>);
+static_assert(std::constructible_from<time_point<(si::day), std::chrono::system_clock>, sys_seconds>);
+static_assert(std::convertible_to<sys_seconds, time_point<(si::day), std::chrono::system_clock>>);
 
 static_assert(quantity<si::second>{1s} == 1 * s);
 static_assert(quantity<isq::time[si::second]>{1s} == 1 * s);
@@ -107,13 +109,13 @@ static_assert(is_of_type<quantity_point{sys_days{sys_days::duration{1}}},
 
 // conversion to chrono
 static_assert(
-  std::constructible_from<std::chrono::seconds, quantity<isq::time[si::second], std::chrono::seconds::rep>>);
-static_assert(std::convertible_to<quantity<isq::time[si::second], std::chrono::seconds::rep>, std::chrono::seconds>);
-static_assert(std::constructible_from<std::chrono::hours, quantity<isq::time[si::hour], std::chrono::hours::rep>>);
-static_assert(std::convertible_to<quantity<isq::time[si::hour], std::chrono::hours::rep>, std::chrono::hours>);
+  std::constructible_from<std::chrono::seconds, quantity<(isq::time[si::second]), std::chrono::seconds::rep>>);
+static_assert(std::convertible_to<quantity<(isq::time[si::second]), std::chrono::seconds::rep>, std::chrono::seconds>);
+static_assert(std::constructible_from<std::chrono::hours, quantity<(isq::time[si::hour]), std::chrono::hours::rep>>);
+static_assert(std::convertible_to<quantity<(isq::time[si::hour]), std::chrono::hours::rep>, std::chrono::hours>);
 static_assert(
-  std::constructible_from<sys_seconds, time_point<si::second, std::chrono::system_clock, sys_seconds::rep>>);
-static_assert(std::convertible_to<time_point<si::second, std::chrono::system_clock, sys_seconds::rep>, sys_seconds>);
+  std::constructible_from<sys_seconds, time_point<(si::second), std::chrono::system_clock, sys_seconds::rep>>);
+static_assert(std::convertible_to<time_point<(si::second), std::chrono::system_clock, sys_seconds::rep>, sys_seconds>);
 
 // units mapping
 static_assert(quantity{1ns} == 1 * ns);
diff --git a/test/static/concepts_test.cpp b/test/static/concepts_test.cpp
index c67ff710..9564ed22 100644
--- a/test/static/concepts_test.cpp
+++ b/test/static/concepts_test.cpp
@@ -83,7 +83,7 @@ inline constexpr auto speed = isq::length / isq::time;
 static_assert(QuantitySpec<struct isq::length>);
 static_assert(QuantitySpec<struct isq::radius>);
 static_assert(QuantitySpec<struct isq::speed>);
-static_assert(QuantitySpec<decltype(kind_of<isq::length>)>);
+static_assert(QuantitySpec<decltype(kind_of<(isq::length)>)>);
 static_assert(QuantitySpec<decltype(isq::length / isq::time)>);
 static_assert(QuantitySpec<decltype(pow<2>(isq::length))>);
 static_assert(QuantitySpec<struct dimensionless>);
@@ -95,7 +95,7 @@ static_assert(!QuantitySpec<int>);
 static_assert(detail::NamedQuantitySpec<struct isq::length>);
 static_assert(detail::NamedQuantitySpec<struct isq::radius>);
 static_assert(detail::NamedQuantitySpec<struct isq::speed>);
-static_assert(!detail::NamedQuantitySpec<std::remove_const_t<decltype(kind_of<isq::length>)>>);
+static_assert(!detail::NamedQuantitySpec<std::remove_const_t<decltype(kind_of<(isq::length)>)>>);
 static_assert(!detail::NamedQuantitySpec<decltype(isq::length / isq::time)>);
 static_assert(!detail::NamedQuantitySpec<decltype(pow<2>(isq::length))>);
 static_assert(detail::NamedQuantitySpec<struct dimensionless>);
@@ -106,7 +106,7 @@ static_assert(!detail::NamedQuantitySpec<int>);
 // DerivedQuantitySpec
 static_assert(!detail::DerivedQuantitySpec<struct isq::length>);
 static_assert(!detail::DerivedQuantitySpec<struct isq::radius>);
-static_assert(!detail::DerivedQuantitySpec<decltype(kind_of<isq::length>)>);
+static_assert(!detail::DerivedQuantitySpec<decltype(kind_of<(isq::length)>)>);
 static_assert(!detail::DerivedQuantitySpec<struct isq::speed>);
 static_assert(detail::DerivedQuantitySpec<decltype(isq::length / isq::time)>);
 static_assert(detail::DerivedQuantitySpec<decltype(pow<2>(isq::length))>);
@@ -118,7 +118,7 @@ static_assert(!detail::DerivedQuantitySpec<int>);
 // QuantityKindSpec
 static_assert(!detail::QuantityKindSpec<struct isq::length>);
 static_assert(!detail::QuantityKindSpec<struct isq::radius>);
-static_assert(detail::QuantityKindSpec<std::remove_const_t<decltype(kind_of<isq::length>)>>);
+static_assert(detail::QuantityKindSpec<std::remove_const_t<decltype(kind_of<(isq::length)>)>>);
 static_assert(!detail::QuantityKindSpec<struct isq::speed>);
 static_assert(!detail::QuantityKindSpec<decltype(isq::length / isq::time)>);
 static_assert(!detail::QuantityKindSpec<decltype(pow<2>(isq::length))>);
@@ -133,7 +133,7 @@ static_assert(!detail::QuantityKindSpec<int>);
 // Unit
 static_assert(Unit<struct si::metre>);
 static_assert(Unit<decltype(si::kilogram)>);
-static_assert(Unit<decltype(si::kilo<si::gram>)>);
+static_assert(Unit<decltype(si::kilo<(si::gram)>)>);
 static_assert(Unit<struct natural::electronvolt>);
 static_assert(Unit<decltype(si::metre / si::second)>);
 static_assert(Unit<decltype(inverse(si::second))>);
@@ -144,11 +144,11 @@ static_assert(Unit<struct si::standard_gravity>);
 static_assert(Unit<scaled_unit<mag<10>, struct si::second>>);
 static_assert(Unit<derived_unit<struct si::metre, per<struct si::second>>>);
 static_assert(Unit<struct one>);
-static_assert(!Unit<named_unit<"?", kind_of<isq::length>>>);
+static_assert(!Unit<named_unit<"?", kind_of<(isq::length)>>>);
 static_assert(!Unit<named_unit<"?">>);
 static_assert(!Unit<named_unit<"?", si::metre / si::second>>);
-static_assert(!Unit<named_unit<"?", si::metre, kind_of<isq::length>>>);
-static_assert(!Unit<prefixed_unit<"?", mag<10>, si::second>>);
+static_assert(!Unit<named_unit<"?", (si::metre), kind_of<(isq::length)>>>);
+static_assert(!Unit<prefixed_unit<"?", mag<10>, (si::second)>>);
 static_assert(!Unit<struct isq::dim_length>);
 static_assert(!Unit<int>);
 #if MP_UNITS_HOSTED
@@ -159,7 +159,7 @@ static_assert(!Unit<std::chrono::seconds>);
 static_assert(PrefixableUnit<struct si::metre>);
 static_assert(PrefixableUnit<struct natural::electronvolt>);
 static_assert(!PrefixableUnit<decltype(si::kilogram)>);
-static_assert(!PrefixableUnit<decltype(si::kilo<si::gram>)>);
+static_assert(!PrefixableUnit<decltype(si::kilo<(si::gram)>)>);
 static_assert(!PrefixableUnit<decltype(si::metre / si::second)>);
 static_assert(!PrefixableUnit<decltype(inverse(si::second))>);
 static_assert(!PrefixableUnit<decltype(mag<10> * si::second)>);
@@ -169,11 +169,11 @@ static_assert(PrefixableUnit<struct si::standard_gravity>);
 static_assert(!PrefixableUnit<scaled_unit<mag<10>, struct si::second>>);
 static_assert(!PrefixableUnit<derived_unit<struct si::metre, per<struct si::second>>>);
 static_assert(!PrefixableUnit<struct one>);
-static_assert(!PrefixableUnit<named_unit<"?", kind_of<isq::length>>>);
+static_assert(!PrefixableUnit<named_unit<"?", kind_of<(isq::length)>>>);
 static_assert(!PrefixableUnit<named_unit<"?">>);
 static_assert(!PrefixableUnit<named_unit<"?", si::metre / si::second>>);
-static_assert(!PrefixableUnit<named_unit<"?", si::metre, kind_of<isq::length>>>);
-static_assert(!PrefixableUnit<prefixed_unit<"?", mag<10>, si::second>>);
+static_assert(!PrefixableUnit<named_unit<"?", (si::metre), kind_of<(isq::length)>>>);
+static_assert(!PrefixableUnit<prefixed_unit<"?", mag<10>, (si::second)>>);
 static_assert(!PrefixableUnit<struct isq::dim_length>);
 static_assert(!PrefixableUnit<int>);
 #if MP_UNITS_HOSTED
@@ -184,7 +184,7 @@ static_assert(!PrefixableUnit<std::chrono::seconds>);
 static_assert(AssociatedUnit<struct si::metre>);
 static_assert(!AssociatedUnit<struct natural::electronvolt>);
 static_assert(AssociatedUnit<decltype(si::kilogram)>);
-static_assert(AssociatedUnit<decltype(si::kilo<si::gram>)>);
+static_assert(AssociatedUnit<decltype(si::kilo<(si::gram)>)>);
 static_assert(AssociatedUnit<decltype(si::metre / si::second)>);
 static_assert(AssociatedUnit<decltype(inverse(si::second))>);
 static_assert(AssociatedUnit<decltype(mag<10> * si::second)>);
@@ -194,11 +194,11 @@ static_assert(AssociatedUnit<struct si::standard_gravity>);
 static_assert(AssociatedUnit<scaled_unit<mag<10>, struct si::second>>);
 static_assert(AssociatedUnit<derived_unit<struct si::metre, per<struct si::second>>>);
 static_assert(AssociatedUnit<struct one>);
-static_assert(!AssociatedUnit<named_unit<"?", kind_of<isq::length>>>);
+static_assert(!AssociatedUnit<named_unit<"?", kind_of<(isq::length)>>>);
 static_assert(!AssociatedUnit<named_unit<"?">>);
 static_assert(!AssociatedUnit<named_unit<"?", si::metre / si::second>>);
-static_assert(!AssociatedUnit<named_unit<"?", si::metre, kind_of<isq::length>>>);
-static_assert(!AssociatedUnit<prefixed_unit<"?", mag<10>, si::second>>);
+static_assert(!AssociatedUnit<named_unit<"?", (si::metre), kind_of<(isq::length)>>>);
+static_assert(!AssociatedUnit<prefixed_unit<"?", mag<10>, (si::second)>>);
 static_assert(!AssociatedUnit<struct isq::dim_length>);
 static_assert(!AssociatedUnit<int>);
 #if MP_UNITS_HOSTED
@@ -206,19 +206,19 @@ static_assert(!AssociatedUnit<std::chrono::seconds>);
 #endif
 
 // UnitOf
-static_assert(UnitOf<struct si::metre, isq::length>);
-static_assert(UnitOf<struct si::metre, isq::radius>);
-static_assert(UnitOf<decltype(si::kilogram), isq::mass>);
-static_assert(UnitOf<struct si::hertz, isq::frequency>);
+static_assert(UnitOf<struct si::metre, (isq::length)>);
+static_assert(UnitOf<struct si::metre, (isq::radius)>);
+static_assert(UnitOf<decltype(si::kilogram), (isq::mass)>);
+static_assert(UnitOf<struct si::hertz, (isq::frequency)>);
 static_assert(UnitOf<struct si::hertz, inverse(isq::time)>);
 static_assert(UnitOf<struct one, dimensionless>);
 static_assert(UnitOf<struct percent, dimensionless>);
-static_assert(UnitOf<struct si::radian, isq::angular_measure>);
-static_assert(UnitOf<struct one, isq::angular_measure>);
-static_assert(UnitOf<struct percent, isq::angular_measure>);
+static_assert(UnitOf<struct si::radian, (isq::angular_measure)>);
+static_assert(UnitOf<struct one, (isq::angular_measure)>);
+static_assert(UnitOf<struct percent, (isq::angular_measure)>);
 static_assert(!UnitOf<struct si::radian, dimensionless>);
-static_assert(!UnitOf<struct si::metre, isq::time>);
-static_assert(!UnitOf<struct natural::electronvolt, isq::energy>);
+static_assert(!UnitOf<struct si::metre, (isq::time)>);
+static_assert(!UnitOf<struct natural::electronvolt, (isq::energy)>);
 
 // Reference
 static_assert(Reference<struct si::metre>);
@@ -228,32 +228,32 @@ static_assert(Reference<decltype(isq::radius[si::metre])>);
 static_assert(Reference<decltype(isq::radius[si::metre] / isq::time[si::second])>);
 static_assert(!Reference<struct natural::electronvolt>);
 static_assert(!Reference<struct isq::length>);
-static_assert(!Reference<decltype(kind_of<isq::length>)>);
+static_assert(!Reference<decltype(kind_of<(isq::length)>)>);
 static_assert(!Reference<struct isq::dim_length>);
 static_assert(!Reference<int>);
 
 // ReferenceOf
-static_assert(ReferenceOf<struct si::metre, isq::length>);
-static_assert(ReferenceOf<struct si::metre, isq::radius>);
-static_assert(!ReferenceOf<struct si::second, isq::length>);
-static_assert(ReferenceOf<decltype(isq::length[si::metre]), isq::length>);
-static_assert(!ReferenceOf<decltype(isq::length[si::metre]), isq::radius>);
-static_assert(ReferenceOf<decltype(isq::radius[si::metre]), isq::length>);
-static_assert(ReferenceOf<decltype(isq::radius[si::metre]), isq::radius>);
-static_assert(!ReferenceOf<struct si::second, isq::dim_length>);
+static_assert(ReferenceOf<struct si::metre, (isq::length)>);
+static_assert(ReferenceOf<struct si::metre, (isq::radius)>);
+static_assert(!ReferenceOf<struct si::second, (isq::length)>);
+static_assert(ReferenceOf<decltype(isq::length[si::metre]), (isq::length)>);
+static_assert(!ReferenceOf<decltype(isq::length[si::metre]), (isq::radius)>);
+static_assert(ReferenceOf<decltype(isq::radius[si::metre]), (isq::length)>);
+static_assert(ReferenceOf<decltype(isq::radius[si::metre]), (isq::radius)>);
+static_assert(!ReferenceOf<struct si::second, (isq::dim_length)>);
 
 static_assert(ReferenceOf<struct one, dimensionless>);
 static_assert(ReferenceOf<decltype(dimensionless[one]), dimensionless>);
-static_assert(ReferenceOf<decltype(isq::rotation[one]), isq::rotation>);
+static_assert(ReferenceOf<decltype(isq::rotation[one]), (isq::rotation)>);
 static_assert(ReferenceOf<decltype(isq::rotation[one]), dimensionless>);
-static_assert(ReferenceOf<struct si::radian, isq::angular_measure>);
+static_assert(ReferenceOf<struct si::radian, (isq::angular_measure)>);
 static_assert(!ReferenceOf<struct si::radian, dimensionless>);
-static_assert(ReferenceOf<decltype(isq::angular_measure[si::radian]), isq::angular_measure>);
+static_assert(ReferenceOf<decltype(isq::angular_measure[si::radian]), (isq::angular_measure)>);
 static_assert(!ReferenceOf<decltype(isq::angular_measure[si::radian]), dimensionless>);
-static_assert(ReferenceOf<struct one, isq::rotation>);
-static_assert(ReferenceOf<struct one, isq::angular_measure>);
-static_assert(!ReferenceOf<decltype(dimensionless[one]), isq::rotation>);
-static_assert(!ReferenceOf<decltype(dimensionless[one]), isq::angular_measure>);
+static_assert(ReferenceOf<struct one, (isq::rotation)>);
+static_assert(ReferenceOf<struct one, (isq::angular_measure)>);
+static_assert(!ReferenceOf<decltype(dimensionless[one]), (isq::rotation)>);
+static_assert(!ReferenceOf<decltype(dimensionless[one]), (isq::angular_measure)>);
 
 // Representation
 static_assert(Representation<int>);
@@ -278,57 +278,57 @@ static_assert(!RepresentationOf<std::string, quantity_character::scalar>);
 #endif
 
 // Quantity
-static_assert(Quantity<quantity<si::metre>>);
-static_assert(Quantity<quantity<isq::length[si::metre]>>);
-static_assert(Quantity<quantity<si::metre, int>>);
-static_assert(Quantity<quantity<isq::length[si::metre], int>>);
+static_assert(Quantity<quantity<(si::metre)>>);
+static_assert(Quantity<quantity<(isq::length[si::metre])>>);
+static_assert(Quantity<quantity<(si::metre), int>>);
+static_assert(Quantity<quantity<(isq::length[si::metre]), int>>);
 #if MP_UNITS_HOSTED
 static_assert(!Quantity<std::chrono::seconds>);
 #endif
-static_assert(!Quantity<quantity_point<si::metre, my_origin>>);
+static_assert(!Quantity<quantity_point<(si::metre), my_origin>>);
 static_assert(!Quantity<decltype(isq::length[si::metre])>);
 
 // QuantityOf
-static_assert(QuantityOf<quantity<si::metre>, isq::length>);
-static_assert(QuantityOf<quantity<si::metre>, isq::radius>);
-static_assert(!QuantityOf<quantity<si::second>, isq::length>);
-static_assert(QuantityOf<quantity<isq::length[si::metre]>, isq::length>);
-static_assert(!QuantityOf<quantity<isq::length[si::metre]>, isq::radius>);
-static_assert(QuantityOf<quantity<isq::radius[si::metre]>, isq::length>);
-static_assert(QuantityOf<quantity<isq::radius[si::metre]>, isq::radius>);
-static_assert(!QuantityOf<quantity<si::second>, isq::dim_length>);
+static_assert(QuantityOf<quantity<(si::metre)>, (isq::length)>);
+static_assert(QuantityOf<quantity<(si::metre)>, (isq::radius)>);
+static_assert(!QuantityOf<quantity<(si::second)>, (isq::length)>);
+static_assert(QuantityOf<quantity<(isq::length[si::metre])>, (isq::length)>);
+static_assert(!QuantityOf<quantity<(isq::length[si::metre])>, (isq::radius)>);
+static_assert(QuantityOf<quantity<(isq::radius[si::metre])>, (isq::length)>);
+static_assert(QuantityOf<quantity<(isq::radius[si::metre])>, (isq::radius)>);
+static_assert(!QuantityOf<quantity<(si::second)>, (isq::dim_length)>);
 
 static_assert(QuantityOf<quantity<one>, dimensionless>);
 static_assert(QuantityOf<quantity<dimensionless[one]>, dimensionless>);
-static_assert(QuantityOf<quantity<isq::rotation[one]>, isq::rotation>);
-static_assert(QuantityOf<quantity<isq::rotation[one]>, dimensionless>);
-static_assert(QuantityOf<quantity<si::radian>, isq::angular_measure>);
-static_assert(!QuantityOf<quantity<si::radian>, dimensionless>);
-static_assert(QuantityOf<quantity<isq::angular_measure[si::radian]>, isq::angular_measure>);
-static_assert(!QuantityOf<quantity<isq::angular_measure[si::radian]>, dimensionless>);
-static_assert(QuantityOf<quantity<one>, isq::rotation>);
-static_assert(QuantityOf<quantity<one>, isq::angular_measure>);
-static_assert(!QuantityOf<quantity<dimensionless[one]>, isq::rotation>);
-static_assert(!QuantityOf<quantity<dimensionless[one]>, isq::angular_measure>);
+static_assert(QuantityOf<quantity<(isq::rotation[one])>, (isq::rotation)>);
+static_assert(QuantityOf<quantity<(isq::rotation[one])>, dimensionless>);
+static_assert(QuantityOf<quantity<(si::radian)>, (isq::angular_measure)>);
+static_assert(!QuantityOf<quantity<(si::radian)>, dimensionless>);
+static_assert(QuantityOf<quantity<(isq::angular_measure[si::radian])>, (isq::angular_measure)>);
+static_assert(!QuantityOf<quantity<(isq::angular_measure[si::radian])>, dimensionless>);
+static_assert(QuantityOf<quantity<one>, (isq::rotation)>);
+static_assert(QuantityOf<quantity<one>, (isq::angular_measure)>);
+static_assert(!QuantityOf<quantity<dimensionless[one]>, (isq::rotation)>);
+static_assert(!QuantityOf<quantity<dimensionless[one]>, (isq::angular_measure)>);
 
 // QuantityLike
 #if MP_UNITS_HOSTED
 static_assert(QuantityLike<std::chrono::seconds>);
 static_assert(QuantityLike<std::chrono::hours>);
 #endif
-static_assert(!QuantityLike<quantity<isq::time[si::second]>>);
-static_assert(!QuantityLike<quantity_point<isq::length[si::metre], my_origin>>);
+static_assert(!QuantityLike<quantity<(isq::time[si::second])>>);
+static_assert(!QuantityLike<quantity_point<(isq::length[si::metre]), my_origin>>);
 static_assert(!QuantityLike<int>);
 
 // QuantityPoint
-static_assert(QuantityPoint<quantity_point<si::metre, my_origin>>);
-static_assert(QuantityPoint<quantity_point<si::metre, my_relative_origin>>);
-static_assert(QuantityPoint<quantity_point<isq::length[si::metre], my_origin>>);
-static_assert(QuantityPoint<quantity_point<isq::length[si::metre], my_relative_origin, int>>);
-static_assert(QuantityPoint<quantity_point<isq::radius[si::metre], my_origin>>);
-static_assert(QuantityPoint<quantity_point<isq::radius[si::metre], my_relative_origin>>);
+static_assert(QuantityPoint<quantity_point<(si::metre), my_origin>>);
+static_assert(QuantityPoint<quantity_point<(si::metre), my_relative_origin>>);
+static_assert(QuantityPoint<quantity_point<(isq::length[si::metre]), my_origin>>);
+static_assert(QuantityPoint<quantity_point<(isq::length[si::metre]), my_relative_origin, int>>);
+static_assert(QuantityPoint<quantity_point<(isq::radius[si::metre]), my_origin>>);
+static_assert(QuantityPoint<quantity_point<(isq::radius[si::metre]), my_relative_origin>>);
 static_assert(!QuantityPoint<decltype(isq::length[si::metre])>);
-static_assert(!QuantityPoint<absolute_point_origin<isq::length>>);
+static_assert(!QuantityPoint<absolute_point_origin<(isq::length)>>);
 static_assert(!QuantityPoint<struct my_origin>);
 static_assert(!QuantityPoint<struct my_relative_origin>);
 #if MP_UNITS_HOSTED
@@ -338,35 +338,35 @@ static_assert(!QuantityPoint<std::chrono::time_point<std::chrono::system_clock>>
 static_assert(!QuantityPoint<int>);
 
 // QuantityPointOf
-static_assert(QuantityPointOf<quantity_point<si::metre, my_origin>, isq::length>);
-static_assert(QuantityPointOf<quantity_point<si::metre, my_origin>, isq::radius>);
-static_assert(QuantityPointOf<quantity_point<isq::length[si::metre], my_origin>, isq::length>);
-static_assert(!QuantityPointOf<quantity_point<isq::length[si::metre], my_origin>, isq::radius>);
-static_assert(QuantityPointOf<quantity_point<isq::radius[si::metre], my_origin>, isq::length>);
-static_assert(QuantityPointOf<quantity_point<isq::radius[si::metre], my_origin>, isq::radius>);
-static_assert(QuantityPointOf<quantity_point<isq::radius[si::metre], my_relative_origin>, isq::length>);
-static_assert(QuantityPointOf<quantity_point<isq::radius[si::metre], my_relative_origin>, isq::radius>);
-static_assert(QuantityPointOf<quantity_point<si::metre, my_origin>, my_origin>);
-static_assert(QuantityPointOf<quantity_point<si::metre, my_origin>, my_relative_origin>);
-static_assert(QuantityPointOf<quantity_point<si::metre, my_relative_origin>, my_relative_origin>);
-static_assert(QuantityPointOf<quantity_point<si::metre, my_relative_origin>, my_origin>);
-static_assert(QuantityPointOf<quantity_point<isq::length[si::metre], my_origin>, my_origin>);
-static_assert(QuantityPointOf<quantity_point<isq::length[si::metre], my_origin>, my_relative_origin>);
-static_assert(QuantityPointOf<quantity_point<isq::length[si::metre], my_relative_origin>, my_relative_origin>);
-static_assert(QuantityPointOf<quantity_point<isq::length[si::metre], my_relative_origin>, my_origin>);
-static_assert(QuantityPointOf<quantity_point<isq::radius[si::metre], my_origin>, my_origin>);
-static_assert(QuantityPointOf<quantity_point<isq::radius[si::metre], my_origin>, my_relative_origin>);
-static_assert(QuantityPointOf<quantity_point<isq::radius[si::metre], my_relative_origin>, my_relative_origin>);
-static_assert(QuantityPointOf<quantity_point<isq::radius[si::metre], my_relative_origin>, my_origin>);
+static_assert(QuantityPointOf<quantity_point<(si::metre), my_origin>, (isq::length)>);
+static_assert(QuantityPointOf<quantity_point<(si::metre), my_origin>, (isq::radius)>);
+static_assert(QuantityPointOf<quantity_point<(isq::length[si::metre]), my_origin>, (isq::length)>);
+static_assert(!QuantityPointOf<quantity_point<(isq::length[si::metre]), my_origin>, (isq::radius)>);
+static_assert(QuantityPointOf<quantity_point<(isq::radius[si::metre]), my_origin>, (isq::length)>);
+static_assert(QuantityPointOf<quantity_point<(isq::radius[si::metre]), my_origin>, (isq::radius)>);
+static_assert(QuantityPointOf<quantity_point<(isq::radius[si::metre]), my_relative_origin>, (isq::length)>);
+static_assert(QuantityPointOf<quantity_point<(isq::radius[si::metre]), my_relative_origin>, (isq::radius)>);
+static_assert(QuantityPointOf<quantity_point<(si::metre), my_origin>, my_origin>);
+static_assert(QuantityPointOf<quantity_point<(si::metre), my_origin>, my_relative_origin>);
+static_assert(QuantityPointOf<quantity_point<(si::metre), my_relative_origin>, my_relative_origin>);
+static_assert(QuantityPointOf<quantity_point<(si::metre), my_relative_origin>, my_origin>);
+static_assert(QuantityPointOf<quantity_point<(isq::length[si::metre]), my_origin>, my_origin>);
+static_assert(QuantityPointOf<quantity_point<(isq::length[si::metre]), my_origin>, my_relative_origin>);
+static_assert(QuantityPointOf<quantity_point<(isq::length[si::metre]), my_relative_origin>, my_relative_origin>);
+static_assert(QuantityPointOf<quantity_point<(isq::length[si::metre]), my_relative_origin>, my_origin>);
+static_assert(QuantityPointOf<quantity_point<(isq::radius[si::metre]), my_origin>, my_origin>);
+static_assert(QuantityPointOf<quantity_point<(isq::radius[si::metre]), my_origin>, my_relative_origin>);
+static_assert(QuantityPointOf<quantity_point<(isq::radius[si::metre]), my_relative_origin>, my_relative_origin>);
+static_assert(QuantityPointOf<quantity_point<(isq::radius[si::metre]), my_relative_origin>, my_origin>);
 
 // PointOrigin
 static_assert(PointOrigin<struct my_origin>);
 static_assert(PointOrigin<struct my_relative_origin>);
-static_assert(!PointOrigin<absolute_point_origin<isq::length>>);
+static_assert(!PointOrigin<absolute_point_origin<(isq::length)>>);
 static_assert(!PointOrigin<relative_point_origin<my_origin + 42 * si::metre>>);
-static_assert(!PointOrigin<quantity_point<si::metre, my_origin>>);
-static_assert(!PointOrigin<quantity_point<isq::length[si::metre], my_origin>>);
-static_assert(!PointOrigin<quantity_point<isq::radius[si::metre], my_origin>>);
+static_assert(!PointOrigin<quantity_point<(si::metre), my_origin>>);
+static_assert(!PointOrigin<quantity_point<(isq::length[si::metre]), my_origin>>);
+static_assert(!PointOrigin<quantity_point<(isq::radius[si::metre]), my_origin>>);
 static_assert(!PointOrigin<decltype(isq::length[si::metre])>);
 #if MP_UNITS_HOSTED
 static_assert(!PointOrigin<std::chrono::seconds>);
@@ -375,38 +375,38 @@ static_assert(!PointOrigin<std::chrono::time_point<std::chrono::system_clock>>);
 static_assert(!PointOrigin<int>);
 
 // PointOriginFor
-static_assert(PointOriginFor<struct my_origin, isq::length>);
-static_assert(PointOriginFor<struct my_origin, isq::radius>);
-static_assert(!PointOriginFor<struct my_origin, isq::time>);
-static_assert(PointOriginFor<struct my_relative_origin, isq::length>);
-static_assert(PointOriginFor<struct my_relative_origin, isq::radius>);
-static_assert(!PointOriginFor<struct my_relative_origin, isq::time>);
-static_assert(!PointOriginFor<quantity_point<si::metre, my_origin>, isq::length>);
-static_assert(!PointOriginFor<quantity_point<si::metre, my_origin>, isq::radius>);
-static_assert(!PointOriginFor<quantity_point<si::metre, my_origin>, isq::time>);
-static_assert(!PointOriginFor<quantity_point<isq::length[si::metre], my_origin>, isq::length>);
-static_assert(!PointOriginFor<quantity_point<isq::length[si::metre], my_origin>, isq::radius>);
-static_assert(!PointOriginFor<quantity_point<isq::length[si::metre], my_origin>, isq::time>);
-static_assert(!PointOriginFor<quantity_point<isq::radius[si::metre], my_origin>, isq::length>);
-static_assert(!PointOriginFor<quantity_point<isq::radius[si::metre], my_origin>, isq::radius>);
-static_assert(!PointOriginFor<quantity_point<isq::radius[si::metre], my_origin>, isq::time>);
-static_assert(!PointOriginFor<quantity_point<isq::radius[si::metre], my_relative_origin>, isq::length>);
-static_assert(!PointOriginFor<quantity_point<isq::radius[si::metre], my_relative_origin>, isq::radius>);
-static_assert(!PointOriginFor<quantity_point<isq::radius[si::metre], my_relative_origin>, isq::time>);
-static_assert(!PointOriginFor<decltype(isq::length[si::metre]), isq::length>);
+static_assert(PointOriginFor<struct my_origin, (isq::length)>);
+static_assert(PointOriginFor<struct my_origin, (isq::radius)>);
+static_assert(!PointOriginFor<struct my_origin, (isq::time)>);
+static_assert(PointOriginFor<struct my_relative_origin, (isq::length)>);
+static_assert(PointOriginFor<struct my_relative_origin, (isq::radius)>);
+static_assert(!PointOriginFor<struct my_relative_origin, (isq::time)>);
+static_assert(!PointOriginFor<quantity_point<(si::metre), my_origin>, (isq::length)>);
+static_assert(!PointOriginFor<quantity_point<(si::metre), my_origin>, (isq::radius)>);
+static_assert(!PointOriginFor<quantity_point<(si::metre), my_origin>, (isq::time)>);
+static_assert(!PointOriginFor<quantity_point<(isq::length[si::metre]), my_origin>, (isq::length)>);
+static_assert(!PointOriginFor<quantity_point<(isq::length[si::metre]), my_origin>, (isq::radius)>);
+static_assert(!PointOriginFor<quantity_point<(isq::length[si::metre]), my_origin>, (isq::time)>);
+static_assert(!PointOriginFor<quantity_point<(isq::radius[si::metre]), my_origin>, (isq::length)>);
+static_assert(!PointOriginFor<quantity_point<(isq::radius[si::metre]), my_origin>, (isq::radius)>);
+static_assert(!PointOriginFor<quantity_point<(isq::radius[si::metre]), my_origin>, (isq::time)>);
+static_assert(!PointOriginFor<quantity_point<(isq::radius[si::metre]), my_relative_origin>, (isq::length)>);
+static_assert(!PointOriginFor<quantity_point<(isq::radius[si::metre]), my_relative_origin>, (isq::radius)>);
+static_assert(!PointOriginFor<quantity_point<(isq::radius[si::metre]), my_relative_origin>, (isq::time)>);
+static_assert(!PointOriginFor<decltype((isq::length[si::metre])), (isq::length)>);
 #if MP_UNITS_HOSTED
-static_assert(!PointOriginFor<std::chrono::seconds, isq::length>);
-static_assert(!PointOriginFor<std::chrono::time_point<std::chrono::system_clock>, isq::length>);
+static_assert(!PointOriginFor<std::chrono::seconds, (isq::length)>);
+static_assert(!PointOriginFor<std::chrono::time_point<std::chrono::system_clock>, (isq::length)>);
 #endif
-static_assert(!PointOriginFor<int, isq::length>);
+static_assert(!PointOriginFor<int, (isq::length)>);
 
 // QuantityPointLike
 #if MP_UNITS_HOSTED
 static_assert(QuantityPointLike<std::chrono::time_point<std::chrono::system_clock>>);
 static_assert(!QuantityPointLike<std::chrono::seconds>);
 #endif
-static_assert(!QuantityPointLike<quantity<isq::time[si::second]>>);
-static_assert(!QuantityPointLike<quantity_point<si::metre, my_origin>>);
+static_assert(!QuantityPointLike<quantity<(isq::time[si::second])>>);
+static_assert(!QuantityPointLike<quantity_point<(si::metre), my_origin>>);
 static_assert(!QuantityPointLike<int>);
 
 }  // namespace
diff --git a/test/static/custom_rep_test_min_impl.cpp b/test/static/custom_rep_test_min_impl.cpp
index 4fb2537b..8b328557 100644
--- a/test/static/custom_rep_test_min_impl.cpp
+++ b/test/static/custom_rep_test_min_impl.cpp
@@ -78,18 +78,18 @@ static_assert(Representation<min_impl<int>>);
 static_assert(Representation<min_impl<double>>);
 
 // construction from a value is not allowed
-static_assert(!std::constructible_from<quantity<si::metre, min_impl<int>>, min_impl<int>>);
-static_assert(!std::convertible_to<min_impl<int>, quantity<si::metre, min_impl<int>>>);
+static_assert(!std::constructible_from<quantity<(si::metre), min_impl<int>>, min_impl<int>>);
+static_assert(!std::convertible_to<min_impl<int>, quantity<(si::metre), min_impl<int>>>);
 
-static_assert(!std::constructible_from<quantity<si::metre, min_impl<double>>, min_impl<double>>);
-static_assert(!std::convertible_to<min_impl<double>, quantity<si::metre, min_impl<double>>>);
+static_assert(!std::constructible_from<quantity<(si::metre), min_impl<double>>, min_impl<double>>);
+static_assert(!std::convertible_to<min_impl<double>, quantity<(si::metre), min_impl<double>>>);
 
 // multiply syntax should work
 template<typename T, auto U>
 concept creates_quantity = Unit<decltype(U)> && requires { T{} * U; };
 
-static_assert(creates_quantity<min_impl<int>, si::metre>);
-static_assert(creates_quantity<min_impl<double>, si::metre>);
+static_assert(creates_quantity<min_impl<int>, (si::metre)>);
+static_assert(creates_quantity<min_impl<double>, (si::metre)>);
 
 // multiply syntax
 static_assert(creates_quantity<min_impl<int>, one>);
@@ -99,46 +99,47 @@ static_assert(creates_quantity<min_impl<double>, percent>);
 
 // construction from a quantity
 // min_impl<T> -> min_impl<T>
-static_assert(std::constructible_from<quantity<si::metre, min_impl<int>>, quantity<si::metre, min_impl<int>>>);
-static_assert(std::convertible_to<quantity<si::metre, min_impl<int>>, quantity<si::metre, min_impl<int>>>);
+static_assert(std::constructible_from<quantity<(si::metre), min_impl<int>>, quantity<(si::metre), min_impl<int>>>);
+static_assert(std::convertible_to<quantity<(si::metre), min_impl<int>>, quantity<(si::metre), min_impl<int>>>);
 
-static_assert(std::constructible_from<quantity<si::metre, min_impl<double>>, quantity<si::metre, min_impl<double>>>);
-static_assert(std::convertible_to<quantity<si::metre, min_impl<double>>, quantity<si::metre, min_impl<double>>>);
+static_assert(
+  std::constructible_from<quantity<(si::metre), min_impl<double>>, quantity<(si::metre), min_impl<double>>>);
+static_assert(std::convertible_to<quantity<(si::metre), min_impl<double>>, quantity<(si::metre), min_impl<double>>>);
 
-static_assert(std::constructible_from<quantity<si::metre, min_impl<double>>, quantity<si::metre, min_impl<int>>>);
-static_assert(std::convertible_to<quantity<si::metre, min_impl<int>>, quantity<si::metre, min_impl<double>>>);
+static_assert(std::constructible_from<quantity<(si::metre), min_impl<double>>, quantity<(si::metre), min_impl<int>>>);
+static_assert(std::convertible_to<quantity<(si::metre), min_impl<int>>, quantity<(si::metre), min_impl<double>>>);
 
-static_assert(!std::constructible_from<quantity<si::metre, min_impl<int>>,
-                                       quantity<si::metre, min_impl<double>>>);  // narrowing conversion
-static_assert(!std::convertible_to<quantity<si::metre, min_impl<double>>, quantity<si::metre, min_impl<int>>>);
+static_assert(!std::constructible_from<quantity<(si::metre), min_impl<int>>,
+                                       quantity<(si::metre), min_impl<double>>>);  // narrowing conversion
+static_assert(!std::convertible_to<quantity<(si::metre), min_impl<double>>, quantity<(si::metre), min_impl<int>>>);
 
 // T -> min_impl<T>
-static_assert(std::constructible_from<quantity<si::metre, min_impl<int>>, quantity<si::metre, int>>);
-static_assert(std::convertible_to<quantity<si::metre, int>, quantity<si::metre, min_impl<int>>>);
+static_assert(std::constructible_from<quantity<(si::metre), min_impl<int>>, quantity<(si::metre), int>>);
+static_assert(std::convertible_to<quantity<(si::metre), int>, quantity<(si::metre), min_impl<int>>>);
 
-static_assert(std::constructible_from<quantity<si::metre, min_impl<double>>, quantity<si::metre, double>>);
-static_assert(std::convertible_to<quantity<si::metre, double>, quantity<si::metre, min_impl<double>>>);
+static_assert(std::constructible_from<quantity<(si::metre), min_impl<double>>, quantity<(si::metre), double>>);
+static_assert(std::convertible_to<quantity<(si::metre), double>, quantity<(si::metre), min_impl<double>>>);
 
-static_assert(std::constructible_from<quantity<si::metre, min_impl<double>>, quantity<si::metre, int>>);
-static_assert(std::convertible_to<quantity<si::metre, int>, quantity<si::metre, min_impl<double>>>);
+static_assert(std::constructible_from<quantity<(si::metre), min_impl<double>>, quantity<(si::metre), int>>);
+static_assert(std::convertible_to<quantity<(si::metre), int>, quantity<(si::metre), min_impl<double>>>);
 
-static_assert(
-  !std::constructible_from<quantity<si::metre, min_impl<int>>, quantity<si::metre, double>>);  // narrowing conversion
-static_assert(!std::convertible_to<quantity<si::metre, double>, quantity<si::metre, min_impl<int>>>);
+static_assert(!std::constructible_from<quantity<(si::metre), min_impl<int>>,
+                                       quantity<(si::metre), double>>);  // narrowing conversion
+static_assert(!std::convertible_to<quantity<(si::metre), double>, quantity<(si::metre), min_impl<int>>>);
 
 // min_impl<T> -> T
-static_assert(std::constructible_from<quantity<si::metre, int>, quantity<si::metre, min_impl<int>>>);
-static_assert(std::convertible_to<quantity<si::metre, min_impl<int>>, quantity<si::metre, int>>);
+static_assert(std::constructible_from<quantity<(si::metre), int>, quantity<(si::metre), min_impl<int>>>);
+static_assert(std::convertible_to<quantity<(si::metre), min_impl<int>>, quantity<(si::metre), int>>);
 
-static_assert(std::constructible_from<quantity<si::metre, double>, quantity<si::metre, min_impl<double>>>);
-static_assert(std::convertible_to<quantity<si::metre, min_impl<double>>, quantity<si::metre, double>>);
+static_assert(std::constructible_from<quantity<(si::metre), double>, quantity<(si::metre), min_impl<double>>>);
+static_assert(std::convertible_to<quantity<(si::metre), min_impl<double>>, quantity<(si::metre), double>>);
 
-static_assert(std::constructible_from<quantity<si::metre, double>, quantity<si::metre, min_impl<int>>>);
-static_assert(std::convertible_to<quantity<si::metre, min_impl<int>>, quantity<si::metre, double>>);
+static_assert(std::constructible_from<quantity<(si::metre), double>, quantity<(si::metre), min_impl<int>>>);
+static_assert(std::convertible_to<quantity<(si::metre), min_impl<int>>, quantity<(si::metre), double>>);
 
-static_assert(
-  !std::constructible_from<quantity<si::metre, int>, quantity<si::metre, min_impl<double>>>);  // narrowing conversion
-static_assert(!std::convertible_to<quantity<si::metre, min_impl<double>>, quantity<si::metre, int>>);
+static_assert(!std::constructible_from<quantity<(si::metre), int>,
+                                       quantity<(si::metre), min_impl<double>>>);  // narrowing conversion
+static_assert(!std::convertible_to<quantity<(si::metre), min_impl<double>>, quantity<(si::metre), int>>);
 
 
 // arithmetic operators
diff --git a/test/static/dimension_test.cpp b/test/static/dimension_test.cpp
index 8064831e..f1d64590 100644
--- a/test/static/dimension_test.cpp
+++ b/test/static/dimension_test.cpp
@@ -33,7 +33,7 @@ namespace {
 
 using namespace mp_units;
 
-using dimension_one_ = struct dimension_one;
+using dimension_one_ = struct mp_units::dimension_one;
 
 // clang-format off
 inline constexpr struct length_ final : base_dimension<"L"> {} length;
diff --git a/test/static/quantity_point_test.cpp b/test/static/quantity_point_test.cpp
index f04e9c1a..50dfb67e 100644
--- a/test/static/quantity_point_test.cpp
+++ b/test/static/quantity_point_test.cpp
@@ -58,24 +58,24 @@ inline constexpr struct mean_sea_level final : absolute_point_origin<isq::height
 
 inline constexpr auto my_mean_sea_level = mean_sea_level;
 
-inline constexpr struct same_mean_sea_level final : relative_point_origin<mean_sea_level + 0 * isq::height[m]> {
+inline constexpr struct same_mean_sea_level final : relative_point_origin<mean_sea_level + 0 * (isq::height[m])> {
 } same_mean_sea_level;
 
-inline constexpr struct ground_level final : relative_point_origin<mean_sea_level + 42 * isq::height[m]> {
+inline constexpr struct ground_level final : relative_point_origin<mean_sea_level + 42 * (isq::height[m])> {
 } ground_level;
 
 inline constexpr auto my_ground_level = ground_level;
 
-inline constexpr struct same_ground_level1 final : relative_point_origin<mean_sea_level + 42 * isq::height[m]> {
+inline constexpr struct same_ground_level1 final : relative_point_origin<mean_sea_level + 42 * (isq::height[m])> {
 } same_ground_level1;
 
-inline constexpr struct same_ground_level2 final : relative_point_origin<my_mean_sea_level + 42 * isq::height[m]> {
+inline constexpr struct same_ground_level2 final : relative_point_origin<my_mean_sea_level + 42 * (isq::height[m])> {
 } same_ground_level2;
 
-inline constexpr struct tower_peak final : relative_point_origin<ground_level + 42 * isq::height[m]> {
+inline constexpr struct tower_peak final : relative_point_origin<ground_level + 42 * (isq::height[m])> {
 } tower_peak;
 
-inline constexpr struct other_ground_level final : relative_point_origin<mean_sea_level + 123 * isq::height[m]> {
+inline constexpr struct other_ground_level final : relative_point_origin<mean_sea_level + 123 * (isq::height[m])> {
 } other_ground_level;
 
 inline constexpr struct other_absolute_level final : absolute_point_origin<isq::height> {
@@ -152,10 +152,10 @@ static_assert(zeroth_point_origin<inverse(isq::time)> != zeroth_point_origin<isq
 // class invariants
 /////////////////////
 
-static_assert(sizeof(quantity_point<si::metre, mean_sea_level>) == sizeof(double));
-static_assert(sizeof(quantity_point<isq::height[m], mean_sea_level>) == sizeof(double));
-static_assert(sizeof(quantity_point<si::metre, ground_level, short>) == sizeof(short));
-static_assert(sizeof(quantity_point<isq::height[m], ground_level, short>) == sizeof(short));
+static_assert(sizeof(quantity_point<(si::metre), mean_sea_level>) == sizeof(double));
+static_assert(sizeof(quantity_point<(isq::height[m]), mean_sea_level>) == sizeof(double));
+static_assert(sizeof(quantity_point<(si::metre), ground_level, short>) == sizeof(short));
+static_assert(sizeof(quantity_point<(isq::height[m]), ground_level, short>) == sizeof(short));
 
 template<template<auto, auto, typename> typename QP>
 concept invalid_types = requires {
@@ -188,15 +188,15 @@ static_assert(invalid_types<quantity_point>);
 
 template<template<auto, auto, typename> typename QP>
 concept valid_types = requires {
-  typename QP<si::metre, mean_sea_level, int>;
-  typename QP<isq::height[m], mean_sea_level, int>;
-  typename QP<special_height[m], mean_sea_level, int>;
-  typename QP<si::metre, ground_level, int>;
-  typename QP<isq::height[m], ground_level, int>;
-  typename QP<special_height[m], ground_level, int>;
-  typename QP<isq::height[m], zeroth_point_origin<isq::length>, int>;
-  typename QP<isq::height[m], zeroth_point_origin<kind_of<isq::length>>, int>;
-  typename QP<si::metre, zeroth_point_origin<isq::height>, int>;
+  typename QP<(si::metre), mean_sea_level, int>;
+  typename QP<(isq::height[m]), mean_sea_level, int>;
+  typename QP<(special_height[m]), mean_sea_level, int>;
+  typename QP<(si::metre), ground_level, int>;
+  typename QP<(isq::height[m]), ground_level, int>;
+  typename QP<(special_height[m]), ground_level, int>;
+  typename QP<(isq::height[m]), zeroth_point_origin<(isq::length)>, int>;
+  typename QP<(isq::height[m]), zeroth_point_origin<kind_of<(isq::length)>>, int>;
+  typename QP<(si::metre), zeroth_point_origin<(isq::height)>, int>;
 };
 static_assert(valid_types<quantity_point>);
 
@@ -217,14 +217,14 @@ static_assert(std::is_nothrow_destructible_v<quantity_point<si::metre, mean_sea_
 static_assert(std::is_trivially_copyable_v<quantity_point<si::metre, mean_sea_level>>);
 static_assert(std::is_standard_layout_v<quantity_point<si::metre, mean_sea_level>>);
 
-static_assert(std::default_initializable<quantity_point<si::metre, mean_sea_level>>);
-static_assert(std::move_constructible<quantity_point<si::metre, mean_sea_level>>);
-static_assert(std::copy_constructible<quantity_point<si::metre, mean_sea_level>>);
-static_assert(std::equality_comparable<quantity_point<si::metre, mean_sea_level>>);
-static_assert(std::totally_ordered<quantity_point<si::metre, mean_sea_level>>);
-static_assert(std::regular<quantity_point<si::metre, mean_sea_level>>);
+static_assert(std::default_initializable<quantity_point<(si::metre), mean_sea_level>>);
+static_assert(std::move_constructible<quantity_point<(si::metre), mean_sea_level>>);
+static_assert(std::copy_constructible<quantity_point<(si::metre), mean_sea_level>>);
+static_assert(std::equality_comparable<quantity_point<(si::metre), mean_sea_level>>);
+static_assert(std::totally_ordered<quantity_point<(si::metre), mean_sea_level>>);
+static_assert(std::regular<quantity_point<(si::metre), mean_sea_level>>);
 
-static_assert(std::three_way_comparable<quantity_point<si::metre, mean_sea_level>>);
+static_assert(std::three_way_comparable<quantity_point<(si::metre), mean_sea_level>>);
 
 
 //////////////////
@@ -235,51 +235,53 @@ static_assert(quantity_point<si::metre>::reference == si::metre);
 static_assert(quantity_point<si::metre>::quantity_spec == kind_of<isq::length>);
 static_assert(quantity_point<si::metre>::dimension == isq::dim_length);
 static_assert(quantity_point<si::metre>::unit == si::metre);
-static_assert(is_of_type<quantity_point<si::metre>::point_origin, zeroth_point_origin_<kind_of<isq::length>>>);
-static_assert(is_of_type<quantity_point<si::metre>::absolute_point_origin, zeroth_point_origin_<kind_of<isq::length>>>);
+static_assert(is_of_type<quantity_point<(si::metre)>::point_origin, zeroth_point_origin_<kind_of<isq::length>>>);
+static_assert(
+  is_of_type<quantity_point<(si::metre)>::absolute_point_origin, zeroth_point_origin_<kind_of<isq::length>>>);
 
 static_assert(quantity_point<isq::height[m]>::reference == isq::height[m]);
 static_assert(quantity_point<isq::height[m]>::quantity_spec == isq::height);
 static_assert(quantity_point<isq::height[m]>::dimension == isq::dim_length);
 static_assert(quantity_point<isq::height[m]>::unit == si::metre);
-static_assert(is_of_type<quantity_point<isq::height[m]>::point_origin, zeroth_point_origin_<isq::height>>);
-static_assert(is_of_type<quantity_point<isq::height[m]>::absolute_point_origin, zeroth_point_origin_<isq::height>>);
+static_assert(is_of_type<quantity_point<(isq::height[m])>::point_origin, zeroth_point_origin_<isq::height>>);
+static_assert(is_of_type<quantity_point<(isq::height[m])>::absolute_point_origin, zeroth_point_origin_<isq::height>>);
 
 static_assert(quantity_point<si::metre, mean_sea_level>::reference == si::metre);
 static_assert(quantity_point<si::metre, mean_sea_level>::quantity_spec == kind_of<isq::length>);
 static_assert(quantity_point<si::metre, mean_sea_level>::dimension == isq::dim_length);
 static_assert(quantity_point<si::metre, mean_sea_level>::unit == si::metre);
-static_assert(is_of_type<quantity_point<si::metre, mean_sea_level>::point_origin, struct mean_sea_level>);
-static_assert(is_of_type<quantity_point<si::metre, mean_sea_level>::absolute_point_origin, struct mean_sea_level>);
+static_assert(is_of_type<quantity_point<(si::metre), mean_sea_level>::point_origin, struct mean_sea_level>);
+static_assert(is_of_type<quantity_point<(si::metre), mean_sea_level>::absolute_point_origin, struct mean_sea_level>);
 
 static_assert(quantity_point<isq::height[m], mean_sea_level>::reference == isq::height[m]);
 static_assert(quantity_point<isq::height[m], mean_sea_level>::quantity_spec == isq::height);
 static_assert(quantity_point<isq::height[m], mean_sea_level>::dimension == isq::dim_length);
 static_assert(quantity_point<isq::height[m], mean_sea_level>::unit == si::metre);
-static_assert(is_of_type<quantity_point<isq::height[m], mean_sea_level>::point_origin, struct mean_sea_level>);
-static_assert(is_of_type<quantity_point<isq::height[m], mean_sea_level>::absolute_point_origin, struct mean_sea_level>);
+static_assert(is_of_type<quantity_point<(isq::height[m]), mean_sea_level>::point_origin, struct mean_sea_level>);
+static_assert(
+  is_of_type<quantity_point<(isq::height[m]), mean_sea_level>::absolute_point_origin, struct mean_sea_level>);
 
 static_assert(quantity_point<isq::height[m], ground_level>::reference == isq::height[m]);
 static_assert(quantity_point<isq::height[m], ground_level>::quantity_spec == isq::height);
 static_assert(quantity_point<isq::height[m], ground_level>::dimension == isq::dim_length);
 static_assert(quantity_point<isq::height[m], ground_level>::unit == si::metre);
-static_assert(is_of_type<quantity_point<isq::height[m], ground_level>::point_origin, struct ground_level>);
-static_assert(is_of_type<quantity_point<isq::height[m], ground_level>::absolute_point_origin, struct mean_sea_level>);
+static_assert(is_of_type<quantity_point<(isq::height[m]), ground_level>::point_origin, struct ground_level>);
+static_assert(is_of_type<quantity_point<(isq::height[m]), ground_level>::absolute_point_origin, struct mean_sea_level>);
 
 static_assert(quantity_point<isq::height[m], tower_peak>::reference == isq::height[m]);
 static_assert(quantity_point<isq::height[m], tower_peak>::quantity_spec == isq::height);
 static_assert(quantity_point<isq::height[m], tower_peak>::dimension == isq::dim_length);
 static_assert(quantity_point<isq::height[m], tower_peak>::unit == si::metre);
-static_assert(is_of_type<quantity_point<isq::height[m], tower_peak>::point_origin, struct tower_peak>);
-static_assert(is_of_type<quantity_point<isq::height[m], tower_peak>::absolute_point_origin, struct mean_sea_level>);
+static_assert(is_of_type<quantity_point<(isq::height[m]), tower_peak>::point_origin, struct tower_peak>);
+static_assert(is_of_type<quantity_point<(isq::height[m]), tower_peak>::absolute_point_origin, struct mean_sea_level>);
 
 static_assert(quantity_point<si::kelvin, si::absolute_zero>::reference == si::kelvin);
 static_assert(quantity_point<si::kelvin, si::absolute_zero>::quantity_spec == kind_of<isq::thermodynamic_temperature>);
 static_assert(quantity_point<si::kelvin, si::absolute_zero>::dimension == isq::dim_thermodynamic_temperature);
 static_assert(quantity_point<si::kelvin, si::absolute_zero>::unit == si::kelvin);
-static_assert(is_of_type<quantity_point<si::kelvin, si::absolute_zero>::point_origin, struct si::absolute_zero>);
+static_assert(is_of_type<quantity_point<(si::kelvin), (si::absolute_zero)>::point_origin, struct si::absolute_zero>);
 static_assert(
-  is_of_type<quantity_point<si::kelvin, si::absolute_zero>::absolute_point_origin, struct si::absolute_zero>);
+  is_of_type<quantity_point<(si::kelvin), (si::absolute_zero)>::absolute_point_origin, struct si::absolute_zero>);
 
 static_assert(quantity_point<isq::thermodynamic_temperature[si::kelvin], si::absolute_zero>::reference ==
               isq::thermodynamic_temperature[si::kelvin]);
@@ -288,10 +290,11 @@ static_assert(quantity_point<isq::thermodynamic_temperature[si::kelvin], si::abs
 static_assert(quantity_point<isq::thermodynamic_temperature[si::kelvin], si::absolute_zero>::dimension ==
               isq::dim_thermodynamic_temperature);
 static_assert(quantity_point<isq::thermodynamic_temperature[si::kelvin], si::absolute_zero>::unit == si::kelvin);
-static_assert(is_of_type<quantity_point<isq::thermodynamic_temperature[si::kelvin], si::absolute_zero>::point_origin,
-                         struct si::absolute_zero>);
 static_assert(
-  is_of_type<quantity_point<isq::thermodynamic_temperature[si::kelvin], si::absolute_zero>::absolute_point_origin,
+  is_of_type<quantity_point<(isq::thermodynamic_temperature[si::kelvin]), (si::absolute_zero)>::point_origin,
+             struct si::absolute_zero>);
+static_assert(
+  is_of_type<quantity_point<(isq::thermodynamic_temperature[si::kelvin]), (si::absolute_zero)>::absolute_point_origin,
              struct si::absolute_zero>);
 
 static_assert(quantity_point<isq::Celsius_temperature[si::kelvin], si::absolute_zero>::reference ==
@@ -301,19 +304,20 @@ static_assert(quantity_point<isq::Celsius_temperature[si::kelvin], si::absolute_
 static_assert(quantity_point<isq::Celsius_temperature[si::kelvin], si::absolute_zero>::dimension ==
               isq::dim_thermodynamic_temperature);
 static_assert(quantity_point<isq::Celsius_temperature[si::kelvin], si::absolute_zero>::unit == si::kelvin);
-static_assert(is_of_type<quantity_point<isq::Celsius_temperature[si::kelvin], si::absolute_zero>::point_origin,
-                         struct si::absolute_zero>);
-static_assert(is_of_type<quantity_point<isq::Celsius_temperature[si::kelvin], si::absolute_zero>::absolute_point_origin,
+static_assert(is_of_type<quantity_point<(isq::Celsius_temperature[si::kelvin]), (si::absolute_zero)>::point_origin,
                          struct si::absolute_zero>);
+static_assert(
+  is_of_type<quantity_point<(isq::Celsius_temperature[si::kelvin]), (si::absolute_zero)>::absolute_point_origin,
+             struct si::absolute_zero>);
 
 static_assert(quantity_point<si::degree_Celsius, si::ice_point>::reference == si::degree_Celsius);
 static_assert(quantity_point<si::degree_Celsius, si::ice_point>::quantity_spec ==
               kind_of<isq::thermodynamic_temperature>);
 static_assert(quantity_point<si::degree_Celsius, si::ice_point>::dimension == isq::dim_thermodynamic_temperature);
 static_assert(quantity_point<si::degree_Celsius, si::ice_point>::unit == si::degree_Celsius);
-static_assert(is_of_type<quantity_point<si::degree_Celsius, si::ice_point>::point_origin, struct si::ice_point>);
+static_assert(is_of_type<quantity_point<(si::degree_Celsius), (si::ice_point)>::point_origin, struct si::ice_point>);
 static_assert(
-  is_of_type<quantity_point<si::degree_Celsius, si::ice_point>::absolute_point_origin, struct si::absolute_zero>);
+  is_of_type<quantity_point<(si::degree_Celsius), (si::ice_point)>::absolute_point_origin, struct si::absolute_zero>);
 
 static_assert(quantity_point<isq::Celsius_temperature[si::degree_Celsius], si::ice_point>::reference ==
               isq::Celsius_temperature[si::degree_Celsius]);
@@ -322,10 +326,10 @@ static_assert(quantity_point<isq::Celsius_temperature[si::degree_Celsius], si::i
 static_assert(quantity_point<isq::Celsius_temperature[si::degree_Celsius], si::ice_point>::dimension ==
               isq::dim_thermodynamic_temperature);
 static_assert(quantity_point<isq::Celsius_temperature[si::degree_Celsius], si::ice_point>::unit == si::degree_Celsius);
-static_assert(is_of_type<quantity_point<isq::Celsius_temperature[si::degree_Celsius], si::ice_point>::point_origin,
+static_assert(is_of_type<quantity_point<(isq::Celsius_temperature[si::degree_Celsius]), (si::ice_point)>::point_origin,
                          struct si::ice_point>);
 static_assert(
-  is_of_type<quantity_point<isq::Celsius_temperature[si::degree_Celsius], si::ice_point>::absolute_point_origin,
+  is_of_type<quantity_point<(isq::Celsius_temperature[si::degree_Celsius]), (si::ice_point)>::absolute_point_origin,
              struct si::absolute_zero>);
 
 
@@ -333,18 +337,18 @@ static_assert(
 // member types
 //////////////////
 
-static_assert(is_same_v<quantity_point<si::metre, mean_sea_level>::rep, double>);
-static_assert(is_same_v<quantity_point<si::metre, mean_sea_level>::quantity_type, quantity<si::metre>>);
+static_assert(is_same_v<quantity_point<(si::metre), mean_sea_level>::rep, double>);
+static_assert(is_same_v<quantity_point<(si::metre), mean_sea_level>::quantity_type, quantity<si::metre>>);
 
-static_assert(is_same_v<quantity_point<si::metre, mean_sea_level, int>::rep, int>);
-static_assert(is_same_v<quantity_point<si::metre, mean_sea_level, int>::quantity_type, quantity<si::metre, int>>);
+static_assert(is_same_v<quantity_point<(si::metre), mean_sea_level, int>::rep, int>);
+static_assert(is_same_v<quantity_point<(si::metre), mean_sea_level, int>::quantity_type, quantity<si::metre, int>>);
 
-static_assert(is_same_v<quantity_point<isq::height[m], mean_sea_level>::rep, double>);
-static_assert(is_same_v<quantity_point<isq::height[m], mean_sea_level>::quantity_type, quantity<isq::height[m]>>);
+static_assert(is_same_v<quantity_point<(isq::height[m]), mean_sea_level>::rep, double>);
+static_assert(is_same_v<quantity_point<(isq::height[m]), mean_sea_level>::quantity_type, quantity<isq::height[m]>>);
 
-static_assert(is_same_v<quantity_point<isq::height[m], mean_sea_level, int>::rep, int>);
+static_assert(is_same_v<quantity_point<(isq::height[m]), mean_sea_level, int>::rep, int>);
 static_assert(
-  is_same_v<quantity_point<isq::height[m], mean_sea_level, int>::quantity_type, quantity<isq::height[m], int>>);
+  is_same_v<quantity_point<(isq::height[m]), mean_sea_level, int>::quantity_type, quantity<isq::height[m], int>>);
 
 
 ////////////////////////////
@@ -371,11 +375,11 @@ static_assert(
 //////////////////////////////
 
 // there is no construction from a value
-static_assert(!std::constructible_from<quantity_point<isq::height[m], mean_sea_level>, double>);
-static_assert(!std::convertible_to<double, quantity_point<isq::height[m], mean_sea_level>>);
+static_assert(!std::constructible_from<quantity_point<(isq::height[m]), mean_sea_level>, double>);
+static_assert(!std::convertible_to<double, quantity_point<(isq::height[m]), mean_sea_level>>);
 
-static_assert(!std::constructible_from<quantity_point<isq::height[m], ground_level, int>, int>);
-static_assert(!std::convertible_to<int, quantity_point<isq::height[m], ground_level, int>>);
+static_assert(!std::constructible_from<quantity_point<(isq::height[m]), ground_level, int>, int>);
+static_assert(!std::convertible_to<int, quantity_point<(isq::height[m]), ground_level, int>>);
 
 static_assert(!std::constructible_from<quantity_point<dimensionless[percent], zero>, double>);
 static_assert(!std::convertible_to<double, quantity_point<dimensionless[percent], zero>>);
@@ -396,135 +400,135 @@ static_assert(!std::convertible_to<int, quantity_point<dimensionless[one], zero,
 // implicit zeroth point origins
 // -----------------------------
 
-static_assert(std::constructible_from<quantity_point<si::metre>, quantity<si::metre>>);
-static_assert(!std::convertible_to<quantity<si::metre>, quantity_point<si::metre>>);
+static_assert(std::constructible_from<quantity_point<(si::metre)>, quantity<(si::metre)>>);
+static_assert(!std::convertible_to<quantity<(si::metre)>, quantity_point<(si::metre)>>);
 
-static_assert(std::constructible_from<quantity_point<isq::height[m]>, quantity<isq::height[m]>>);
-static_assert(!std::convertible_to<quantity<isq::height[m]>, quantity_point<isq::height[m]>>);
+static_assert(std::constructible_from<quantity_point<(isq::height[m])>, quantity<(isq::height[m])>>);
+static_assert(!std::convertible_to<quantity<(isq::height[m])>, quantity_point<(isq::height[m])>>);
 
-static_assert(std::constructible_from<quantity_point<isq::height[m]>, quantity<si::metre>>);
-static_assert(!std::convertible_to<quantity<si::metre>, quantity_point<isq::height[m]>>);
+static_assert(std::constructible_from<quantity_point<(isq::height[m])>, quantity<(si::metre)>>);
+static_assert(!std::convertible_to<quantity<(si::metre)>, quantity_point<(isq::height[m])>>);
 
-static_assert(std::constructible_from<quantity_point<si::metre>, quantity<isq::height[m]>>);
-static_assert(!std::convertible_to<quantity<isq::height[m]>, quantity_point<si::metre>>);
+static_assert(std::constructible_from<quantity_point<(si::metre)>, quantity<(isq::height[m])>>);
+static_assert(!std::convertible_to<quantity<(isq::height[m])>, quantity_point<(si::metre)>>);
 
-static_assert(std::constructible_from<quantity_point<m / s>, quantity<isq::speed[m / s]>>);
-static_assert(!std::convertible_to<quantity<isq::speed[m / s]>, quantity_point<m / s>>);
+static_assert(std::constructible_from<quantity_point<m / s>, quantity<(isq::speed[m / s])>>);
+static_assert(!std::convertible_to<quantity<(isq::speed[m / s])>, quantity_point<m / s>>);
 
-static_assert(std::constructible_from<quantity_point<isq::speed[m / s]>, quantity<m / s>>);
-static_assert(!std::convertible_to<quantity<m / s>, quantity_point<isq::speed[m / s]>>);
+static_assert(std::constructible_from<quantity_point<(isq::speed[m / s])>, quantity<m / s>>);
+static_assert(!std::convertible_to<quantity<m / s>, quantity_point<(isq::speed[m / s])>>);
 
-static_assert(std::constructible_from<quantity_point<isq::length[m] / isq::time[s]>, quantity<isq::speed[m / s]>>);
-static_assert(!std::convertible_to<quantity<isq::speed[m / s]>, quantity_point<isq::length[m] / isq::time[s]>>);
+static_assert(std::constructible_from<quantity_point<(isq::length[m] / isq::time[s])>, quantity<(isq::speed[m / s])>>);
+static_assert(!std::convertible_to<quantity<(isq::speed[m / s])>, quantity_point<(isq::length[m] / isq::time[s])>>);
 
-static_assert(std::constructible_from<quantity_point<isq::speed[m / s]>, quantity<isq::length[m] / isq::time[s]>>);
-static_assert(!std::convertible_to<quantity<isq::length[m] / isq::time[s]>, quantity_point<isq::speed[m / s]>>);
+static_assert(std::constructible_from<quantity_point<(isq::speed[m / s])>, quantity<(isq::length[m] / isq::time[s])>>);
+static_assert(!std::convertible_to<quantity<(isq::length[m] / isq::time[s])>, quantity_point<(isq::speed[m / s])>>);
 
-static_assert(std::constructible_from<quantity_point<isq::speed[m / s]>, quantity<m / s>>);
-static_assert(!std::convertible_to<quantity<m / s>, quantity_point<isq::speed[m / s]>>);
+static_assert(std::constructible_from<quantity_point<(isq::speed[m / s])>, quantity<m / s>>);
+static_assert(!std::convertible_to<quantity<m / s>, quantity_point<(isq::speed[m / s])>>);
 
 static_assert(std::constructible_from<quantity_point<dimensionless[one]>, quantity<dimensionless[one]>>);
 static_assert(!std::convertible_to<quantity<dimensionless[one]>, quantity_point<dimensionless[one]>>);
 
 // different dimensions
-static_assert(!std::constructible_from<quantity_point<isq::height[m]>, quantity<si::second>>);
-static_assert(!std::convertible_to<quantity<si::second>, quantity_point<isq::height[m]>>);
+static_assert(!std::constructible_from<quantity_point<(isq::height[m])>, quantity<(si::second)>>);
+static_assert(!std::convertible_to<quantity<(si::second)>, quantity_point<(isq::height[m])>>);
 
 // convertible but different quantity_specs
-static_assert(std::constructible_from<quantity_point<isq::length[m]>, quantity<isq::height[m]>>);
-static_assert(!std::convertible_to<quantity<isq::height[m]>, quantity_point<isq::length[m]>>);
+static_assert(std::constructible_from<quantity_point<(isq::length[m])>, quantity<(isq::height[m])>>);
+static_assert(!std::convertible_to<quantity<(isq::height[m])>, quantity_point<(isq::length[m])>>);
 
-static_assert(std::constructible_from<quantity_point<isq::height[m]>, quantity<special_height[m]>>);
-static_assert(!std::convertible_to<quantity<special_height[m]>, quantity_point<isq::height[m]>>);
+static_assert(std::constructible_from<quantity_point<(isq::height[m])>, quantity<(special_height[m])>>);
+static_assert(!std::convertible_to<quantity<(special_height[m])>, quantity_point<(isq::height[m])>>);
 
 // quantity_specs with common_quantity_spec
-static_assert(!std::constructible_from<quantity_point<isq::width[m]>, quantity<isq::height[m]>>);
-static_assert(!std::convertible_to<quantity<isq::height[m]>, quantity_point<isq::width[m]>>);
+static_assert(!std::constructible_from<quantity_point<(isq::width[m])>, quantity<(isq::height[m])>>);
+static_assert(!std::convertible_to<quantity<(isq::height[m])>, quantity_point<(isq::width[m])>>);
 
-static_assert(!std::constructible_from<quantity_point<isq::height[m]>, quantity<isq::width[m]>>);
-static_assert(!std::convertible_to<quantity<isq::width[m]>, quantity_point<isq::height[m]>>);
+static_assert(!std::constructible_from<quantity_point<(isq::height[m])>, quantity<(isq::width[m])>>);
+static_assert(!std::convertible_to<quantity<(isq::width[m])>, quantity_point<(isq::height[m])>>);
 
 // non-convertible quantity_specs
-static_assert(!std::constructible_from<quantity_point<isq::height[m]>, quantity<isq::length[m]>>);
-static_assert(!std::convertible_to<quantity<isq::length[m]>, quantity_point<isq::height[m]>>);
+static_assert(!std::constructible_from<quantity_point<(isq::height[m])>, quantity<(isq::length[m])>>);
+static_assert(!std::convertible_to<quantity<(isq::length[m])>, quantity_point<(isq::height[m])>>);
 
-static_assert(!std::constructible_from<quantity_point<special_height[m]>, quantity<isq::height[m]>>);
-static_assert(!std::convertible_to<quantity<special_height[m]>, quantity_point<isq::height[m]>>);
+static_assert(!std::constructible_from<quantity_point<special_height[m]>, quantity<(isq::height[m])>>);
+static_assert(!std::convertible_to<quantity<special_height[m]>, quantity_point<(isq::height[m])>>);
 
 #if MP_UNITS_HOSTED
 // quantity-like
-static_assert(!std::constructible_from<quantity_point<si::second>, std::chrono::seconds>);
-static_assert(!std::convertible_to<std::chrono::seconds, quantity_point<si::second>>);
+static_assert(!std::constructible_from<quantity_point<(si::second)>, std::chrono::seconds>);
+static_assert(!std::convertible_to<std::chrono::seconds, quantity_point<(si::second)>>);
 
-static_assert(!std::constructible_from<quantity_point<isq::time[s]>, std::chrono::seconds>);
-static_assert(!std::convertible_to<std::chrono::seconds, quantity_point<isq::time[s]>>);
+static_assert(!std::constructible_from<quantity_point<(isq::time[s])>, std::chrono::seconds>);
+static_assert(!std::convertible_to<std::chrono::seconds, quantity_point<(isq::time[s])>>);
 
-static_assert(!std::constructible_from<quantity_point<isq::period_duration[s]>, std::chrono::seconds>);
-static_assert(!std::convertible_to<std::chrono::seconds, quantity_point<isq::period_duration[s]>>);
+static_assert(!std::constructible_from<quantity_point<(isq::period_duration[s])>, std::chrono::seconds>);
+static_assert(!std::convertible_to<std::chrono::seconds, quantity_point<(isq::period_duration[s])>>);
 #endif
 
 // ----------------------
 // explicit point origins
 // ----------------------
 
-static_assert(!std::constructible_from<quantity_point<si::metre, mean_sea_level>, quantity<si::metre>>);
-static_assert(!std::convertible_to<quantity<si::metre>, quantity_point<si::metre, mean_sea_level>>);
+static_assert(!std::constructible_from<quantity_point<(si::metre), mean_sea_level>, quantity<(si::metre)>>);
+static_assert(!std::convertible_to<quantity<(si::metre)>, quantity_point<(si::metre), mean_sea_level>>);
 
-static_assert(!std::constructible_from<quantity_point<isq::height[m], mean_sea_level>, quantity<isq::height[m]>>);
-static_assert(!std::convertible_to<quantity<isq::height[m]>, quantity_point<isq::height[m], mean_sea_level>>);
+static_assert(!std::constructible_from<quantity_point<(isq::height[m]), mean_sea_level>, quantity<(isq::height[m])>>);
+static_assert(!std::convertible_to<quantity<(isq::height[m])>, quantity_point<(isq::height[m]), mean_sea_level>>);
 
-static_assert(!std::constructible_from<quantity_point<isq::height[m], mean_sea_level>, quantity<si::metre>>);
-static_assert(!std::convertible_to<quantity<si::metre>, quantity_point<isq::height[m], mean_sea_level>>);
+static_assert(!std::constructible_from<quantity_point<(isq::height[m]), mean_sea_level>, quantity<(si::metre)>>);
+static_assert(!std::convertible_to<quantity<(si::metre)>, quantity_point<(isq::height[m]), mean_sea_level>>);
 
-static_assert(!std::constructible_from<quantity_point<si::metre, mean_sea_level>, quantity<isq::height[m]>>);
-static_assert(!std::convertible_to<quantity<isq::height[m]>, quantity_point<si::metre, mean_sea_level>>);
+static_assert(!std::constructible_from<quantity_point<(si::metre), mean_sea_level>, quantity<(isq::height[m])>>);
+static_assert(!std::convertible_to<quantity<(isq::height[m])>, quantity_point<(si::metre), mean_sea_level>>);
 
-static_assert(!std::constructible_from<quantity_point<isq::height[m], mean_sea_level>, quantity<special_height[m]>>);
-static_assert(!std::convertible_to<quantity<special_height[m]>, quantity_point<isq::height[m], mean_sea_level>>);
+static_assert(!std::constructible_from<quantity_point<(isq::height[m]), mean_sea_level>, quantity<special_height[m]>>);
+static_assert(!std::convertible_to<quantity<special_height[m]>, quantity_point<(isq::height[m]), mean_sea_level>>);
 
 static_assert(!std::constructible_from<quantity_point<dimensionless[one], zero>, quantity<dimensionless[one]>>);
 static_assert(!std::convertible_to<quantity<dimensionless[one]>, quantity_point<dimensionless[one], zero>>);
 
 // quantity_specs with common_quantity_spec
-static_assert(!std::constructible_from<quantity_point<isq::width[m], zeroth_length>, quantity<isq::height[m]>>);
-static_assert(!std::convertible_to<quantity<isq::height[m]>, quantity_point<isq::width[m], zeroth_length>>);
+static_assert(!std::constructible_from<quantity_point<(isq::width[m]), zeroth_length>, quantity<(isq::height[m])>>);
+static_assert(!std::convertible_to<quantity<(isq::height[m])>, quantity_point<(isq::width[m]), zeroth_length>>);
 
-static_assert(!std::constructible_from<quantity_point<isq::height[m], zeroth_length>, quantity<isq::width[m]>>);
-static_assert(!std::convertible_to<quantity<isq::width[m]>, quantity_point<isq::height[m], zeroth_length>>);
+static_assert(!std::constructible_from<quantity_point<(isq::height[m]), zeroth_length>, quantity<(isq::width[m])>>);
+static_assert(!std::convertible_to<quantity<(isq::width[m])>, quantity_point<(isq::height[m]), zeroth_length>>);
 
 // different dimensions
-static_assert(!std::constructible_from<quantity_point<isq::height[m], mean_sea_level>, quantity<si::second>>);
-static_assert(!std::convertible_to<quantity<si::second>, quantity_point<isq::height[m], mean_sea_level>>);
+static_assert(!std::constructible_from<quantity_point<(isq::height[m]), mean_sea_level>, quantity<(si::second)>>);
+static_assert(!std::convertible_to<quantity<(si::second)>, quantity_point<(isq::height[m]), mean_sea_level>>);
 
 // non-convertible quantity_specs
-static_assert(!std::constructible_from<quantity_point<isq::height[m], mean_sea_level>, quantity<isq::length[m]>>);
-static_assert(!std::convertible_to<quantity<isq::length[m]>, quantity_point<isq::height[m], mean_sea_level>>);
+static_assert(!std::constructible_from<quantity_point<(isq::height[m]), mean_sea_level>, quantity<(isq::length[m])>>);
+static_assert(!std::convertible_to<quantity<(isq::length[m])>, quantity_point<(isq::height[m]), mean_sea_level>>);
 
-static_assert(!std::constructible_from<quantity_point<special_height[m], mean_sea_level>, quantity<isq::height[m]>>);
-static_assert(!std::convertible_to<quantity<special_height[m]>, quantity_point<isq::height[m], mean_sea_level>>);
+static_assert(!std::constructible_from<quantity_point<special_height[m], mean_sea_level>, quantity<(isq::height[m])>>);
+static_assert(!std::convertible_to<quantity<special_height[m]>, quantity_point<(isq::height[m]), mean_sea_level>>);
 
 // not-compatible origin
-static_assert(!std::constructible_from<quantity_point<si::metre, mean_sea_level>, quantity<isq::length[m]>>);
-static_assert(!std::convertible_to<quantity<isq::length[m]>, quantity_point<si::metre, mean_sea_level>>);
+static_assert(!std::constructible_from<quantity_point<((si::metre)), mean_sea_level>, quantity<(isq::length[m])>>);
+static_assert(!std::convertible_to<quantity<(isq::length[m])>, quantity_point<((si::metre)), mean_sea_level>>);
 
 #if MP_UNITS_HOSTED
 // quantity-like
-static_assert(!std::constructible_from<quantity_point<si::second, chrono_point_origin<std::chrono::system_clock>>,
+static_assert(!std::constructible_from<quantity_point<(si::second), chrono_point_origin<std::chrono::system_clock>>,
                                        std::chrono::seconds>);
 static_assert(!std::convertible_to<std::chrono::seconds,
-                                   quantity_point<si::second, chrono_point_origin<std::chrono::system_clock>>>);
+                                   quantity_point<(si::second), chrono_point_origin<std::chrono::system_clock>>>);
 
-static_assert(!std::constructible_from<quantity_point<isq::time[s], chrono_point_origin<std::chrono::system_clock>>,
+static_assert(!std::constructible_from<quantity_point<(isq::time[s]), chrono_point_origin<std::chrono::system_clock>>,
                                        std::chrono::seconds>);
 static_assert(!std::convertible_to<std::chrono::seconds,
-                                   quantity_point<isq::time[s], chrono_point_origin<std::chrono::system_clock>>>);
+                                   quantity_point<(isq::time[s]), chrono_point_origin<std::chrono::system_clock>>>);
 
 static_assert(
-  !std::constructible_from<quantity_point<isq::period_duration[s], chrono_point_origin<std::chrono::system_clock>>,
+  !std::constructible_from<quantity_point<(isq::period_duration[s]), chrono_point_origin<std::chrono::system_clock>>,
                            std::chrono::seconds>);
 static_assert(
   !std::convertible_to<std::chrono::seconds,
-                       quantity_point<isq::period_duration[s], chrono_point_origin<std::chrono::system_clock>>>);
+                       quantity_point<(isq::period_duration[s]), chrono_point_origin<std::chrono::system_clock>>>);
 #endif
 
 
@@ -533,140 +537,146 @@ static_assert(
 ///////////////////////////////////////
 
 // implicit origin
-static_assert(std::constructible_from<quantity_point<si::metre>, quantity_point<si::metre>>);
-static_assert(std::convertible_to<quantity_point<si::metre>, quantity_point<si::metre>>);
-static_assert(std::constructible_from<quantity_point<isq::height[m]>, quantity_point<isq::height[m]>>);
-static_assert(std::convertible_to<quantity_point<isq::height[m]>, quantity_point<isq::height[m]>>);
+static_assert(std::constructible_from<quantity_point<(si::metre)>, quantity_point<(si::metre)>>);
+static_assert(std::convertible_to<quantity_point<(si::metre)>, quantity_point<(si::metre)>>);
+static_assert(std::constructible_from<quantity_point<(isq::height[m])>, quantity_point<(isq::height[m])>>);
+static_assert(std::convertible_to<quantity_point<(isq::height[m])>, quantity_point<(isq::height[m])>>);
 
-static_assert(std::constructible_from<quantity_point<si::metre>, quantity_point<isq::height[m]>>);
-static_assert(std::convertible_to<quantity_point<isq::height[m]>, quantity_point<si::metre>>);
-static_assert(std::constructible_from<quantity_point<isq::height[m]>, quantity_point<si::metre>>);
-static_assert(std::convertible_to<quantity_point<si::metre>, quantity_point<isq::height[m]>>);
+static_assert(std::constructible_from<quantity_point<(si::metre)>, quantity_point<(isq::height[m])>>);
+static_assert(std::convertible_to<quantity_point<(isq::height[m])>, quantity_point<(si::metre)>>);
+static_assert(std::constructible_from<quantity_point<(isq::height[m])>, quantity_point<(si::metre)>>);
+static_assert(std::convertible_to<quantity_point<(si::metre)>, quantity_point<(isq::height[m])>>);
 
 static_assert(
-  std::constructible_from<quantity_point<isq::length[m] / isq::time[s]>, quantity_point<isq::speed[m / s]>>);
-static_assert(std::convertible_to<quantity_point<isq::speed[m / s]>, quantity_point<isq::length[m] / isq::time[s]>>);
+  std::constructible_from<quantity_point<(isq::length[m]) / isq::time[s]>, quantity_point<(isq::speed[m / s])>>);
+static_assert(
+  std::convertible_to<quantity_point<(isq::speed[m / s])>, quantity_point<(isq::length[m]) / isq::time[s]>>);
 
-static_assert(std::constructible_from<quantity_point<m / s>, quantity_point<isq::speed[m / s]>>);
-static_assert(std::convertible_to<quantity_point<isq::speed[m / s]>, quantity_point<m / s>>);
+static_assert(std::constructible_from<quantity_point<m / s>, quantity_point<(isq::speed[m / s])>>);
+static_assert(std::convertible_to<quantity_point<(isq::speed[m / s])>, quantity_point<m / s>>);
 
-static_assert(std::constructible_from<quantity_point<m / s>, quantity_point<isq::length[m] / isq::time[s]>>);
-static_assert(std::convertible_to<quantity_point<isq::length[m] / isq::time[s]>, quantity_point<m / s>>);
+static_assert(std::constructible_from<quantity_point<m / s>, quantity_point<(isq::length[m]) / isq::time[s]>>);
+static_assert(std::convertible_to<quantity_point<(isq::length[m]) / isq::time[s]>, quantity_point<m / s>>);
 
 // convertible but different quantity_specs
-static_assert(!std::constructible_from<quantity_point<isq::length[m]>, quantity_point<isq::height[m]>>);
-static_assert(!std::convertible_to<quantity_point<isq::height[m]>, quantity_point<isq::length[m]>>);
+static_assert(!std::constructible_from<quantity_point<(isq::length[m])>, quantity_point<(isq::height[m])>>);
+static_assert(!std::convertible_to<quantity_point<(isq::height[m])>, quantity_point<(isq::length[m])>>);
 
-static_assert(!std::constructible_from<quantity_point<isq::height[m]>, quantity_point<special_height[m]>>);
-static_assert(!std::convertible_to<quantity_point<special_height[m]>, quantity_point<isq::height[m]>>);
+static_assert(!std::constructible_from<quantity_point<(isq::height[m])>, quantity_point<special_height[m]>>);
+static_assert(!std::convertible_to<quantity_point<special_height[m]>, quantity_point<(isq::height[m])>>);
 
 // quantity_specs with common_quantity_spec
-static_assert(!std::constructible_from<quantity_point<isq::width[m]>, quantity_point<isq::height[m]>>);
-static_assert(!std::convertible_to<quantity_point<isq::height[m]>, quantity_point<isq::width[m]>>);
+static_assert(!std::constructible_from<quantity_point<(isq::width[m])>, quantity_point<(isq::height[m])>>);
+static_assert(!std::convertible_to<quantity_point<(isq::height[m])>, quantity_point<(isq::width[m])>>);
 
-static_assert(!std::constructible_from<quantity_point<isq::height[m]>, quantity_point<isq::width[m]>>);
-static_assert(!std::convertible_to<quantity_point<isq::width[m]>, quantity_point<isq::height[m]>>);
+static_assert(!std::constructible_from<quantity_point<(isq::height[m])>, quantity_point<(isq::width[m])>>);
+static_assert(!std::convertible_to<quantity_point<(isq::width[m])>, quantity_point<(isq::height[m])>>);
 
 // non-convertible quantity_specs
-static_assert(!std::constructible_from<quantity_point<isq::height[m]>, quantity_point<isq::length[m]>>);
-static_assert(!std::convertible_to<quantity_point<isq::length[m]>, quantity_point<isq::height[m]>>);
+static_assert(!std::constructible_from<quantity_point<(isq::height[m])>, quantity_point<(isq::length[m])>>);
+static_assert(!std::convertible_to<quantity_point<(isq::length[m])>, quantity_point<(isq::height[m])>>);
 
-static_assert(!std::constructible_from<quantity_point<special_height[m]>, quantity_point<isq::height[m]>>);
-static_assert(!std::convertible_to<quantity_point<isq::height[m]>, quantity_point<special_height[m]>>);
+static_assert(!std::constructible_from<quantity_point<special_height[m]>, quantity_point<(isq::height[m])>>);
+static_assert(!std::convertible_to<quantity_point<(isq::height[m])>, quantity_point<special_height[m]>>);
 
 // mixed origins
-static_assert(!std::constructible_from<quantity_point<si::metre, mean_sea_level>, quantity_point<si::metre>>);
-static_assert(!std::convertible_to<quantity_point<si::metre>, quantity_point<si::metre, mean_sea_level>>);
-static_assert(!std::constructible_from<quantity_point<isq::height[m], mean_sea_level>, quantity_point<isq::height[m]>>);
-static_assert(!std::convertible_to<quantity_point<isq::height[m]>, quantity_point<isq::height[m], mean_sea_level>>);
+static_assert(!std::constructible_from<quantity_point<(si::metre), mean_sea_level>, quantity_point<(si::metre)>>);
+static_assert(!std::convertible_to<quantity_point<(si::metre)>, quantity_point<(si::metre), mean_sea_level>>);
+static_assert(
+  !std::constructible_from<quantity_point<(isq::height[m]), mean_sea_level>, quantity_point<(isq::height[m])>>);
+static_assert(!std::convertible_to<quantity_point<(isq::height[m])>, quantity_point<(isq::height[m]), mean_sea_level>>);
 
-static_assert(!std::constructible_from<quantity_point<si::metre>, quantity_point<si::metre, mean_sea_level>>);
-static_assert(!std::convertible_to<quantity_point<si::metre, mean_sea_level>, quantity_point<si::metre>>);
-static_assert(!std::constructible_from<quantity_point<isq::height[m]>, quantity_point<isq::height[m], mean_sea_level>>);
-static_assert(!std::convertible_to<quantity_point<isq::height[m], mean_sea_level>, quantity_point<isq::height[m]>>);
+static_assert(!std::constructible_from<quantity_point<(si::metre)>, quantity_point<(si::metre), mean_sea_level>>);
+static_assert(!std::convertible_to<quantity_point<(si::metre), mean_sea_level>, quantity_point<(si::metre)>>);
+static_assert(
+  !std::constructible_from<quantity_point<(isq::height[m])>, quantity_point<(isq::height[m]), mean_sea_level>>);
+static_assert(!std::convertible_to<quantity_point<(isq::height[m]), mean_sea_level>, quantity_point<(isq::height[m])>>);
 
 // same explicit origins
 static_assert(
-  std::constructible_from<quantity_point<si::metre, mean_sea_level>, quantity_point<si::metre, mean_sea_level>>);
+  std::constructible_from<quantity_point<(si::metre), mean_sea_level>, quantity_point<(si::metre), mean_sea_level>>);
 static_assert(
-  std::convertible_to<quantity_point<si::metre, mean_sea_level>, quantity_point<si::metre, mean_sea_level>>);
+  std::convertible_to<quantity_point<(si::metre), mean_sea_level>, quantity_point<(si::metre), mean_sea_level>>);
 
-static_assert(std::constructible_from<quantity_point<isq::height[m], mean_sea_level>,
-                                      quantity_point<isq::height[m], mean_sea_level>>);
-static_assert(
-  std::convertible_to<quantity_point<isq::height[m], mean_sea_level>, quantity_point<isq::height[m], mean_sea_level>>);
+static_assert(std::constructible_from<quantity_point<(isq::height[m]), mean_sea_level>,
+                                      quantity_point<(isq::height[m]), mean_sea_level>>);
+static_assert(std::convertible_to<quantity_point<(isq::height[m]), mean_sea_level>,
+                                  quantity_point<(isq::height[m]), mean_sea_level>>);
 
-static_assert(std::constructible_from<quantity_point<isq::height[km], mean_sea_level>,
-                                      quantity_point<isq::height[m], mean_sea_level>>);
-static_assert(
-  std::convertible_to<quantity_point<isq::height[m], mean_sea_level>, quantity_point<isq::height[km], mean_sea_level>>);
+static_assert(std::constructible_from<quantity_point<(isq::height[km]), mean_sea_level>,
+                                      quantity_point<(isq::height[m]), mean_sea_level>>);
+static_assert(std::convertible_to<quantity_point<(isq::height[m]), mean_sea_level>,
+                                  quantity_point<(isq::height[km]), mean_sea_level>>);
 
-static_assert(std::constructible_from<quantity_point<isq::height[m], mean_sea_level>,
-                                      quantity_point<isq::height[km], mean_sea_level>>);
-static_assert(
-  std::convertible_to<quantity_point<isq::height[km], mean_sea_level>, quantity_point<isq::height[m], mean_sea_level>>);
+static_assert(std::constructible_from<quantity_point<(isq::height[m]), mean_sea_level>,
+                                      quantity_point<(isq::height[km]), mean_sea_level>>);
+static_assert(std::convertible_to<quantity_point<(isq::height[km]), mean_sea_level>,
+                                  quantity_point<(isq::height[m]), mean_sea_level>>);
 
+static_assert(std::constructible_from<quantity_point<(si::metre), mean_sea_level>,
+                                      quantity_point<(isq::height[m]), mean_sea_level>>);
 static_assert(
-  std::constructible_from<quantity_point<si::metre, mean_sea_level>, quantity_point<isq::height[m], mean_sea_level>>);
-static_assert(
-  std::convertible_to<quantity_point<isq::height[m], mean_sea_level>, quantity_point<si::metre, mean_sea_level>>);
+  std::convertible_to<quantity_point<(isq::height[m]), mean_sea_level>, quantity_point<(si::metre), mean_sea_level>>);
 
+static_assert(std::constructible_from<quantity_point<(isq::height[m]), mean_sea_level>,
+                                      quantity_point<(si::metre), mean_sea_level>>);
 static_assert(
-  std::constructible_from<quantity_point<isq::height[m], mean_sea_level>, quantity_point<si::metre, mean_sea_level>>);
-static_assert(
-  std::convertible_to<quantity_point<si::metre, mean_sea_level>, quantity_point<isq::height[m], mean_sea_level>>);
+  std::convertible_to<quantity_point<(si::metre), mean_sea_level>, quantity_point<(isq::height[m]), mean_sea_level>>);
 
-static_assert(std::constructible_from<quantity_point<isq::height[m], mean_sea_level>,
+static_assert(std::constructible_from<quantity_point<(isq::height[m]), mean_sea_level>,
                                       quantity_point<special_height[m], mean_sea_level>>);
 static_assert(std::convertible_to<quantity_point<special_height[m], mean_sea_level>,
-                                  quantity_point<isq::height[m], mean_sea_level>>);
+                                  quantity_point<(isq::height[m]), mean_sea_level>>);
 
 static_assert(
-  std::constructible_from<quantity_point<si::metre, ground_level>, quantity_point<si::metre, ground_level>>);
-static_assert(std::convertible_to<quantity_point<si::metre, ground_level>, quantity_point<si::metre, ground_level>>);
+  std::constructible_from<quantity_point<(si::metre), ground_level>, quantity_point<(si::metre), ground_level>>);
+static_assert(
+  std::convertible_to<quantity_point<(si::metre), ground_level>, quantity_point<(si::metre), ground_level>>);
+
+static_assert(std::constructible_from<quantity_point<(isq::height[m]), ground_level>,
+                                      quantity_point<(isq::height[m]), ground_level>>);
+static_assert(
+  std::convertible_to<quantity_point<(isq::height[m]), ground_level>, quantity_point<(isq::height[m]), ground_level>>);
+
+static_assert(std::constructible_from<quantity_point<(isq::height[km]), ground_level>,
+                                      quantity_point<(isq::height[m]), mean_sea_level>>);
+static_assert(std::convertible_to<quantity_point<(isq::height[m]), ground_level>,
+                                  quantity_point<(isq::height[km]), mean_sea_level>>);
+
+static_assert(std::constructible_from<quantity_point<(isq::height[m]), ground_level>,
+                                      quantity_point<(isq::height[km]), ground_level>>);
+static_assert(
+  std::convertible_to<quantity_point<(isq::height[km]), ground_level>, quantity_point<(isq::height[m]), ground_level>>);
 
 static_assert(
-  std::constructible_from<quantity_point<isq::height[m], ground_level>, quantity_point<isq::height[m], ground_level>>);
+  std::constructible_from<quantity_point<(si::metre), ground_level>, quantity_point<(isq::height[m]), ground_level>>);
 static_assert(
-  std::convertible_to<quantity_point<isq::height[m], ground_level>, quantity_point<isq::height[m], ground_level>>);
-
-static_assert(std::constructible_from<quantity_point<isq::height[km], ground_level>,
-                                      quantity_point<isq::height[m], mean_sea_level>>);
-static_assert(
-  std::convertible_to<quantity_point<isq::height[m], ground_level>, quantity_point<isq::height[km], mean_sea_level>>);
+  std::convertible_to<quantity_point<(isq::height[m]), ground_level>, quantity_point<(si::metre), ground_level>>);
 
 static_assert(
-  std::constructible_from<quantity_point<isq::height[m], ground_level>, quantity_point<isq::height[km], ground_level>>);
+  std::constructible_from<quantity_point<(isq::height[m]), ground_level>, quantity_point<(si::metre), ground_level>>);
 static_assert(
-  std::convertible_to<quantity_point<isq::height[km], ground_level>, quantity_point<isq::height[m], ground_level>>);
+  std::convertible_to<quantity_point<(si::metre), ground_level>, quantity_point<(isq::height[m]), ground_level>>);
 
-static_assert(
-  std::constructible_from<quantity_point<si::metre, ground_level>, quantity_point<isq::height[m], ground_level>>);
-static_assert(
-  std::convertible_to<quantity_point<isq::height[m], ground_level>, quantity_point<si::metre, ground_level>>);
-
-static_assert(
-  std::constructible_from<quantity_point<isq::height[m], ground_level>, quantity_point<si::metre, ground_level>>);
-static_assert(
-  std::convertible_to<quantity_point<si::metre, ground_level>, quantity_point<isq::height[m], ground_level>>);
-
-static_assert(std::constructible_from<quantity_point<isq::height[m], ground_level>,
+static_assert(std::constructible_from<quantity_point<(isq::height[m]), ground_level>,
                                       quantity_point<special_height[m], ground_level>>);
 static_assert(
-  std::convertible_to<quantity_point<special_height[m], ground_level>, quantity_point<isq::height[m], ground_level>>);
+  std::convertible_to<quantity_point<special_height[m], ground_level>, quantity_point<(isq::height[m]), ground_level>>);
 
 static_assert(
-  std::constructible_from<quantity_point<si::metre, mean_sea_level>, quantity_point<si::metre, ground_level>>);
-static_assert(std::convertible_to<quantity_point<si::metre, ground_level>, quantity_point<si::metre, mean_sea_level>>);
+  std::constructible_from<quantity_point<(si::metre), mean_sea_level>, quantity_point<(si::metre), ground_level>>);
+static_assert(
+  std::convertible_to<quantity_point<(si::metre), ground_level>, quantity_point<(si::metre), mean_sea_level>>);
 
 static_assert(
-  std::constructible_from<quantity_point<si::metre, ground_level>, quantity_point<si::metre, mean_sea_level>>);
-static_assert(std::convertible_to<quantity_point<si::metre, mean_sea_level>, quantity_point<si::metre, ground_level>>);
+  std::constructible_from<quantity_point<(si::metre), ground_level>, quantity_point<(si::metre), mean_sea_level>>);
+static_assert(
+  std::convertible_to<quantity_point<(si::metre), mean_sea_level>, quantity_point<(si::metre), ground_level>>);
 
 static_assert(
-  std::constructible_from<quantity_point<si::metre, ground_level>, quantity_point<si::metre, other_ground_level>>);
+  std::constructible_from<quantity_point<(si::metre), ground_level>, quantity_point<(si::metre), other_ground_level>>);
 static_assert(
-  std::convertible_to<quantity_point<si::metre, other_ground_level>, quantity_point<si::metre, ground_level>>);
+  std::convertible_to<quantity_point<(si::metre), other_ground_level>, quantity_point<(si::metre), ground_level>>);
 
 static_assert(
   std::constructible_from<quantity_point<dimensionless[one], zero>, quantity_point<dimensionless[one], zero>>);
@@ -682,121 +692,121 @@ static_assert(
 static_assert(
   std::convertible_to<quantity_point<dimensionless[one], zero>, quantity_point<dimensionless[percent], zero>>);
 
-static_assert(std::constructible_from<quantity_point<isq::length[m], zeroth_length>,
-                                      quantity_point<isq::height[m], zeroth_length>>);
-static_assert(
-  std::convertible_to<quantity_point<isq::height[m], zeroth_length>, quantity_point<isq::length[m], zeroth_length>>);
+static_assert(std::constructible_from<quantity_point<(isq::length[m]), zeroth_length>,
+                                      quantity_point<(isq::height[m]), zeroth_length>>);
+static_assert(std::convertible_to<quantity_point<(isq::height[m]), zeroth_length>,
+                                  quantity_point<(isq::length[m]), zeroth_length>>);
 
 // quantity_specs with common_quantity_spec
-static_assert(!std::constructible_from<quantity_point<isq::width[m], zeroth_length>,
-                                       quantity_point<isq::height[m], zeroth_length>>);
-static_assert(
-  !std::convertible_to<quantity_point<isq::height[m], zeroth_length>, quantity_point<isq::width[m], zeroth_length>>);
+static_assert(!std::constructible_from<quantity_point<(isq::width[m]), zeroth_length>,
+                                       quantity_point<(isq::height[m]), zeroth_length>>);
+static_assert(!std::convertible_to<quantity_point<(isq::height[m]), zeroth_length>,
+                                   quantity_point<(isq::width[m]), zeroth_length>>);
 
-static_assert(!std::constructible_from<quantity_point<isq::height[m], zeroth_length>,
-                                       quantity_point<isq::width[m], zeroth_length>>);
-static_assert(
-  !std::convertible_to<quantity_point<isq::width[m], zeroth_length>, quantity_point<isq::height[m], zeroth_length>>);
+static_assert(!std::constructible_from<quantity_point<(isq::height[m]), zeroth_length>,
+                                       quantity_point<(isq::width[m]), zeroth_length>>);
+static_assert(!std::convertible_to<quantity_point<(isq::width[m]), zeroth_length>,
+                                   quantity_point<(isq::height[m]), zeroth_length>>);
 
 // different dimensions
-static_assert(
-  !std::constructible_from<quantity_point<isq::height[m], mean_sea_level>, quantity_point<si::kelvin, si::ice_point>>);
-static_assert(
-  !std::convertible_to<quantity_point<si::kelvin, si::ice_point>, quantity_point<isq::height[m], mean_sea_level>>);
+static_assert(!std::constructible_from<quantity_point<(isq::height[m]), mean_sea_level>,
+                                       quantity_point<(si::kelvin), (si::ice_point)>>);
+static_assert(!std::convertible_to<quantity_point<(si::kelvin), (si::ice_point)>,
+                                   quantity_point<(isq::height[m]), mean_sea_level>>);
 
 // non-convertible quantity_specs
 static_assert(!std::constructible_from<quantity_point<special_height[m], mean_sea_level>,
-                                       quantity_point<isq::height[m], mean_sea_level>>);
-static_assert(!std::convertible_to<quantity_point<isq::height[m], mean_sea_level>,
+                                       quantity_point<(isq::height[m]), mean_sea_level>>);
+static_assert(!std::convertible_to<quantity_point<(isq::height[m]), mean_sea_level>,
                                    quantity_point<special_height[m], mean_sea_level>>);
 
 // implicit conversion from another quantity point only if non-truncating
 // int -> double OK
-static_assert(std::constructible_from<quantity_point<isq::height[m], mean_sea_level>,
-                                      quantity_point<isq::height[m], mean_sea_level, int>>);
-static_assert(std::convertible_to<quantity_point<isq::height[m], mean_sea_level, int>,
-                                  quantity_point<isq::height[m], mean_sea_level>>);
+static_assert(std::constructible_from<quantity_point<(isq::height[m]), mean_sea_level>,
+                                      quantity_point<(isq::height[m]), mean_sea_level, int>>);
+static_assert(std::convertible_to<quantity_point<(isq::height[m]), mean_sea_level, int>,
+                                  quantity_point<(isq::height[m]), mean_sea_level>>);
 
 // truncating double -> int not allowed
-static_assert(!std::constructible_from<quantity_point<isq::height[m], mean_sea_level, int>,
-                                       quantity_point<isq::height[m], mean_sea_level>>);
-static_assert(!std::convertible_to<quantity_point<isq::height[m], mean_sea_level>,
-                                   quantity_point<isq::height[m], mean_sea_level, int>>);
+static_assert(!std::constructible_from<quantity_point<(isq::height[m]), mean_sea_level, int>,
+                                       quantity_point<(isq::height[m]), mean_sea_level>>);
+static_assert(!std::convertible_to<quantity_point<(isq::height[m]), mean_sea_level>,
+                                   quantity_point<(isq::height[m]), mean_sea_level, int>>);
 
 // kilometre<int> -> metre<int> OK
-static_assert(std::constructible_from<quantity_point<isq::height[m], mean_sea_level, int>,
-                                      quantity_point<isq::height[km], mean_sea_level, int>>);
-static_assert(std::convertible_to<quantity_point<isq::height[km], mean_sea_level, int>,
-                                  quantity_point<isq::height[m], mean_sea_level, int>>);
+static_assert(std::constructible_from<quantity_point<(isq::height[m]), mean_sea_level, int>,
+                                      quantity_point<(isq::height[km]), mean_sea_level, int>>);
+static_assert(std::convertible_to<quantity_point<(isq::height[km]), mean_sea_level, int>,
+                                  quantity_point<(isq::height[m]), mean_sea_level, int>>);
 
 // truncating metre<int> -> kilometre<int> not allowed
-static_assert(!std::constructible_from<quantity_point<isq::height[km], mean_sea_level, int>,
-                                       quantity_point<isq::height[m], mean_sea_level, int>>);
-static_assert(!std::convertible_to<quantity_point<isq::height[m], mean_sea_level, int>,
-                                   quantity_point<isq::height[km], mean_sea_level, int>>);
+static_assert(!std::constructible_from<quantity_point<(isq::height[km]), mean_sea_level, int>,
+                                       quantity_point<(isq::height[m]), mean_sea_level, int>>);
+static_assert(!std::convertible_to<quantity_point<(isq::height[m]), mean_sea_level, int>,
+                                   quantity_point<(isq::height[km]), mean_sea_level, int>>);
 
 // converting to double always OK
-static_assert(std::constructible_from<quantity_point<isq::height[m], mean_sea_level>,
-                                      quantity_point<isq::height[km], mean_sea_level, int>>);
-static_assert(std::convertible_to<quantity_point<isq::height[km], mean_sea_level, int>,
-                                  quantity_point<isq::height[m], mean_sea_level>>);
-static_assert(std::constructible_from<quantity_point<isq::height[km], mean_sea_level>,
-                                      quantity_point<isq::height[m], mean_sea_level, int>>);
-static_assert(std::convertible_to<quantity_point<isq::height[m], mean_sea_level, int>,
-                                  quantity_point<isq::height[km], mean_sea_level>>);
+static_assert(std::constructible_from<quantity_point<(isq::height[m]), mean_sea_level>,
+                                      quantity_point<(isq::height[km]), mean_sea_level, int>>);
+static_assert(std::convertible_to<quantity_point<(isq::height[km]), mean_sea_level, int>,
+                                  quantity_point<(isq::height[m]), mean_sea_level>>);
+static_assert(std::constructible_from<quantity_point<(isq::height[km]), mean_sea_level>,
+                                      quantity_point<(isq::height[m]), mean_sea_level, int>>);
+static_assert(std::convertible_to<quantity_point<(isq::height[m]), mean_sea_level, int>,
+                                  quantity_point<(isq::height[km]), mean_sea_level>>);
 
 // same but not a default origin
-static_assert(std::constructible_from<quantity_point<isq::height[m], mean_sea_level>,
-                                      quantity_point<isq::height[m], mean_sea_level>>);
-static_assert(
-  std::convertible_to<quantity_point<isq::height[m], mean_sea_level>, quantity_point<isq::height[m], mean_sea_level>>);
+static_assert(std::constructible_from<quantity_point<(isq::height[m]), mean_sea_level>,
+                                      quantity_point<(isq::height[m]), mean_sea_level>>);
+static_assert(std::convertible_to<quantity_point<(isq::height[m]), mean_sea_level>,
+                                  quantity_point<(isq::height[m]), mean_sea_level>>);
 
+static_assert(std::constructible_from<quantity_point<(si::metre), mean_sea_level>,
+                                      quantity_point<(isq::height[m]), mean_sea_level>>);
 static_assert(
-  std::constructible_from<quantity_point<si::metre, mean_sea_level>, quantity_point<isq::height[m], mean_sea_level>>);
-static_assert(
-  std::convertible_to<quantity_point<isq::height[m], mean_sea_level>, quantity_point<si::metre, mean_sea_level>>);
+  std::convertible_to<quantity_point<(isq::height[m]), mean_sea_level>, quantity_point<(si::metre), mean_sea_level>>);
 
+static_assert(std::constructible_from<quantity_point<(isq::height[m]), mean_sea_level>,
+                                      quantity_point<(si::metre), mean_sea_level>>);
 static_assert(
-  std::constructible_from<quantity_point<isq::height[m], mean_sea_level>, quantity_point<si::metre, mean_sea_level>>);
-static_assert(
-  std::convertible_to<quantity_point<si::metre, mean_sea_level>, quantity_point<isq::height[m], mean_sea_level>>);
+  std::convertible_to<quantity_point<(si::metre), mean_sea_level>, quantity_point<(isq::height[m]), mean_sea_level>>);
 
-static_assert(std::constructible_from<quantity_point<isq::height[m], mean_sea_level>,
+static_assert(std::constructible_from<quantity_point<(isq::height[m]), mean_sea_level>,
                                       quantity_point<special_height[m], mean_sea_level>>);
 static_assert(std::convertible_to<quantity_point<special_height[m], mean_sea_level>,
-                                  quantity_point<isq::height[m], mean_sea_level>>);
+                                  quantity_point<(isq::height[m]), mean_sea_level>>);
 
 static_assert(!std::constructible_from<quantity_point<special_height[m], mean_sea_level>,
-                                       quantity_point<isq::height[m], mean_sea_level>>);
-static_assert(!std::convertible_to<quantity_point<isq::height[m], mean_sea_level>,
+                                       quantity_point<(isq::height[m]), mean_sea_level>>);
+static_assert(!std::convertible_to<quantity_point<(isq::height[m]), mean_sea_level>,
                                    quantity_point<special_height[m], mean_sea_level>>);
 
 // different origins
-static_assert(!std::constructible_from<quantity_point<isq::height[m], mean_sea_level>,
-                                       quantity_point<isq::height[m], other_absolute_level>>);
-static_assert(!std::convertible_to<quantity_point<isq::height[m], other_absolute_level>,
-                                   quantity_point<isq::height[m], mean_sea_level>>);
-static_assert(!std::constructible_from<quantity_point<isq::height[m], ground_level>,
-                                       quantity_point<isq::height[m], other_absolute_level>>);
-static_assert(!std::convertible_to<quantity_point<isq::height[m], other_absolute_level>,
-                                   quantity_point<isq::height[m], ground_level>>);
-static_assert(!std::constructible_from<quantity_point<isq::height[m], other_absolute_level>,
-                                       quantity_point<isq::height[m], ground_level>>);
-static_assert(!std::convertible_to<quantity_point<isq::height[m], ground_level>,
-                                   quantity_point<isq::height[m], other_absolute_level>>);
+static_assert(!std::constructible_from<quantity_point<(isq::height[m]), mean_sea_level>,
+                                       quantity_point<(isq::height[m]), other_absolute_level>>);
+static_assert(!std::convertible_to<quantity_point<(isq::height[m]), other_absolute_level>,
+                                   quantity_point<(isq::height[m]), mean_sea_level>>);
+static_assert(!std::constructible_from<quantity_point<(isq::height[m]), ground_level>,
+                                       quantity_point<(isq::height[m]), other_absolute_level>>);
+static_assert(!std::convertible_to<quantity_point<(isq::height[m]), other_absolute_level>,
+                                   quantity_point<(isq::height[m]), ground_level>>);
+static_assert(!std::constructible_from<quantity_point<(isq::height[m]), other_absolute_level>,
+                                       quantity_point<(isq::height[m]), ground_level>>);
+static_assert(!std::convertible_to<quantity_point<(isq::height[m]), ground_level>,
+                                   quantity_point<(isq::height[m]), other_absolute_level>>);
 
 #if MP_UNITS_HOSTED
 // quantity-point-like
 static_assert(
-  std::constructible_from<quantity_point<isq::time[s], chrono_point_origin<std::chrono::system_clock>>, sys_seconds>);
+  std::constructible_from<quantity_point<(isq::time[s]), chrono_point_origin<std::chrono::system_clock>>, sys_seconds>);
 static_assert(
-  std::convertible_to<sys_seconds, quantity_point<isq::time[s], chrono_point_origin<std::chrono::system_clock>>>);
+  std::convertible_to<sys_seconds, quantity_point<(isq::time[s]), chrono_point_origin<std::chrono::system_clock>>>);
 
 // incompatible origin
+static_assert(!std::constructible_from<quantity_point<(isq::time[s]), chrono_point_origin<std::chrono::steady_clock>>,
+                                       sys_seconds>);
 static_assert(
-  !std::constructible_from<quantity_point<isq::time[s], chrono_point_origin<std::chrono::steady_clock>>, sys_seconds>);
-static_assert(
-  !std::convertible_to<sys_seconds, quantity_point<isq::time[s], chrono_point_origin<std::chrono::steady_clock>>>);
+  !std::convertible_to<sys_seconds, quantity_point<(isq::time[s]), chrono_point_origin<std::chrono::steady_clock>>>);
 #endif
 
 
@@ -825,17 +835,19 @@ static_assert((mean_sea_level + 42 * m).quantity_from(mean_sea_level) == 42 * m)
 static_assert((ground_level + 42 * m).quantity_from(ground_level) == 42 * m);
 static_assert((tower_peak + 42 * m).quantity_from(tower_peak) == 42 * m);
 
-static_assert(quantity_point<isq::height[m], mean_sea_level>(ground_level + 42 * m).quantity_from(mean_sea_level) ==
+static_assert(quantity_point<(isq::height[m]), mean_sea_level>(ground_level + 42 * m).quantity_from(mean_sea_level) ==
               84 * m);
-static_assert(quantity_point<isq::height[m], mean_sea_level>(tower_peak + 42 * m).quantity_from(mean_sea_level) ==
+static_assert(quantity_point<(isq::height[m]), mean_sea_level>(tower_peak + 42 * m).quantity_from(mean_sea_level) ==
               126 * m);
 
-static_assert(quantity_point<isq::height[m], ground_level>(mean_sea_level + 84 * m).quantity_from(ground_level) ==
+static_assert(quantity_point<(isq::height[m]), ground_level>(mean_sea_level + 84 * m).quantity_from(ground_level) ==
               42 * m);
-static_assert(quantity_point<isq::height[m], ground_level>(tower_peak + 42 * m).quantity_from(ground_level) == 84 * m);
+static_assert(quantity_point<(isq::height[m]), ground_level>(tower_peak + 42 * m).quantity_from(ground_level) ==
+              84 * m);
 
-static_assert(quantity_point<isq::height[m], tower_peak>(mean_sea_level + 42 * m).quantity_from(tower_peak) == -42 * m);
-static_assert(quantity_point<isq::height[m], tower_peak>(ground_level + 84 * m).quantity_from(tower_peak) == 42 * m);
+static_assert(quantity_point<(isq::height[m]), tower_peak>(mean_sea_level + 42 * m).quantity_from(tower_peak) ==
+              -42 * m);
+static_assert(quantity_point<(isq::height[m]), tower_peak>(ground_level + 84 * m).quantity_from(tower_peak) == 42 * m);
 
 static_assert((mean_sea_level + 42 * m).point_for(mean_sea_level).quantity_from(mean_sea_level) == 42 * m);
 static_assert((ground_level + 42 * m).point_for(mean_sea_level).quantity_from(mean_sea_level) == 84 * m);
@@ -850,7 +862,7 @@ static_assert((mean_sea_level + 42 * m).point_for(tower_peak).quantity_from(towe
 static_assert((ground_level + 84 * m).point_for(tower_peak).quantity_from(tower_peak) == 42 * m);
 
 static_assert(is_of_type<(ground_level + isq::height(short{42} * m)).point_for(mean_sea_level),
-                         quantity_point<isq::height[m], mean_sea_level, int>>);
+                         quantity_point<(isq::height[m]), mean_sea_level, int>>);
 
 
 ///////////////////////////////////
@@ -877,8 +889,8 @@ static_assert(is_of_type<(mean_sea_level + 2500. * m).force_in<int>(km), quantit
 
 template<template<auto, auto, typename> typename QP>
 concept invalid_unit_conversion = requires {
-  requires !requires { QP<isq::height[m], mean_sea_level, int>(2000 * m).in(km); };  // truncating conversion
-  requires !requires { QP<isq::height[m], mean_sea_level, int>(2 * m).in(s); };      // invalid unit
+  requires !requires { QP<(isq::height[m]), mean_sea_level, int>(2000 * m).in(km); };  // truncating conversion
+  requires !requires { QP<(isq::height[m]), mean_sea_level, int>(2 * m).in(s); };      // invalid unit
 };
 static_assert(invalid_unit_conversion<quantity_point>);
 
@@ -926,13 +938,12 @@ static_assert(quantity_point{sys_seconds{24h}}.quantity_spec == kind_of<isq::tim
 ////////////
 // getters
 ////////////
-
-constexpr quantity_point mean_sea_level_qp = mean_sea_level + 1 * m;
-constexpr quantity_point my_mean_sea_level_qp = my_mean_sea_level + 1 * m;
-constexpr quantity_point ground_level_qp = ground_level + 1 * m;
-constexpr quantity_point my_ground_level_qp = my_ground_level + 1 * m;
-constexpr quantity_point same_ground_level1_qp = same_ground_level1 + 1 * m;
-constexpr quantity_point same_ground_level2_qp = same_ground_level2 + 1 * m;
+constexpr QuantityPoint auto mean_sea_level_qp = mean_sea_level + (1 * m);
+constexpr QuantityPoint auto my_mean_sea_level_qp = my_mean_sea_level + 1 * m;
+constexpr QuantityPoint auto ground_level_qp = ground_level + 1 * m;
+constexpr QuantityPoint auto my_ground_level_qp = my_ground_level + 1 * m;
+constexpr QuantityPoint auto same_ground_level1_qp = same_ground_level1 + 1 * m;
+constexpr QuantityPoint auto same_ground_level2_qp = same_ground_level2 + 1 * m;
 
 static_assert(mean_sea_level_qp.quantity_ref_from(mean_sea_level) == 1 * m);
 static_assert(mean_sea_level_qp.quantity_ref_from(my_mean_sea_level) == 1 * m);
@@ -957,24 +968,24 @@ static_assert(same_ground_level2_qp.quantity_ref_from(same_ground_level1) == 1 *
 static_assert(same_ground_level2_qp.quantity_ref_from(same_ground_level2) == 1 * m);
 
 
-////////////////////////
-// assignment operator
-////////////////////////
+// ////////////////////////
+// //assignment operator
+// ////////////////////////
 
 static_assert(([]() {
-                const quantity_point l1{mean_sea_level + 1 * m};
-                quantity_point l2{mean_sea_level + 2 * m};
+                const QuantityPoint auto l1{mean_sea_level + 1 * m};
+                QuantityPoint auto l2{mean_sea_level + 2 * m};
                 return l2 = l1;
               }())
                 .quantity_from(mean_sea_level) == 1 * m);
 static_assert(([]() {
-                const quantity_point l1{mean_sea_level + 1 * m};
-                quantity_point l2{mean_sea_level + 2 * m};
+                const QuantityPoint auto l1{mean_sea_level + 1 * m};
+                QuantityPoint auto l2{mean_sea_level + 2 * m};
                 return l2 = l1;
               }())
                 .quantity_from(mean_sea_level) == 1 * m);
 static_assert(([]() {
-                quantity_point l1{mean_sea_level + 1 * m}, l2{mean_sea_level + 2 * m};
+                QuantityPoint auto l1{mean_sea_level + 1 * m}, l2{mean_sea_level + 2 * m};
                 return l2 = std::move(l1);  // NOLINT(*-move-const-arg)
               }())
                 .quantity_from(mean_sea_level) == 1 * m);
@@ -987,7 +998,7 @@ static_assert(([]() {
 static_assert([](auto v) {
   auto vv = v++;  // NOLINT(bugprone-inc-dec-in-conditions)
   return std::pair(v, vv);
-}(mean_sea_level + 123 * m) == std::pair(mean_sea_level + 124 * m, quantity_point(mean_sea_level + 123 * m)));
+}(mean_sea_level + 123 * m) == std::pair(mean_sea_level + 124 * m, mean_sea_level + 123 * m));
 static_assert([](auto v) {
   auto vv = ++v;  // NOLINT(bugprone-inc-dec-in-conditions)
   return std::pair(v, vv);
@@ -1020,18 +1031,18 @@ static_assert((mean_sea_level + 1123 * m -= 1 * km).quantity_from_zero().numeric
 template<template<auto, auto, typename> typename QP>
 concept invalid_compound_assignments = requires() {
   // truncating not allowed
-  requires !requires(QP<isq::height[m], mean_sea_level, int> l) { l += 2.5 * m; };
-  requires !requires(QP<isq::height[m], mean_sea_level, int> l) { l -= 2.5 * m; };
-  requires !requires(QP<isq::height[km], mean_sea_level, int> l) { l += 2 * isq::height[m]; };
-  requires !requires(QP<isq::height[km], mean_sea_level, int> l) { l -= 2 * isq::height[m]; };
+  requires !requires(QP<(isq::height[m]), mean_sea_level, int> l) { l += 2.5 * m; };
+  requires !requires(QP<(isq::height[m]), mean_sea_level, int> l) { l -= 2.5 * m; };
+  requires !requires(QP<isq::height[km], mean_sea_level, int> l) { l += 2 * (isq::height[m]); };
+  requires !requires(QP<isq::height[km], mean_sea_level, int> l) { l -= 2 * (isq::height[m]); };
 
   // only quantities can be added or subtracted
-  requires !requires(QP<isq::height[m], mean_sea_level, int> l) { l += 2; };
-  requires !requires(QP<isq::height[m], mean_sea_level, int> l) { l -= 2; };
+  requires !requires(QP<(isq::height[m]), mean_sea_level, int> l) { l += 2; };
+  requires !requires(QP<(isq::height[m]), mean_sea_level, int> l) { l -= 2; };
 
   // no unit constants
-  requires !requires(QP<isq::height[m], mean_sea_level, int> l) { l += m; };
-  requires !requires(QP<isq::height[m], mean_sea_level, int> l) { l -= m; };
+  requires !requires(QP<(isq::height[m]), mean_sea_level, int> l) { l += m; };
+  requires !requires(QP<(isq::height[m]), mean_sea_level, int> l) { l -= m; };
 };
 static_assert(invalid_compound_assignments<quantity_point>);
 
@@ -1132,12 +1143,12 @@ concept invalid_binary_operations = requires {
   requires !requires { Origin - Origin; };
 
   // unit constants
-  requires !requires { QP<si::metre, mean_sea_level, int>(1) + m; };
-  requires !requires { QP<si::metre, mean_sea_level, int>(1) - m; };
+  requires !requires { QP<(si::metre), mean_sea_level, int>(1) + m; };
+  requires !requires { QP<(si::metre), mean_sea_level, int>(1) - m; };
   requires !requires { Origin + m; };
   requires !requires { Origin - m; };
-  requires !requires { m + QP<si::metre, mean_sea_level, int>(1); };
-  requires !requires { m - QP<si::metre, mean_sea_level, int>(1); };
+  requires !requires { m + QP<(si::metre), mean_sea_level, int>(1); };
+  requires !requires { m - QP<(si::metre), mean_sea_level, int>(1); };
   requires !requires { m + Origin; };
   requires !requires { m - Origin; };
 };
@@ -1174,36 +1185,36 @@ static_assert(is_of_type<1 * m + (mean_sea_level + 1 * km), quantity_point<si::m
 static_assert(is_of_type<1 * km + (mean_sea_level + 1 * m), quantity_point<si::metre, mean_sea_level, int>>);
 
 static_assert(
-  is_of_type<1 * m + (mean_sea_level + isq::height(1 * m)), quantity_point<isq::height[m], mean_sea_level, int>>);
+  is_of_type<1 * m + (mean_sea_level + isq::height(1 * m)), quantity_point<(isq::height[m]), mean_sea_level, int>>);
 static_assert(
-  is_of_type<1 * m + (mean_sea_level + isq::height(1 * km)), quantity_point<isq::height[m], mean_sea_level, int>>);
+  is_of_type<1 * m + (mean_sea_level + isq::height(1 * km)), quantity_point<(isq::height[m]), mean_sea_level, int>>);
 static_assert(
-  is_of_type<1 * km + (mean_sea_level + isq::height(1 * m)), quantity_point<isq::height[m], mean_sea_level, int>>);
+  is_of_type<1 * km + (mean_sea_level + isq::height(1 * m)), quantity_point<(isq::height[m]), mean_sea_level, int>>);
 
 static_assert(
-  is_of_type<isq::height(1 * m) + (mean_sea_level + 1 * m), quantity_point<isq::height[m], mean_sea_level, int>>);
+  is_of_type<isq::height(1 * m) + (mean_sea_level + 1 * m), quantity_point<(isq::height[m]), mean_sea_level, int>>);
 static_assert(
-  is_of_type<isq::height(1 * m) + (mean_sea_level + 1 * km), quantity_point<isq::height[m], mean_sea_level, int>>);
+  is_of_type<isq::height(1 * m) + (mean_sea_level + 1 * km), quantity_point<(isq::height[m]), mean_sea_level, int>>);
 static_assert(
-  is_of_type<isq::height(1 * km) + (mean_sea_level + 1 * m), quantity_point<isq::height[m], mean_sea_level, int>>);
+  is_of_type<isq::height(1 * km) + (mean_sea_level + 1 * m), quantity_point<(isq::height[m]), mean_sea_level, int>>);
 
 static_assert(is_of_type<isq::height(1 * m) + (mean_sea_level + isq::height(1 * m)),
-                         quantity_point<isq::height[m], mean_sea_level, int>>);
+                         quantity_point<(isq::height[m]), mean_sea_level, int>>);
 static_assert(is_of_type<isq::height(1 * m) + (mean_sea_level + isq::height(1 * km)),
-                         quantity_point<isq::height[m], mean_sea_level, int>>);
+                         quantity_point<(isq::height[m]), mean_sea_level, int>>);
 static_assert(is_of_type<isq::height(1 * km) + (mean_sea_level + isq::height(1 * m)),
-                         quantity_point<isq::height[m], mean_sea_level, int>>);
+                         quantity_point<(isq::height[m]), mean_sea_level, int>>);
 
 static_assert(is_of_type<mean_sea_level + 1 * m, quantity_point<si::metre, mean_sea_level, int>>);
 static_assert(is_of_type<mean_sea_level + 1 * km, quantity_point<si::kilo<si::metre>, mean_sea_level, int>>);
-static_assert(is_of_type<mean_sea_level + isq::height(1 * m), quantity_point<isq::height[m], mean_sea_level, int>>);
+static_assert(is_of_type<mean_sea_level + isq::height(1 * m), quantity_point<(isq::height[m]), mean_sea_level, int>>);
 static_assert(
   is_of_type<mean_sea_level + special_height(1 * m), quantity_point<special_height[si::metre], mean_sea_level, int>>);
 static_assert(is_of_type<mean_sea_level + special_height(1 * km),
                          quantity_point<special_height[si::kilo<si::metre>], mean_sea_level, int>>);
 static_assert(is_of_type<1 * m + mean_sea_level, quantity_point<si::metre, mean_sea_level, int>>);
 static_assert(is_of_type<1 * km + mean_sea_level, quantity_point<si::kilo<si::metre>, mean_sea_level, int>>);
-static_assert(is_of_type<isq::height(1 * m) + mean_sea_level, quantity_point<isq::height[m], mean_sea_level, int>>);
+static_assert(is_of_type<isq::height(1 * m) + mean_sea_level, quantity_point<(isq::height[m]), mean_sea_level, int>>);
 static_assert(
   is_of_type<special_height(1 * m) + mean_sea_level, quantity_point<special_height[si::metre], mean_sea_level, int>>);
 static_assert(is_of_type<special_height(1 * km) + mean_sea_level,
@@ -1219,25 +1230,25 @@ static_assert(is_of_type<(mean_sea_level + 1 * km) - 1 * m, quantity_point<si::m
 static_assert(is_of_type<(mean_sea_level + 1 * m) - 1 * km, quantity_point<si::metre, mean_sea_level, int>>);
 
 static_assert(
-  is_of_type<(mean_sea_level + 1 * m) - isq::height(1 * m), quantity_point<isq::height[m], mean_sea_level, int>>);
+  is_of_type<(mean_sea_level + 1 * m) - isq::height(1 * m), quantity_point<(isq::height[m]), mean_sea_level, int>>);
 static_assert(
-  is_of_type<(mean_sea_level + 1 * m) - isq::height(1 * km), quantity_point<isq::height[m], mean_sea_level, int>>);
+  is_of_type<(mean_sea_level + 1 * m) - isq::height(1 * km), quantity_point<(isq::height[m]), mean_sea_level, int>>);
 static_assert(
-  is_of_type<(mean_sea_level + 1 * km) - isq::height(1 * m), quantity_point<isq::height[m], mean_sea_level, int>>);
+  is_of_type<(mean_sea_level + 1 * km) - isq::height(1 * m), quantity_point<(isq::height[m]), mean_sea_level, int>>);
 
 static_assert(
-  is_of_type<(mean_sea_level + isq::height(1 * m)) - 1 * m, quantity_point<isq::height[m], mean_sea_level, int>>);
+  is_of_type<(mean_sea_level + isq::height(1 * m)) - 1 * m, quantity_point<(isq::height[m]), mean_sea_level, int>>);
 static_assert(
-  is_of_type<(mean_sea_level + isq::height(1 * m)) - 1 * km, quantity_point<isq::height[m], mean_sea_level, int>>);
+  is_of_type<(mean_sea_level + isq::height(1 * m)) - 1 * km, quantity_point<(isq::height[m]), mean_sea_level, int>>);
 static_assert(
-  is_of_type<(mean_sea_level + isq::height(1 * km)) - 1 * m, quantity_point<isq::height[m], mean_sea_level, int>>);
+  is_of_type<(mean_sea_level + isq::height(1 * km)) - 1 * m, quantity_point<(isq::height[m]), mean_sea_level, int>>);
 
 static_assert(is_of_type<(mean_sea_level + isq::height(1 * m)) - isq::height(1 * m),
-                         quantity_point<isq::height[m], mean_sea_level, int>>);
+                         quantity_point<(isq::height[m]), mean_sea_level, int>>);
 static_assert(is_of_type<(mean_sea_level + isq::height(1 * m)) - isq::height(1 * km),
-                         quantity_point<isq::height[m], mean_sea_level, int>>);
+                         quantity_point<(isq::height[m]), mean_sea_level, int>>);
 static_assert(is_of_type<(mean_sea_level + isq::height(1 * km)) - isq::height(1 * m),
-                         quantity_point<isq::height[m], mean_sea_level, int>>);
+                         quantity_point<(isq::height[m]), mean_sea_level, int>>);
 
 static_assert(is_of_type<mean_sea_level - 1 * m, quantity_point<si::metre, mean_sea_level, int>>);
 static_assert(is_of_type<mean_sea_level - 1 * km, quantity_point<si::kilo<si::metre>, mean_sea_level, int>>);
@@ -1254,39 +1265,39 @@ static_assert(is_of_type<(mean_sea_level + 1 * km) - (mean_sea_level + 1 * m), q
 static_assert(is_of_type<(mean_sea_level + 1 * m) - (mean_sea_level + 1 * km), quantity<si::metre, int>>);
 
 static_assert(
-  is_of_type<(mean_sea_level + 1 * m) - (mean_sea_level + isq::height(1 * m)), quantity<isq::height[m], int>>);
+  is_of_type<(mean_sea_level + 1 * m) - (mean_sea_level + isq::height(1 * m)), quantity<(isq::height[m]), int>>);
 static_assert(
-  is_of_type<(mean_sea_level + 1 * m) - (mean_sea_level + isq::height(1 * km)), quantity<isq::height[m], int>>);
+  is_of_type<(mean_sea_level + 1 * m) - (mean_sea_level + isq::height(1 * km)), quantity<(isq::height[m]), int>>);
 static_assert(
-  is_of_type<(mean_sea_level + 1 * km) - (mean_sea_level + isq::height(1 * m)), quantity<isq::height[m], int>>);
+  is_of_type<(mean_sea_level + 1 * km) - (mean_sea_level + isq::height(1 * m)), quantity<(isq::height[m]), int>>);
 
 static_assert(
-  is_of_type<(mean_sea_level + isq::height(1 * m)) - (mean_sea_level + 1 * m), quantity<isq::height[m], int>>);
+  is_of_type<(mean_sea_level + isq::height(1 * m)) - (mean_sea_level + 1 * m), quantity<(isq::height[m]), int>>);
 static_assert(
-  is_of_type<(mean_sea_level + isq::height(1 * m)) - (mean_sea_level + 1 * km), quantity<isq::height[m], int>>);
+  is_of_type<(mean_sea_level + isq::height(1 * m)) - (mean_sea_level + 1 * km), quantity<(isq::height[m]), int>>);
 static_assert(
-  is_of_type<(mean_sea_level + isq::height(1 * km)) - (mean_sea_level + 1 * m), quantity<isq::height[m], int>>);
+  is_of_type<(mean_sea_level + isq::height(1 * km)) - (mean_sea_level + 1 * m), quantity<(isq::height[m]), int>>);
 
 static_assert(is_of_type<(mean_sea_level + isq::height(1 * m)) - (mean_sea_level + isq::height(1 * m)),
-                         quantity<isq::height[m], int>>);
+                         quantity<(isq::height[m]), int>>);
 static_assert(is_of_type<(mean_sea_level + isq::height(1 * m)) - (mean_sea_level + isq::height(1 * km)),
-                         quantity<isq::height[m], int>>);
+                         quantity<(isq::height[m]), int>>);
 static_assert(is_of_type<(mean_sea_level + isq::height(1 * km)) - (mean_sea_level + isq::height(1 * m)),
-                         quantity<isq::height[m], int>>);
+                         quantity<(isq::height[m]), int>>);
 
 static_assert(is_of_type<(mean_sea_level + 1 * m) - (mean_sea_level + 1 * m), quantity<si::metre, int>>);
 static_assert(is_of_type<(ground_level + 1 * m) - (ground_level + 1 * m), quantity<si::metre, int>>);
 static_assert(is_of_type<(tower_peak + 1 * m) - (tower_peak + 1 * m), quantity<si::metre, int>>);
-static_assert(is_of_type<(mean_sea_level + 1 * m) - (ground_level + 1 * m), quantity<isq::height[m], int>>);
-static_assert(is_of_type<(ground_level + 1 * m) - (mean_sea_level + 1 * m), quantity<isq::height[m], int>>);
-static_assert(is_of_type<(tower_peak + 1 * m) - (ground_level + 1 * m), quantity<isq::height[m], int>>);
-static_assert(is_of_type<(ground_level + 1 * m) - (tower_peak + 1 * m), quantity<isq::height[m], int>>);
-static_assert(is_of_type<(tower_peak + 1 * m) - (mean_sea_level + 1 * m), quantity<isq::height[m], int>>);
-static_assert(is_of_type<(mean_sea_level + 1 * m) - (tower_peak + 1 * m), quantity<isq::height[m], int>>);
-static_assert(is_of_type<(other_ground_level + 1 * m) - (ground_level + 1 * m), quantity<isq::height[m], int>>);
-static_assert(is_of_type<(ground_level + 1 * m) - (other_ground_level + 1 * m), quantity<isq::height[m], int>>);
-static_assert(is_of_type<(other_ground_level + 1 * m) - (tower_peak + 1 * m), quantity<isq::height[m], int>>);
-static_assert(is_of_type<(tower_peak + 1 * m) - (other_ground_level + 1 * m), quantity<isq::height[m], int>>);
+static_assert(is_of_type<(mean_sea_level + 1 * m) - (ground_level + 1 * m), quantity<(isq::height[m]), int>>);
+static_assert(is_of_type<(ground_level + 1 * m) - (mean_sea_level + 1 * m), quantity<(isq::height[m]), int>>);
+static_assert(is_of_type<(tower_peak + 1 * m) - (ground_level + 1 * m), quantity<(isq::height[m]), int>>);
+static_assert(is_of_type<(ground_level + 1 * m) - (tower_peak + 1 * m), quantity<(isq::height[m]), int>>);
+static_assert(is_of_type<(tower_peak + 1 * m) - (mean_sea_level + 1 * m), quantity<(isq::height[m]), int>>);
+static_assert(is_of_type<(mean_sea_level + 1 * m) - (tower_peak + 1 * m), quantity<(isq::height[m]), int>>);
+static_assert(is_of_type<(other_ground_level + 1 * m) - (ground_level + 1 * m), quantity<(isq::height[m]), int>>);
+static_assert(is_of_type<(ground_level + 1 * m) - (other_ground_level + 1 * m), quantity<(isq::height[m]), int>>);
+static_assert(is_of_type<(other_ground_level + 1 * m) - (tower_peak + 1 * m), quantity<(isq::height[m]), int>>);
+static_assert(is_of_type<(tower_peak + 1 * m) - (other_ground_level + 1 * m), quantity<(isq::height[m]), int>>);
 
 static_assert(is_of_type<mean_sea_level - (mean_sea_level + 1 * m), quantity<si::metre, int>>);
 static_assert(is_of_type<mean_sea_level - (mean_sea_level + 1 * km), quantity<si::kilo<si::metre>, int>>);
@@ -1298,32 +1309,32 @@ static_assert(is_of_type<ground_level - (ground_level + 1 * km), quantity<si::ki
 static_assert(is_of_type<(ground_level + 1 * m) - ground_level, quantity<si::metre, int>>);
 static_assert(is_of_type<(ground_level + 1 * km) - ground_level, quantity<si::kilo<si::metre>, int>>);
 
-static_assert(is_of_type<mean_sea_level - (ground_level + 1 * m), quantity<isq::height[m], int>>);
-static_assert(is_of_type<mean_sea_level - (ground_level + 1 * km), quantity<isq::height[m], int>>);
-static_assert(is_of_type<(ground_level + 1 * m) - mean_sea_level, quantity<isq::height[m], int>>);
-static_assert(is_of_type<(ground_level + 1 * km) - mean_sea_level, quantity<isq::height[m], int>>);
+static_assert(is_of_type<mean_sea_level - (ground_level + 1 * m), quantity<(isq::height[m]), int>>);
+static_assert(is_of_type<mean_sea_level - (ground_level + 1 * km), quantity<(isq::height[m]), int>>);
+static_assert(is_of_type<(ground_level + 1 * m) - mean_sea_level, quantity<(isq::height[m]), int>>);
+static_assert(is_of_type<(ground_level + 1 * km) - mean_sea_level, quantity<(isq::height[m]), int>>);
 
-static_assert(is_of_type<ground_level - (mean_sea_level + 1 * m), quantity<isq::height[m], int>>);
-static_assert(is_of_type<ground_level - (mean_sea_level + 1 * km), quantity<isq::height[m], int>>);
-static_assert(is_of_type<(mean_sea_level + 1 * m) - ground_level, quantity<isq::height[m], int>>);
-static_assert(is_of_type<(mean_sea_level + 1 * km) - ground_level, quantity<isq::height[m], int>>);
+static_assert(is_of_type<ground_level - (mean_sea_level + 1 * m), quantity<(isq::height[m]), int>>);
+static_assert(is_of_type<ground_level - (mean_sea_level + 1 * km), quantity<(isq::height[m]), int>>);
+static_assert(is_of_type<(mean_sea_level + 1 * m) - ground_level, quantity<(isq::height[m]), int>>);
+static_assert(is_of_type<(mean_sea_level + 1 * km) - ground_level, quantity<(isq::height[m]), int>>);
 
-static_assert(is_of_type<ground_level - ground_level, quantity<isq::height[m], int>>);
-static_assert(is_of_type<mean_sea_level - ground_level, quantity<isq::height[m], int>>);
-static_assert(is_of_type<ground_level - mean_sea_level, quantity<isq::height[m], int>>);
-static_assert(is_of_type<ground_level - tower_peak, quantity<isq::height[m], int>>);
-static_assert(is_of_type<tower_peak - ground_level, quantity<isq::height[m], int>>);
+static_assert(is_of_type<ground_level - ground_level, quantity<(isq::height[m]), int>>);
+static_assert(is_of_type<mean_sea_level - ground_level, quantity<(isq::height[m]), int>>);
+static_assert(is_of_type<ground_level - mean_sea_level, quantity<(isq::height[m]), int>>);
+static_assert(is_of_type<ground_level - tower_peak, quantity<(isq::height[m]), int>>);
+static_assert(is_of_type<tower_peak - ground_level, quantity<(isq::height[m]), int>>);
 
-static_assert(is_of_type<(1 * m + mean_sea_level) - (1 * m + ground_level), quantity<isq::height[m], int>>);
-static_assert(is_of_type<(1 * m + ground_level) - (1 * m + mean_sea_level), quantity<isq::height[m], int>>);
-static_assert(is_of_type<(1 * m + tower_peak) - (1 * m + ground_level), quantity<isq::height[m], int>>);
-static_assert(is_of_type<(1 * m + ground_level) - (1 * m + tower_peak), quantity<isq::height[m], int>>);
-static_assert(is_of_type<(1 * m + tower_peak) - (1 * m + mean_sea_level), quantity<isq::height[m], int>>);
-static_assert(is_of_type<(1 * m + mean_sea_level) - (1 * m + tower_peak), quantity<isq::height[m], int>>);
-static_assert(is_of_type<(1 * m + other_ground_level) - (1 * m + ground_level), quantity<isq::height[m], int>>);
-static_assert(is_of_type<(1 * m + ground_level) - (1 * m + other_ground_level), quantity<isq::height[m], int>>);
-static_assert(is_of_type<(1 * m + other_ground_level) - (1 * m + tower_peak), quantity<isq::height[m], int>>);
-static_assert(is_of_type<(1 * m + tower_peak) - (1 * m + other_ground_level), quantity<isq::height[m], int>>);
+static_assert(is_of_type<(1 * m + mean_sea_level) - (1 * m + ground_level), quantity<(isq::height[m]), int>>);
+static_assert(is_of_type<(1 * m + ground_level) - (1 * m + mean_sea_level), quantity<(isq::height[m]), int>>);
+static_assert(is_of_type<(1 * m + tower_peak) - (1 * m + ground_level), quantity<(isq::height[m]), int>>);
+static_assert(is_of_type<(1 * m + ground_level) - (1 * m + tower_peak), quantity<(isq::height[m]), int>>);
+static_assert(is_of_type<(1 * m + tower_peak) - (1 * m + mean_sea_level), quantity<(isq::height[m]), int>>);
+static_assert(is_of_type<(1 * m + mean_sea_level) - (1 * m + tower_peak), quantity<(isq::height[m]), int>>);
+static_assert(is_of_type<(1 * m + other_ground_level) - (1 * m + ground_level), quantity<(isq::height[m]), int>>);
+static_assert(is_of_type<(1 * m + ground_level) - (1 * m + other_ground_level), quantity<(isq::height[m]), int>>);
+static_assert(is_of_type<(1 * m + other_ground_level) - (1 * m + tower_peak), quantity<(isq::height[m]), int>>);
+static_assert(is_of_type<(1 * m + tower_peak) - (1 * m + other_ground_level), quantity<(isq::height[m]), int>>);
 
 
 // check for integral types promotion
@@ -1643,8 +1654,8 @@ static_assert(is_of_type<(zero_Hz + 5 * isq::frequency[Hz]) - (zero_Hz + 10 / (2
 
 static_assert((quantity_point{10 / (2 * isq::period_duration[s])} + 5 * isq::frequency[Hz]).quantity_from_zero() ==
               10 * isq::frequency[Hz]);
-static_assert((10 / (2 * isq::period_duration[s]) + quantity_point{zero_Hz + 5 * isq::frequency[Hz]})
-                .quantity_from_zero() == 10 * isq::frequency[Hz]);
+static_assert((10 / (2 * isq::period_duration[s]) + (zero_Hz + 5 * isq::frequency[Hz])).quantity_from_zero() ==
+              10 * isq::frequency[Hz]);
 static_assert((quantity_point{5 * isq::frequency[Hz]} + 10 / (2 * isq::period_duration[s])).quantity_from_zero() ==
               10 * isq::frequency[Hz]);
 static_assert((5 * isq::frequency[Hz] + quantity_point{10 / (2 * isq::period_duration[s])}).quantity_from_zero() ==
@@ -1718,7 +1729,7 @@ static_assert(value_cast<m>(quantity_point{2 * km}).quantity_from_zero().numeric
 static_assert(value_cast<km>(quantity_point{2000 * m}).quantity_from_zero().numerical_value_in(km) == 2);
 static_assert(value_cast<int>(quantity_point{1.23 * m}).quantity_from_zero().numerical_value_in(m) == 1);
 static_assert(
-  value_cast<km / h>(quantity_point{2000.0 * m / (3600.0 * s)}).quantity_from_zero().numerical_value_in(km / h) == 2);
+  value_cast<(km / h)>(quantity_point{2000.0 * m / (3600.0 * s)}).quantity_from_zero().numerical_value_in(km / h) == 2);
 // lvalue references in value_cast
 namespace lvalue_tests {
 constexpr quantity_point lvalue_qp{2 * km};
diff --git a/test/static/quantity_spec_test.cpp b/test/static/quantity_spec_test.cpp
index ee4e86a8..ed4cb359 100644
--- a/test/static/quantity_spec_test.cpp
+++ b/test/static/quantity_spec_test.cpp
@@ -33,8 +33,8 @@ namespace {
 
 using namespace mp_units;
 
-using dimensionless_ = struct dimensionless;
-using dim_one_ = struct dimension_one;
+using dimensionless_ = struct mp_units::dimensionless;
+using dim_one_ = struct mp_units::dimension_one;
 
 // clang-format off
 inline constexpr struct dim_length_ final : base_dimension<"L"> {} dim_length;
diff --git a/test/static/quantity_test.cpp b/test/static/quantity_test.cpp
index 89f169bb..44ee65ad 100644
--- a/test/static/quantity_test.cpp
+++ b/test/static/quantity_test.cpp
@@ -84,14 +84,14 @@ static_assert(std::is_nothrow_destructible_v<quantity<isq::length[m]>>);
 static_assert(std::is_trivially_copyable_v<quantity<isq::length[m]>>);
 static_assert(std::is_standard_layout_v<quantity<isq::length[m]>>);
 
-static_assert(std::default_initializable<quantity<isq::length[m]>>);
-static_assert(std::move_constructible<quantity<isq::length[m]>>);
-static_assert(std::copy_constructible<quantity<isq::length[m]>>);
-static_assert(std::equality_comparable<quantity<isq::length[m]>>);
-static_assert(std::totally_ordered<quantity<isq::length[m]>>);
-static_assert(std::regular<quantity<isq::length[m]>>);
+static_assert(std::default_initializable<quantity<(isq::length[m])>>);
+static_assert(std::move_constructible<quantity<(isq::length[m])>>);
+static_assert(std::copy_constructible<quantity<(isq::length[m])>>);
+static_assert(std::equality_comparable<quantity<(isq::length[m])>>);
+static_assert(std::totally_ordered<quantity<(isq::length[m])>>);
+static_assert(std::regular<quantity<(isq::length[m])>>);
 
-static_assert(std::three_way_comparable<quantity<isq::length[m]>>);
+static_assert(std::three_way_comparable<quantity<(isq::length[m])>>);
 
 
 //////////////////
@@ -112,8 +112,8 @@ static_assert(quantity<isq::length[m]>::unit == si::metre);
 // member types
 /////////////////
 
-static_assert(is_same_v<quantity<isq::length[m]>::rep, double>);
-static_assert(is_same_v<quantity<isq::length[m], int>::rep, int>);
+static_assert(is_same_v<quantity<(isq::length[m])>::rep, double>);
+static_assert(is_same_v<quantity<(isq::length[m]), int>::rep, int>);
 
 [[maybe_unused]] volatile std::int16_t vint = 123;
 static_assert(is_same_v<decltype(quantity(vint * m))::rep, std::int16_t>);
@@ -139,11 +139,11 @@ static_assert(quantity<isq::length[m], double>::max().numerical_value_in(m) == s
 /////////////////////////////////////////////////
 
 // construction from a value is private
-static_assert(!std::constructible_from<quantity<isq::length[m]>, double>);
-static_assert(!std::convertible_to<double, quantity<isq::length[m]>>);
+static_assert(!std::constructible_from<quantity<(isq::length[m])>, double>);
+static_assert(!std::convertible_to<double, quantity<(isq::length[m])>>);
 
-static_assert(!std::constructible_from<quantity<isq::length[m], int>, int>);
-static_assert(!std::convertible_to<int, quantity<isq::length[m], int>>);
+static_assert(!std::constructible_from<quantity<(isq::length[m]), int>, int>);
+static_assert(!std::convertible_to<int, quantity<(isq::length[m]), int>>);
 
 static_assert(std::constructible_from<quantity<one>, double>);
 static_assert(std::convertible_to<double, quantity<one>>);
@@ -163,45 +163,46 @@ static_assert(std::convertible_to<int, quantity<dimensionless[one]>>);
 ///////////////////////////////////////
 
 // conversion only between convertible quantities
-static_assert(std::constructible_from<quantity<isq::length[m]>, quantity<isq::length[m]>>);
-static_assert(std::convertible_to<quantity<isq::length[m]>, quantity<isq::length[m]>>);
-static_assert(std::constructible_from<quantity<isq::length[m]>, quantity<isq::distance[m]>>);
-static_assert(std::convertible_to<quantity<isq::distance[m]>, quantity<isq::length[m]>>);
-static_assert(std::constructible_from<quantity<isq::length[m]>, quantity<isq::length[km]>>);
-static_assert(std::convertible_to<quantity<isq::length[km]>, quantity<isq::length[m]>>);
+static_assert(std::constructible_from<quantity<(isq::length[m])>, quantity<(isq::length[m])>>);
+static_assert(std::convertible_to<quantity<(isq::length[m])>, quantity<(isq::length[m])>>);
+static_assert(std::constructible_from<quantity<(isq::length[m])>, quantity<(isq::distance[m])>>);
+static_assert(std::convertible_to<quantity<(isq::distance[m])>, quantity<(isq::length[m])>>);
+static_assert(std::constructible_from<quantity<(isq::length[m])>, quantity<(isq::length[km])>>);
+static_assert(std::convertible_to<quantity<(isq::length[km])>, quantity<(isq::length[m])>>);
 
 // conversion between different quantities not allowed
-static_assert(!std::constructible_from<quantity<isq::length[m]>, quantity<isq::time[s]>>);
-static_assert(!std::convertible_to<quantity<isq::time[s]>, quantity<isq::length[m]>>);
-static_assert(!std::constructible_from<quantity<isq::length[m]>, quantity<isq::speed[m / s]>>);
-static_assert(!std::convertible_to<quantity<isq::speed[m / s]>, quantity<isq::length[m]>>);
+static_assert(!std::constructible_from<quantity<(isq::length[m])>, quantity<(isq::time[s])>>);
+static_assert(!std::convertible_to<quantity<(isq::time[s])>, quantity<(isq::length[m])>>);
+static_assert(!std::constructible_from<quantity<(isq::length[m])>, quantity<(isq::speed[m / s])>>);
+static_assert(!std::convertible_to<quantity<(isq::speed[m / s])>, quantity<(isq::length[m])>>);
 
 // implicit conversion from another quantity only if non-truncating
-static_assert(std::constructible_from<quantity<isq::length[m]>, quantity<isq::length[m], int>>);  // int -> double OK
-static_assert(std::convertible_to<quantity<isq::length[m], int>, quantity<isq::length[m]>>);      // int -> double OK
-
-static_assert(!std::constructible_from<quantity<isq::length[m], int>,
-                                       quantity<isq::length[m]>>);  // truncating double -> int not allowed
-static_assert(!std::convertible_to<quantity<isq::length[m]>,
-                                   quantity<isq::length[m], int>>);  // truncating double -> int not allowed
-
-static_assert(std::constructible_from<quantity<isq::length[m], int>,
-                                      quantity<isq::length[km], int>>);  // kilometre<int> -> metre<int> OK
-static_assert(std::convertible_to<quantity<isq::length[km], int>,
-                                  quantity<isq::length[m], int>>);  // kilometre<int> -> metre<int> OK
-
-static_assert(!std::constructible_from<quantity<isq::length[km], int>,
-                                       quantity<isq::length[m], int>>);  // truncating metre<int> ->
-                                                                         // kilometre<int> not allowed
 static_assert(
-  !std::convertible_to<quantity<isq::length[m], int>,
-                       quantity<isq::length[km], int>>);  // truncating metre<int> -> kilometre<int> not allowed
+  std::constructible_from<quantity<(isq::length[m])>, quantity<(isq::length[m]), int>>);          // int -> double OK
+static_assert(std::convertible_to<quantity<(isq::length[m]), int>, quantity<(isq::length[m])>>);  // int -> double OK
+
+static_assert(!std::constructible_from<quantity<(isq::length[m]), int>,
+                                       quantity<(isq::length[m])>>);  // truncating double -> int not allowed
+static_assert(!std::convertible_to<quantity<(isq::length[m])>,
+                                   quantity<(isq::length[m]), int>>);  // truncating double -> int not allowed
+
+static_assert(std::constructible_from<quantity<(isq::length[m]), int>,
+                                      quantity<(isq::length[km]), int>>);  // kilometre<int> -> metre<int> OK
+static_assert(std::convertible_to<quantity<(isq::length[km]), int>,
+                                  quantity<(isq::length[m]), int>>);  // kilometre<int> -> metre<int> OK
+
+static_assert(!std::constructible_from<quantity<(isq::length[km]), int>,
+                                       quantity<(isq::length[m]), int>>);  // truncating metre<int> ->
+                                                                           // kilometre<int> not allowed
+static_assert(
+  !std::convertible_to<quantity<(isq::length[m]), int>,
+                       quantity<(isq::length[km]), int>>);  // truncating metre<int> -> kilometre<int> not allowed
 
 // converting to double always OK
-static_assert(std::constructible_from<quantity<isq::length[m]>, quantity<isq::length[km], int>>);
-static_assert(std::convertible_to<quantity<isq::length[km], int>, quantity<isq::length[m]>>);
-static_assert(std::constructible_from<quantity<isq::length[km]>, quantity<isq::length[m], int>>);
-static_assert(std::convertible_to<quantity<isq::length[m], int>, quantity<isq::length[km]>>);
+static_assert(std::constructible_from<quantity<(isq::length[m])>, quantity<(isq::length[km]), int>>);
+static_assert(std::convertible_to<quantity<(isq::length[km]), int>, quantity<(isq::length[m])>>);
+static_assert(std::constructible_from<quantity<(isq::length[km])>, quantity<(isq::length[m]), int>>);
+static_assert(std::convertible_to<quantity<(isq::length[m]), int>, quantity<(isq::length[km])>>);
 
 ///////////////////////
 // obtaining a number
@@ -219,16 +220,16 @@ static_assert(quantity<isq::length[km]>(1500 * m).numerical_value_in(km) == 1.5)
 
 static_assert(!std::convertible_to<quantity<one>, double>);
 static_assert(std::constructible_from<double, quantity<one>>);
-static_assert(!std::convertible_to<quantity<isq::angular_measure[one]>, double>);
-static_assert(std::constructible_from<double, quantity<isq::angular_measure[one]>>);
+static_assert(!std::convertible_to<quantity<(isq::angular_measure[one])>, double>);
+static_assert(std::constructible_from<double, quantity<(isq::angular_measure[one])>>);
 static_assert(!std::convertible_to<quantity<one>, int>);
 static_assert(std::constructible_from<int, quantity<one>>);
-static_assert(!std::convertible_to<quantity<isq::angular_measure[one]>, int>);
-static_assert(std::constructible_from<int, quantity<isq::angular_measure[one]>>);
+static_assert(!std::convertible_to<quantity<(isq::angular_measure[one])>, int>);
+static_assert(std::constructible_from<int, quantity<(isq::angular_measure[one])>>);
 static_assert(!std::convertible_to<quantity<one, int>, double>);
 static_assert(std::constructible_from<double, quantity<one, int>>);
-static_assert(!std::convertible_to<quantity<isq::angular_measure[one], int>, double>);
-static_assert(std::constructible_from<double, quantity<isq::angular_measure[one], int>>);
+static_assert(!std::convertible_to<quantity<(isq::angular_measure[one]), int>, double>);
+static_assert(std::constructible_from<double, quantity<(isq::angular_measure[one]), int>>);
 
 
 ///////////////////////////////////
@@ -318,9 +319,9 @@ struct derived_quantity : quantity<Q::reference, Rep> {
     R::operator=(t);
     return *this;
   }
-  constexpr derived_quantity& operator=(R&& t)
+  constexpr derived_quantity& operator=(R&& other)
   {
-    R::operator=(std::move(t));
+    R::operator=(std::move(other));
     return *this;
   }
   // NOLINTBEGIN(google-explicit-constructor, hicpp-explicit-conversions)
@@ -331,9 +332,9 @@ struct derived_quantity : quantity<Q::reference, Rep> {
   // NOLINTEND(google-explicit-constructor, hicpp-explicit-conversions)
 };
 
-static_assert(Quantity<derived_quantity<double, quantity<isq::length[m]>, "NTTP type description">>);
+static_assert(Quantity<derived_quantity<double, quantity<(isq::length[m])>, "NTTP type description">>);
 
-constexpr QuantityOf<isq::length> auto get_length_derived_quantity() noexcept
+constexpr QuantityOf<(isq::length)> auto get_length_derived_quantity() noexcept
 {
   derived_quantity<double, quantity<isq::length[m]>, "NTTP type description"> dist{};
   dist += 1 * m;
@@ -362,7 +363,8 @@ static_assert(quantity{123}.quantity_spec == kind_of<dimensionless>);
 #if MP_UNITS_HOSTED
 using namespace std::chrono_literals;
 static_assert(std::is_same_v<decltype(quantity{123s})::rep, std::chrono::seconds::rep>);
-static_assert(std::is_same_v<decltype(quantity{123.s})::rep, long double>);
+// return type for "s" is not specified. is double for msvc
+// static_assert(std::is_same_v<decltype(quantity{123.s})::rep, long double>);
 static_assert(quantity{24h}.unit == si::hour);
 static_assert(quantity{24h}.quantity_spec == kind_of<isq::time>);
 #endif
@@ -461,10 +463,10 @@ static_assert((std::uint8_t{255}* m %= 257 * m).numerical_value_in(m) != [] {
 #if !(defined MP_UNITS_COMP_CLANG && MP_UNITS_COMP_CLANG < 18 && defined MP_UNITS_MODULES)
 // next two lines trigger conversions warnings
 // (warning disabled in CMake for this file)
-static_assert((22 * m *= 33.33).numerical_value_in(m) == 733);
-static_assert((22 * m /= 3.33).numerical_value_in(m) == 6);
-static_assert((22 * m *= 33.33 * one).numerical_value_in(m) == 733);
-static_assert((22 * m /= 3.33 * one).numerical_value_in(m) == 6);
+static_assert(((22 * m) *= 33.33).numerical_value_in(m) == 733);
+static_assert(((22 * m) /= 3.33).numerical_value_in(m) == 6);
+static_assert(((22 * m) *= 33.33 * one).numerical_value_in(m) == 733);
+static_assert(((22 * m) /= 3.33 * one).numerical_value_in(m) == 6);
 #endif
 
 template<template<auto, typename> typename Q>
@@ -850,27 +852,30 @@ static_assert(2 * one / (1 * m) == 2 / (1 * m));
 // equality operators
 ///////////////////////
 
-static_assert(std::equality_comparable_with<quantity<si::metre>, quantity<si::metre>>);
-static_assert(std::equality_comparable_with<quantity<si::metre>, quantity<si::metre, int>>);
-static_assert(std::equality_comparable_with<quantity<si::metre>, quantity<si::kilo<si::metre>, int>>);
-static_assert(std::equality_comparable_with<quantity<si::metre, int>, quantity<si::kilo<si::metre>, int>>);
-static_assert(std::equality_comparable_with<quantity<isq::length[si::metre]>, quantity<si::metre>>);
-static_assert(std::equality_comparable_with<quantity<isq::length[si::metre]>, quantity<si::metre, int>>);
-static_assert(std::equality_comparable_with<quantity<isq::length[si::metre]>, quantity<si::kilo<si::metre>, int>>);
-static_assert(std::equality_comparable_with<quantity<isq::width[si::metre]>, quantity<si::metre>>);
-static_assert(std::equality_comparable_with<quantity<isq::width[si::metre]>, quantity<si::metre, int>>);
-static_assert(std::equality_comparable_with<quantity<isq::width[si::metre]>, quantity<si::kilo<si::metre>, int>>);
-static_assert(std::equality_comparable_with<quantity<isq::width[si::metre]>, quantity<isq::height[si::metre]>>);
-static_assert(std::equality_comparable_with<quantity<isq::width[si::metre]>, quantity<isq::height[si::metre], int>>);
+static_assert(std::equality_comparable_with<quantity<(si::metre)>, quantity<(si::metre)>>);
+static_assert(std::equality_comparable_with<quantity<(si::metre)>, quantity<(si::metre), int>>);
+static_assert(std::equality_comparable_with<quantity<(si::metre)>, quantity<si::kilo<(si::metre)>, int>>);
+static_assert(std::equality_comparable_with<quantity<(si::metre), int>, quantity<si::kilo<(si::metre)>, int>>);
+static_assert(std::equality_comparable_with<quantity<(isq::length[(si::metre)])>, quantity<(si::metre)>>);
+static_assert(std::equality_comparable_with<quantity<(isq::length[(si::metre)])>, quantity<(si::metre), int>>);
 static_assert(
-  std::equality_comparable_with<quantity<isq::width[si::metre]>, quantity<isq::height[si::kilo<si::metre>], int>>);
+  std::equality_comparable_with<quantity<(isq::length[(si::metre)])>, quantity<si::kilo<(si::metre)>, int>>);
+static_assert(std::equality_comparable_with<quantity<(isq::width[(si::metre)])>, quantity<(si::metre)>>);
+static_assert(std::equality_comparable_with<quantity<(isq::width[(si::metre)])>, quantity<(si::metre), int>>);
+static_assert(
+  std::equality_comparable_with<quantity<(isq::width[(si::metre)])>, quantity<(si::kilo<(si::metre)>), int>>);
+static_assert(std::equality_comparable_with<quantity<(isq::width[(si::metre)])>, quantity<(isq::height[(si::metre)])>>);
+static_assert(
+  std::equality_comparable_with<quantity<(isq::width[(si::metre)])>, quantity<(isq::height[(si::metre)]), int>>);
+static_assert(std::equality_comparable_with<quantity<(isq::width[(si::metre)])>,
+                                            quantity<(isq::height[(si::kilo<(si::metre)>)]), int>>);
 
 template<auto M>
 concept no_crossdimensional_equality = requires {
   requires !requires { 1 * s == 1 * M; };
   requires !requires { 1 * s != 1 * M; };
 };
-static_assert(no_crossdimensional_equality<si::metre>);
+static_assert(no_crossdimensional_equality<(si::metre)>);
 
 // same type
 static_assert(123 * m == 123 * m);
@@ -923,7 +928,7 @@ concept no_crossdimensional_ordering = requires {
   requires !requires { 1 * s <= 1 * M; };
   requires !requires { 1 * s >= 1 * M; };
 };
-static_assert(no_crossdimensional_ordering<si::metre>);
+static_assert(no_crossdimensional_ordering<(si::metre)>);
 
 // same type
 static_assert(123 * m < 321 * m);
@@ -1037,34 +1042,35 @@ static_assert(is_of_type<quantity_cast<isq::distance>(lvalue_q), quantity<isq::d
 }  // namespace lvalue_tests
 
 // QuantityOf
-static_assert(QuantityOf<quantity<isq::length[m]>, isq::length>);
-static_assert(QuantityOf<quantity<isq::width[m]>, isq::length>);
-static_assert(QuantityOf<quantity<isq::position_vector[m], int>, isq::length>);
-static_assert(!QuantityOf<quantity<isq::length[m]>, isq::width>);
-static_assert(QuantityOf<quantity<m>, isq::width>);
-static_assert(QuantityOf<quantity<m>, isq::position_vector>);
-static_assert(QuantityOf<quantity<kind_of<isq::length>[m]>, isq::width>);
-static_assert(QuantityOf<quantity<kind_of<isq::length>[m]>, isq::position_vector>);
-static_assert(!QuantityOf<quantity<isq::width[m]>, isq::altitude>);
+static_assert(QuantityOf<quantity<(isq::length[m])>, (isq::length)>);
+static_assert(QuantityOf<quantity<(isq::width[m])>, (isq::length)>);
+static_assert(QuantityOf<quantity<(isq::position_vector[m]), int>, (isq::length)>);
+static_assert(!QuantityOf<quantity<(isq::length[m])>, (isq::width)>);
+static_assert(QuantityOf<quantity<m>, (isq::width)>);
+static_assert(QuantityOf<quantity<m>, (isq::position_vector)>);
+static_assert(QuantityOf<quantity<kind_of<(isq::length)>[m]>, (isq::width)>);
+static_assert(QuantityOf<quantity<kind_of<(isq::length)>[m]>, (isq::position_vector)>);
+static_assert(!QuantityOf<quantity<(isq::width[m])>, isq::altitude>);
 
-static_assert(QuantityOf<quantity<isq::speed[m / s]>, isq::speed>);
-static_assert(QuantityOf<quantity<isq::speed[m / s]>, isq::length / isq::time>);
+static_assert(QuantityOf<quantity<(isq::speed[m / s])>, (isq::speed)>);
+static_assert(QuantityOf<quantity<(isq::speed[m / s])>, (isq::length) / (isq::time)>);
 static_assert(QuantityOf<quantity<m / s>, isq::length / isq::time>);
-static_assert(QuantityOf<quantity<kind_of<isq::speed>[m / s]>, isq::length / isq::time>);
-static_assert(!QuantityOf<quantity<isq::speed[m / s]>, isq::distance / isq::duration>);
-static_assert(!QuantityOf<quantity<isq::speed[m / s]>, isq::width / isq::duration>);
+static_assert(QuantityOf<quantity<kind_of<(isq::speed)>[m / s]>, (isq::length) / (isq::time)>);
+static_assert(!QuantityOf<quantity<(isq::speed[m / s])>, (isq::distance) / (isq::duration)>);
+static_assert(!QuantityOf<quantity<(isq::speed[m / s])>, (isq::width) / (isq::duration)>);
 static_assert(QuantityOf<quantity<m / s>, isq::width / isq::duration>);
-static_assert(QuantityOf<quantity<kind_of<isq::speed>[m / s]>, isq::width / isq::duration>);
-static_assert(!QuantityOf<quantity<isq::speed[m / s]>, isq::position_vector / isq::duration>);
+static_assert(QuantityOf<quantity<kind_of<(isq::speed)>[m / s]>, (isq::width) / (isq::duration)>);
+static_assert(!QuantityOf<quantity<(isq::speed[m / s])>, (isq::position_vector) / (isq::duration)>);
 static_assert(QuantityOf<quantity<m / s>, isq::position_vector / isq::duration>);
-static_assert(QuantityOf<quantity<kind_of<isq::speed>[m / s]>, isq::position_vector / isq::duration>);
-static_assert(QuantityOf<quantity<isq::velocity[m / s], int>, isq::position_vector / isq::duration>);
+static_assert(QuantityOf<quantity<kind_of<(isq::speed)>[m / s]>, isq::position_vector / isq::duration>);
+static_assert(QuantityOf<quantity<(isq::velocity)[m / s], int>, isq::position_vector / isq::duration>);
 
-static_assert(QuantityOf<decltype(10 * m), isq::height>);                        // kind of
-static_assert(QuantityOf<decltype(10 * kind_of<isq::length>[m]), isq::height>);  // kind of
-static_assert(!QuantityOf<decltype(10 * isq::length[m]), isq::height>);          // different kinds
-static_assert(!QuantityOf<decltype(10 * isq::width[m]), isq::height>);           // different kinds
-static_assert(QuantityOf<decltype(10 * isq::speed[m / s]), isq::speed>);
-static_assert(QuantityOf<decltype(20 * isq::length[m] / (2 * isq::time[s])), isq::speed>);  // derived unnamed quantity
+static_assert(QuantityOf<decltype(10 * m), (isq::height)>);                          // kind of
+static_assert(QuantityOf<decltype(10 * kind_of<(isq::length)>[m]), (isq::height)>);  // kind of
+static_assert(!QuantityOf<decltype(10 * (isq::length[m])), (isq::height)>);          // different kinds
+static_assert(!QuantityOf<decltype(10 * (isq::width[m])), (isq::height)>);           // different kinds
+static_assert(QuantityOf<decltype(10 * (isq::speed[m / s])), (isq::speed)>);
+static_assert(
+  QuantityOf<decltype(20 * (isq::length[m]) / (2 * isq::time[s])), (isq::speed)>);  // derived unnamed quantity
 
 }  // namespace
diff --git a/test/static/reference_test.cpp b/test/static/reference_test.cpp
index 65abe0bb..46026702 100644
--- a/test/static/reference_test.cpp
+++ b/test/static/reference_test.cpp
@@ -34,8 +34,8 @@ namespace {
 
 using namespace mp_units;
 
-using dimensionless_ = struct dimensionless;
-using one_ = struct one;
+using dimensionless_ = struct mp_units::dimensionless;
+using one_ = struct mp_units::one;
 
 // base dimensions
 // clang-format off
@@ -238,7 +238,7 @@ template<auto dim, auto unit>
 concept invalid_nu_unit = !requires { dim[unit]; };
 
 static_assert(invalid_nu_unit<time, nu::second>);
-static_assert(invalid_nu_unit<nu::time, second>);
+static_assert(invalid_nu_unit<(nu::time), second>);
 static_assert(invalid_nu_unit<length / time, nu::second / nu::second>);
 static_assert(invalid_nu_unit<speed, nu::second / nu::second>);
 static_assert(invalid_nu_unit<speed, nu::second / second>);
diff --git a/test/static/si_test.cpp b/test/static/si_test.cpp
index 4f306fd2..d52a8edc 100644
--- a/test/static/si_test.cpp
+++ b/test/static/si_test.cpp
@@ -65,7 +65,7 @@ concept can_not_be_prefixed = Unit<decltype(V1)> && !requires { typename prefix<
 
 static_assert(can_not_be_prefixed<si::milli_, si::kilogram>);
 static_assert(can_not_be_prefixed<si::milli_, si::hectare>);
-static_assert(can_not_be_prefixed<si::milli_, si::kilo<si::metre>>);
+static_assert(can_not_be_prefixed<si::milli_, (si::kilo<(si::metre)>)>);
 static_assert(can_not_be_prefixed<si::milli_, si::metre / si::second>);
 static_assert(can_not_be_prefixed<si::milli_, mag_ratio<1, 60> * si::degree>);
 
diff --git a/test/static/unit_test.cpp b/test/static/unit_test.cpp
index ba7ecb4c..c16ea66a 100644
--- a/test/static/unit_test.cpp
+++ b/test/static/unit_test.cpp
@@ -35,8 +35,8 @@ namespace {
 using namespace mp_units;
 using namespace mp_units::detail;
 
-using one_ = struct one;
-using percent_ = struct percent;
+using one_ = struct mp_units::one;
+using percent_ = struct mp_units::percent;
 
 // base dimensions
 // clang-format off