diff --git a/example/avg_speed.cpp b/example/avg_speed.cpp
index 11072bb3..dc2d24d2 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 2f2f7fdb..4cf363fe 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 9a74de52..42ed6d0b 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 0eb46040..6f280659 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 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);
+  const quantity_point price_usd{100 * USD};
+  const quantity_point 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 f06062fe..133a7713 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 glider_task = {waypoints[0], waypoints[1], waypoints[0]};
+  const task t = {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(glider_task);
+  print(t);
   print(tow);
 
-  for (const auto& glider : gliders) {
+  for (const auto& g : gliders) {
     for (const auto& c : weather_conditions) {
-      const std::string txt = "Scenario: Glider = " + glider.name + ", Weather = " + c.first;
+      const std::string txt = "Scenario: Glider = " + g.name + ", Weather = " + c.first;
       std::cout << txt << "\n";
       std::cout << MP_UNITS_STD_FMT::format("{0:=^{1}}\n\n", "", txt.size());
 
-      estimate(start_time, glider, c.second, glider_task, sfty, tow);
+      estimate(start_time, g, c.second, t, 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 e8fafbf3..5e2ac4db 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 95b5e6d6..e635bc25 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 4f7ca94a..ba26b3f1 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 80179790..90d0d506 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)>
   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 d7650c21..d61c8d2e 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 MP_UNITS_CONSTRAINED_AUTO_WORKAROUND(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 d618b3b3..3fce6a8b 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 44b24738..86bc32ff 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 28963f6b..75416bb7 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 E1 = total_energy(p1, m1, c);
+  const QuantityOf<isq::mass> auto m1 = 3. * GeV / c2;
+  const quantity E = 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 = " << E1 << "\n";
+            << "E = " << E << "\n";
 
   const quantity p2 = p1.in(GeV / (m / s));
-  const quantity metre2 = m1.in(GeV / pow<2>(m / s));
-  const quantity E2 = total_energy(p2, metre2, c).in(GeV);
+  const quantity m2 = m1.in(GeV / pow<2>(m / s));
+  const quantity E2 = total_energy(p2, m2, 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 metre3 = m1.in(kg);
-  const quantity E3 = total_energy(p3, metre3, c).in(J);
+  const quantity m3 = m1.in(kg);
+  const quantity E3 = total_energy(p3, m3, 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 9cb32bfc..064e8055 100644
--- a/example/unmanned_aerial_vehicle.cpp
+++ b/example/unmanned_aerial_vehicle.cpp
@@ -70,7 +70,6 @@ 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/test/runtime/CMakeLists.txt b/test/runtime/CMakeLists.txt
index 70e13650..d79ed54b 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 2785041f..8c532390 100644
--- a/test/static/chrono_test.cpp
+++ b/test/static/chrono_test.cpp
@@ -57,43 +57,41 @@ 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>>);
+  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>>);
 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<time_point<si::second, std::chrono::system_clock, sys_seconds::rep>, sys_seconds>);
 static_assert(
-  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>>);
+  !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);
@@ -109,13 +107,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);
@@ -129,6 +127,15 @@ static_assert(quantity{std::chrono::weeks{1}} == 7 * d);
 static_assert(quantity{std::chrono::months{1}} == 2629746 * s);
 static_assert(quantity{std::chrono::years{1}} == 31556952 * s);
 
+// conversion from chrono
+static_assert(quantity<ns>{1ns} == 1 * ns);
+static_assert(quantity<ns>{1s} == 1 * s);
+static_assert(quantity<s>{1ms} == 1 * ms);
+
+// conversion to chrono
+static_assert(std::chrono::nanoseconds(quantity{1 * ns}) == 1ns);
+static_assert(std::chrono::nanoseconds(quantity{1 * s}) == 1s);
+
 // operators
 static_assert(quantity{1s} + 1 * s == 2 * s);
 static_assert(quantity{1s} + 1 * min == 61 * s);
diff --git a/test/static/concepts_test.cpp b/test/static/concepts_test.cpp
index 9564ed22..c67ff710 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 8b328557..4fb2537b 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,47 +99,46 @@ 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 f1d64590..8064831e 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 mp_units::dimension_one;
+using dimension_one_ = struct 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 50dfb67e..f04e9c1a 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,53 +235,51 @@ 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]);
@@ -290,11 +288,10 @@ 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)>::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>::absolute_point_origin,
              struct si::absolute_zero>);
 
 static_assert(quantity_point<isq::Celsius_temperature[si::kelvin], si::absolute_zero>::reference ==
@@ -304,20 +301,19 @@ 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,
+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(
-  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]);
@@ -326,10 +322,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>);
 
 
@@ -337,18 +333,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>>);
 
 
 ////////////////////////////
@@ -375,11 +371,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>>);
@@ -400,135 +396,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
 
 
@@ -537,146 +533,140 @@ 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[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<(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>,
+                                      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<isq::height[m], 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[km], mean_sea_level>,
+                                      quantity_point<isq::height[m], 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<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>,
+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::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::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>,
                                       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>>);
-
-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>>);
+  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<(si::metre), ground_level>, quantity_point<(isq::height[m]), ground_level>>);
+  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<(si::metre), ground_level>>);
+  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<(si::metre), ground_level>>);
+  std::constructible_from<quantity_point<isq::height[m], ground_level>, quantity_point<isq::height[km], ground_level>>);
 static_assert(
-  std::convertible_to<quantity_point<(si::metre), ground_level>, quantity_point<(isq::height[m]), ground_level>>);
+  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>,
+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>,
                                       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>>);
@@ -692,121 +682,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<(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>,
+                                      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<isq::height[m], 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::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>>);
 
-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<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>>);
+
+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::convertible_to<sys_seconds, quantity_point<(isq::time[s]), chrono_point_origin<std::chrono::steady_clock>>>);
+  !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>>>);
 #endif
 
 
@@ -835,19 +825,17 @@ 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);
@@ -862,7 +850,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>>);
 
 
 ///////////////////////////////////
@@ -889,8 +877,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>);
 
@@ -938,12 +926,13 @@ static_assert(quantity_point{sys_seconds{24h}}.quantity_spec == kind_of<isq::tim
 ////////////
 // getters
 ////////////
-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;
+
+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;
 
 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);
@@ -968,24 +957,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 QuantityPoint auto l1{mean_sea_level + 1 * m};
-                QuantityPoint auto l2{mean_sea_level + 2 * m};
+                const quantity_point l1{mean_sea_level + 1 * m};
+                quantity_point l2{mean_sea_level + 2 * m};
                 return l2 = l1;
               }())
                 .quantity_from(mean_sea_level) == 1 * m);
 static_assert(([]() {
-                const QuantityPoint auto l1{mean_sea_level + 1 * m};
-                QuantityPoint auto l2{mean_sea_level + 2 * m};
+                const quantity_point l1{mean_sea_level + 1 * m};
+                quantity_point l2{mean_sea_level + 2 * m};
                 return l2 = l1;
               }())
                 .quantity_from(mean_sea_level) == 1 * m);
 static_assert(([]() {
-                QuantityPoint auto l1{mean_sea_level + 1 * m}, l2{mean_sea_level + 2 * m};
+                quantity_point 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);
@@ -998,7 +987,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, mean_sea_level + 123 * m));
+}(mean_sea_level + 123 * m) == std::pair(mean_sea_level + 124 * m, quantity_point(mean_sea_level + 123 * m)));
 static_assert([](auto v) {
   auto vv = ++v;  // NOLINT(bugprone-inc-dec-in-conditions)
   return std::pair(v, vv);
@@ -1031,18 +1020,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>);
 
@@ -1143,12 +1132,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; };
 };
@@ -1185,36 +1174,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,
@@ -1230,25 +1219,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>>);
@@ -1265,39 +1254,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>>);
@@ -1309,32 +1298,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
@@ -1654,8 +1643,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]) + (zero_Hz + 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((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() ==
@@ -1729,7 +1718,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 ed4cb359..ee4e86a8 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 mp_units::dimensionless;
-using dim_one_ = struct mp_units::dimension_one;
+using dimensionless_ = struct dimensionless;
+using dim_one_ = struct 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 44ee65ad..89f169bb 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,46 +163,45 @@ 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::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::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
@@ -220,16 +219,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>>);
 
 
 ///////////////////////////////////
@@ -319,9 +318,9 @@ struct derived_quantity : quantity<Q::reference, Rep> {
     R::operator=(t);
     return *this;
   }
-  constexpr derived_quantity& operator=(R&& other)
+  constexpr derived_quantity& operator=(R&& t)
   {
-    R::operator=(std::move(other));
+    R::operator=(std::move(t));
     return *this;
   }
   // NOLINTBEGIN(google-explicit-constructor, hicpp-explicit-conversions)
@@ -332,9 +331,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;
@@ -363,8 +362,7 @@ 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>);
-// 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(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
@@ -463,10 +461,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>
@@ -852,30 +850,27 @@ 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<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<(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>>);
+  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);
@@ -928,7 +923,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);
@@ -1042,35 +1037,34 @@ 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 46026702..65abe0bb 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 mp_units::dimensionless;
-using one_ = struct mp_units::one;
+using dimensionless_ = struct dimensionless;
+using one_ = struct 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 d52a8edc..4f306fd2 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 c16ea66a..ba7ecb4c 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 mp_units::one;
-using percent_ = struct mp_units::percent;
+using one_ = struct one;
+using percent_ = struct percent;
 
 // base dimensions
 // clang-format off