diff --git a/example/include/validated_type.h b/example/include/validated_type.h
index f37bec12..5e63f792 100644
--- a/example/include/validated_type.h
+++ b/example/include/validated_type.h
@@ -61,7 +61,7 @@ public:
   {
   }
 
-  constexpr explicit(false) operator T() const & noexcept(std::is_nothrow_copy_constructible_v<T>)
+  constexpr explicit(false) operator T() const& noexcept(std::is_nothrow_copy_constructible_v<T>)
     requires std::copyable<T>
   {
     return value_;
diff --git a/src/core/include/units/bits/basic_concepts.h b/src/core/include/units/bits/basic_concepts.h
index ac073b28..397f5137 100644
--- a/src/core/include/units/bits/basic_concepts.h
+++ b/src/core/include/units/bits/basic_concepts.h
@@ -217,14 +217,13 @@ struct point_origin;
  * Satisfied by types derived from an specialization of @c point_origin.
  */
 template<typename T>
-concept PointOrigin = is_derived_from_specialization_of<T, point_origin> &&
-                      requires {
-                        typename T::dimension;
-                        requires Dimension<typename T::dimension>;
-                        typename T::point_origin;
-                        requires std::same_as<typename T::point_origin, point_origin<typename T::dimension>>;
-                        requires !std::same_as<T, point_origin<typename T::dimension>>;
-                      };
+concept PointOrigin = is_derived_from_specialization_of<T, point_origin> && requires {
+  typename T::dimension;
+  requires Dimension<typename T::dimension>;
+  typename T::point_origin;
+  requires std::same_as<typename T::point_origin, point_origin<typename T::dimension>>;
+  requires !std::same_as<T, point_origin<typename T::dimension>>;
+};
 
 // RebindablePointOriginFor
 
@@ -261,10 +260,10 @@ struct _kind_base;
 
 template<typename T, template<typename...> typename Base>
 concept kind_impl_ = is_derived_from_specialization_of<T, Base> && requires {
-                                                                     typename T::base_kind;
-                                                                     typename T::dimension;
-                                                                     requires Dimension<typename T::dimension>;
-                                                                   };
+  typename T::base_kind;
+  typename T::dimension;
+  requires Dimension<typename T::dimension>;
+};
 
 /**
  * @brief A concept matching all kind types
@@ -389,12 +388,12 @@ concept QuantityPointLike = detail::is_quantity_point_like<T>;
 
 template<typename T, typename U>
 concept common_type_with_ =  // exposition only
-  (std::same_as<std::common_type_t<T, U>, std::common_type_t<U, T>>) &&
-  (std::constructible_from<std::common_type_t<T, U>, T>) && (std::constructible_from<std::common_type_t<T, U>, U>);
+  (std::same_as<std::common_type_t<T, U>, std::common_type_t<U, T>>)&&(
+    std::constructible_from<std::common_type_t<T, U>, T>)&&(std::constructible_from<std::common_type_t<T, U>, U>);
 
 template<typename T, typename U = T>
 concept scalable_number_ =  // exposition only
-  (std::regular_invocable<std::multiplies<>, T, U>) && (std::regular_invocable<std::divides<>, T, U>);
+  (std::regular_invocable<std::multiplies<>, T, U>)&&(std::regular_invocable<std::divides<>, T, U>);
 
 template<typename T>
 concept castable_number_ =  // exposition only
@@ -443,37 +442,36 @@ concept wrapped_quantity_ =  // exposition only
  * Satisfied by types that satisfy `(!Quantity<T>) && (!WrappedQuantity<T>) && std::regular<T>`.
  */
 template<typename T>
-concept Representation = (!Quantity<T>) && (!QuantityLike<T>) &&
-                         (!wrapped_quantity_<T>) && std::regular<T> && scalable_<T>;
+concept Representation = (!Quantity<T>)&&(!QuantityLike<T>)&&(!wrapped_quantity_<T>)&&std::regular<T> && scalable_<T>;
 
 namespace detail {
 
 template<typename T>
   requires requires(T q) {
-             typename quantity_like_traits<T>::dimension;
-             typename quantity_like_traits<T>::unit;
-             typename quantity_like_traits<T>::rep;
-             requires Dimension<typename quantity_like_traits<T>::dimension>;
-             requires Unit<typename quantity_like_traits<T>::unit>;
-             requires Representation<typename quantity_like_traits<T>::rep>;
-             {
-               quantity_like_traits<T>::number(q)
-               } -> std::convertible_to<typename quantity_like_traits<T>::rep>;
-           }
+    typename quantity_like_traits<T>::dimension;
+    typename quantity_like_traits<T>::unit;
+    typename quantity_like_traits<T>::rep;
+    requires Dimension<typename quantity_like_traits<T>::dimension>;
+    requires Unit<typename quantity_like_traits<T>::unit>;
+    requires Representation<typename quantity_like_traits<T>::rep>;
+    {
+      quantity_like_traits<T>::number(q)
+    } -> std::convertible_to<typename quantity_like_traits<T>::rep>;
+  }
 inline constexpr bool is_quantity_like<T> = true;
 
 template<typename T>
   requires requires(T q) {
-             typename quantity_point_like_traits<T>::dimension;
-             typename quantity_point_like_traits<T>::unit;
-             typename quantity_point_like_traits<T>::rep;
-             requires Dimension<typename quantity_point_like_traits<T>::dimension>;
-             requires Unit<typename quantity_point_like_traits<T>::unit>;
-             requires Representation<typename quantity_point_like_traits<T>::rep>;
-             {
-               quantity_point_like_traits<T>::relative(q)
-               } -> QuantityLike;
-           }
+    typename quantity_point_like_traits<T>::dimension;
+    typename quantity_point_like_traits<T>::unit;
+    typename quantity_point_like_traits<T>::rep;
+    requires Dimension<typename quantity_point_like_traits<T>::dimension>;
+    requires Unit<typename quantity_point_like_traits<T>::unit>;
+    requires Representation<typename quantity_point_like_traits<T>::rep>;
+    {
+      quantity_point_like_traits<T>::relative(q)
+    } -> QuantityLike;
+  }
 inline constexpr bool is_quantity_point_like<T> = true;
 
 }  // namespace detail
diff --git a/src/core/include/units/customization_points.h b/src/core/include/units/customization_points.h
index 54bd9c35..106faffb 100644
--- a/src/core/include/units/customization_points.h
+++ b/src/core/include/units/customization_points.h
@@ -69,20 +69,20 @@ struct quantity_values {
 
   static constexpr Rep min() noexcept
     requires requires {
-               {
-                 std::numeric_limits<Rep>::lowest()
-                 } -> std::same_as<Rep>;
-             }
+      {
+        std::numeric_limits<Rep>::lowest()
+      } -> std::same_as<Rep>;
+    }
   {
     return std::numeric_limits<Rep>::lowest();
   }
 
   static constexpr Rep max() noexcept
     requires requires {
-               {
-                 std::numeric_limits<Rep>::max()
-                 } -> std::same_as<Rep>;
-             }
+      {
+        std::numeric_limits<Rep>::max()
+      } -> std::same_as<Rep>;
+    }
   {
     return std::numeric_limits<Rep>::max();
   }
diff --git a/src/core/include/units/magnitude.h b/src/core/include/units/magnitude.h
index 2760ee33..f565e80d 100644
--- a/src/core/include/units/magnitude.h
+++ b/src/core/include/units/magnitude.h
@@ -313,11 +313,9 @@ struct pairwise_all {
     }(sizeof...(Ts));
 
     // Compare zero or more pairs of neighbours as needed.
-    return [this]<std::size_t... Is>(std::tuple<Ts...> && t, std::index_sequence<Is...>)
-    {
+    return [this]<std::size_t... Is>(std::tuple<Ts...>&& t, std::index_sequence<Is...>) {
       return (predicate(std::get<Is>(t), std::get<Is + 1>(t)) && ...);
-    }
-    (std::make_tuple(std::forward<Ts>(ts)...), std::make_index_sequence<num_comparisons>());
+    }(std::make_tuple(std::forward<Ts>(ts)...), std::make_index_sequence<num_comparisons>());
   }
 };
 
diff --git a/src/core/include/units/math.h b/src/core/include/units/math.h
index 20a111d2..cc86712b 100644
--- a/src/core/include/units/math.h
+++ b/src/core/include/units/math.h
@@ -159,9 +159,9 @@ template<Unit To, typename D, typename U, typename Rep>
   requires((!treat_as_floating_point<Rep>) || requires { floor(q.number()); } ||
            requires { std::floor(q.number()); }) &&
           (std::same_as<To, U> || requires {
-                                    ::units::quantity_cast<To>(q);
-                                    quantity<D, To, Rep>::one();
-                                  })
+            ::units::quantity_cast<To>(q);
+            quantity<D, To, Rep>::one();
+          })
 {
   const auto handle_signed_results = [&]<typename T>(const T& res) {
     if (res > q) {
@@ -208,9 +208,9 @@ template<Unit To, typename D, typename U, typename Rep>
 [[nodiscard]] constexpr quantity<D, To, Rep> ceil(const quantity<D, U, Rep>& q) noexcept
   requires((!treat_as_floating_point<Rep>) || requires { ceil(q.number()); } || requires { std::ceil(q.number()); }) &&
           (std::same_as<To, U> || requires {
-                                    ::units::quantity_cast<To>(q);
-                                    quantity<D, To, Rep>::one();
-                                  })
+            ::units::quantity_cast<To>(q);
+            quantity<D, To, Rep>::one();
+          })
 {
   const auto handle_signed_results = [&]<typename T>(const T& res) {
     if (res < q) {
@@ -260,9 +260,9 @@ template<Unit To, typename D, typename U, typename Rep>
   requires((!treat_as_floating_point<Rep>) || requires { round(q.number()); } ||
            requires { std::round(q.number()); }) &&
           (std::same_as<To, U> || requires {
-                                    ::units::floor<To>(q);
-                                    quantity<D, To, Rep>::one();
-                                  })
+            ::units::floor<To>(q);
+            quantity<D, To, Rep>::one();
+          })
 {
   if constexpr (std::is_same_v<To, U>) {
     if constexpr (treat_as_floating_point<Rep>) {
@@ -308,10 +308,9 @@ template<Quantity To, std::same_as<typename To::dimension> D, typename U, std::s
  */
 template<Quantity Q1, Quantity Q2>
 [[nodiscard]] inline std::common_type_t<Q1, Q2> hypot(const Q1& x, const Q2& y) noexcept
-  requires requires { typename std::common_type_t<Q1, Q2>; } &&
-           requires(std::common_type_t<Q1, Q2> q) {
-             requires requires { hypot(q.number(), q.number()); } || requires { std::hypot(q.number(), q.number()); };
-           }
+  requires requires { typename std::common_type_t<Q1, Q2>; } && requires(std::common_type_t<Q1, Q2> q) {
+    requires requires { hypot(q.number(), q.number()); } || requires { std::hypot(q.number(), q.number()); };
+  }
 {
   using type = std::common_type_t<Q1, Q2>;
   type xx = x;
@@ -326,11 +325,10 @@ template<Quantity Q1, Quantity Q2>
  */
 template<Quantity Q1, Quantity Q2, Quantity Q3>
 [[nodiscard]] inline std::common_type_t<Q1, Q2, Q3> hypot(const Q1& x, const Q2& y, const Q3& z) noexcept
-  requires requires { typename std::common_type_t<Q1, Q2, Q3>; } &&
-           requires(std::common_type_t<Q1, Q2, Q3> q) {
-             requires requires { hypot(q.number(), q.number(), q.number()); } ||
-                        requires { std::hypot(q.number(), q.number(), q.number()); };
-           }
+  requires requires { typename std::common_type_t<Q1, Q2, Q3>; } && requires(std::common_type_t<Q1, Q2, Q3> q) {
+    requires requires { hypot(q.number(), q.number(), q.number()); } ||
+               requires { std::hypot(q.number(), q.number(), q.number()); };
+  }
 {
   using type = std::common_type_t<Q1, Q2, Q3>;
   type xx = x;
diff --git a/src/core/include/units/quantity.h b/src/core/include/units/quantity.h
index 25ad6fd7..306e460b 100644
--- a/src/core/include/units/quantity.h
+++ b/src/core/include/units/quantity.h
@@ -51,8 +51,8 @@ inline constexpr auto make_quantity = [](auto&& v) {
 template<typename T>
 concept quantity_one =
   Quantity<T> &&
-  (std::same_as<typename T::dimension, dim_one> || std::same_as<typename T::dimension, unknown_dimension<>>) &&
-  detail::equivalent_unit<typename T::unit, typename T::dimension, ::units::one, typename T::dimension>::value;
+  (std::same_as<typename T::dimension, dim_one> || std::same_as<typename T::dimension, unknown_dimension<>>)&&detail::
+    equivalent_unit<typename T::unit, typename T::dimension, ::units::one, typename T::dimension>::value;
 
 }  // namespace detail
 
@@ -62,7 +62,7 @@ concept floating_point_ =  // exposition only
 
 template<typename From, typename To>
 concept safe_convertible_to_ =  // exposition only
-  (!Quantity<From>) && (!Quantity<To>) && std::convertible_to<From, To> &&
+  (!Quantity<From>)&&(!Quantity<To>)&&std::convertible_to<From, To> &&
   (floating_point_<To> || (!floating_point_<From>));
 
 // QFrom ratio is an exact multiple of QTo
@@ -84,7 +84,7 @@ concept invoke_result_convertible_to_ =
   Representation<T> && quantity_value_for_<Func, U, V> && safe_convertible_to_<T, std::invoke_result_t<Func, U, V>>;
 
 template<typename Func, typename Q, typename V>
-concept have_quantity_for_ = Quantity<Q> && (!Quantity<V>) && quantity_value_for_<Func, typename Q::rep, V>;
+concept have_quantity_for_ = Quantity<Q> && (!Quantity<V>)&&quantity_value_for_<Func, typename Q::rep, V>;
 
 template<QuantityLike Q>
 using quantity_like_type = quantity<typename quantity_like_traits<Q>::dimension, typename quantity_like_traits<Q>::unit,
@@ -169,10 +169,10 @@ public:
   // member unary operators
   [[nodiscard]] constexpr Quantity auto operator+() const
     requires requires(rep v) {
-               {
-                 +v
-                 } -> std::common_with<rep>;
-             }
+      {
+        +v
+      } -> std::common_with<rep>;
+    }
   {
     using ret = quantity<D, U, decltype(+number())>;
     return ret(+number());
@@ -187,10 +187,10 @@ public:
 
   constexpr quantity& operator++()
     requires requires(rep v) {
-               {
-                 ++v
-                 } -> std::same_as<rep&>;
-             }
+      {
+        ++v
+      } -> std::same_as<rep&>;
+    }
   {
     ++number_;
     return *this;
@@ -198,20 +198,20 @@ public:
 
   [[nodiscard]] constexpr quantity operator++(int)
     requires requires(rep v) {
-               {
-                 v++
-                 } -> std::same_as<rep>;
-             }
+      {
+        v++
+      } -> std::same_as<rep>;
+    }
   {
     return quantity(number_++);
   }
 
   constexpr quantity& operator--()
     requires requires(rep v) {
-               {
-                 --v
-                 } -> std::same_as<rep&>;
-             }
+      {
+        --v
+      } -> std::same_as<rep&>;
+    }
   {
     --number_;
     return *this;
@@ -219,20 +219,20 @@ public:
 
   [[nodiscard]] constexpr quantity operator--(int)
     requires requires(rep v) {
-               {
-                 v--
-                 } -> std::same_as<rep>;
-             }
+      {
+        v--
+      } -> std::same_as<rep>;
+    }
   {
     return quantity(number_--);
   }
 
   constexpr quantity& operator+=(const quantity& q)
     requires requires(rep a, rep b) {
-               {
-                 a += b
-                 } -> std::same_as<rep&>;
-             }
+      {
+        a += b
+      } -> std::same_as<rep&>;
+    }
   {
     number_ += q.number();
     return *this;
@@ -240,10 +240,10 @@ public:
 
   constexpr quantity& operator-=(const quantity& q)
     requires requires(rep a, rep b) {
-               {
-                 a -= b
-                 } -> std::same_as<rep&>;
-             }
+      {
+        a -= b
+      } -> std::same_as<rep&>;
+    }
   {
     number_ -= q.number();
     return *this;
@@ -252,10 +252,10 @@ public:
   template<typename Rep2>
   constexpr quantity& operator*=(const Rep2& rhs)
     requires requires(rep a, const Rep2 b) {
-               {
-                 a *= b
-                 } -> std::same_as<rep&>;
-             }
+      {
+        a *= b
+      } -> std::same_as<rep&>;
+    }
   {
     number_ *= rhs;
     return *this;
@@ -263,10 +263,10 @@ public:
   template<detail::quantity_one Q>
   constexpr quantity& operator*=(const Q& rhs)
     requires requires(rep a, const typename Q::rep b) {
-               {
-                 a *= b
-                 } -> std::same_as<rep&>;
-             }
+      {
+        a *= b
+      } -> std::same_as<rep&>;
+    }
   {
     number_ *= rhs.number();
     return *this;
@@ -275,10 +275,10 @@ public:
   template<typename Rep2>
   constexpr quantity& operator/=(const Rep2& rhs)
     requires requires(rep a, const Rep2 b) {
-               {
-                 a /= b
-                 } -> std::same_as<rep&>;
-             }
+      {
+        a /= b
+      } -> std::same_as<rep&>;
+    }
   {
     gsl_ExpectsAudit(rhs != quantity_values<Rep2>::zero());
     number_ /= rhs;
@@ -287,10 +287,10 @@ public:
   template<detail::quantity_one Q>
   constexpr quantity& operator/=(const Q& rhs)
     requires requires(rep a, const typename Q::rep b) {
-               {
-                 a /= b
-                 } -> std::same_as<rep&>;
-             }
+      {
+        a /= b
+      } -> std::same_as<rep&>;
+    }
   {
     gsl_ExpectsAudit(rhs.number() != quantity_values<typename Q::rep>::zero());
     number_ /= rhs.number();
@@ -300,10 +300,10 @@ public:
   template<typename Rep2>
   constexpr quantity& operator%=(const Rep2& rhs)
     requires(!floating_point_<rep>) && (!floating_point_<Rep2>) && requires(rep a, const Rep2 b) {
-                                                                     {
-                                                                       a %= b
-                                                                       } -> std::same_as<rep&>;
-                                                                   }
+      {
+        a %= b
+      } -> std::same_as<rep&>;
+    }
   {
     gsl_ExpectsAudit(rhs != quantity_values<Rep2>::zero());
     number_ %= rhs;
@@ -313,10 +313,10 @@ public:
   template<detail::quantity_one Q>
   constexpr quantity& operator%=(const Q& rhs)
     requires(!floating_point_<rep>) && (!floating_point_<typename Q::rep>) && requires(rep a, const typename Q::rep b) {
-                                                                                {
-                                                                                  a %= b
-                                                                                  } -> std::same_as<rep&>;
-                                                                              }
+      {
+        a %= b
+      } -> std::same_as<rep&>;
+    }
   {
     gsl_ExpectsAudit(rhs.number() != quantity_values<typename Q::rep>::zero());
     number_ %= rhs.number();
@@ -325,10 +325,10 @@ public:
 
   constexpr quantity& operator%=(const quantity& q)
     requires(!floating_point_<rep>) && requires(rep a, rep b) {
-                                         {
-                                           a %= b
-                                           } -> std::same_as<rep&>;
-                                       }
+      {
+        a %= b
+      } -> std::same_as<rep&>;
+    }
   {
     gsl_ExpectsAudit(q.number() != quantity_values<rep>::zero());
     number_ %= q.number();
@@ -340,20 +340,20 @@ public:
   template<typename Value>
   [[nodiscard]] friend constexpr Quantity auto operator+(const quantity& lhs, const Value& rhs)
     requires requires {  // TODO: Simplify when Clang catches up.
-               requires !Quantity<Value>;
-               requires is_same_v<unit, units::one>;
-               requires invoke_result_convertible_to_<rep, std::plus<>, rep, Value>;
-             }
+      requires !Quantity<Value>;
+      requires is_same_v<unit, units::one>;
+      requires invoke_result_convertible_to_<rep, std::plus<>, rep, Value>;
+    }
   {
     return units::quantity(lhs.number() + rhs);
   }
   template<typename Value>
   [[nodiscard]] friend constexpr Quantity auto operator+(const Value& lhs, const quantity& rhs)
     requires requires {  // TODO: Simplify when Clang catches up.
-               requires !Quantity<Value>;
-               requires is_same_v<unit, units::one>;
-               requires invoke_result_convertible_to_<rep, std::plus<>, Value, rep>;
-             }
+      requires !Quantity<Value>;
+      requires is_same_v<unit, units::one>;
+      requires invoke_result_convertible_to_<rep, std::plus<>, Value, rep>;
+    }
   {
     return units::quantity(lhs + rhs.number());
   }
@@ -361,20 +361,20 @@ public:
   template<typename Value>
   [[nodiscard]] friend constexpr Quantity auto operator-(const quantity& lhs, const Value& rhs)
     requires requires {  // TODO: Simplify when Clang catches up.
-               requires !Quantity<Value>;
-               requires is_same_v<unit, units::one>;
-               requires invoke_result_convertible_to_<rep, std::minus<>, rep, Value>;
-             }
+      requires !Quantity<Value>;
+      requires is_same_v<unit, units::one>;
+      requires invoke_result_convertible_to_<rep, std::minus<>, rep, Value>;
+    }
   {
     return units::quantity(lhs.number() - rhs);
   }
   template<typename Value>
   [[nodiscard]] friend constexpr Quantity auto operator-(const Value& lhs, const quantity& rhs)
     requires requires {  // TODO: Simplify when Clang catches up.
-               requires !Quantity<Value>;
-               requires is_same_v<unit, units::one>;
-               requires invoke_result_convertible_to_<rep, std::minus<>, Value, rep>;
-             }
+      requires !Quantity<Value>;
+      requires is_same_v<unit, units::one>;
+      requires invoke_result_convertible_to_<rep, std::minus<>, Value, rep>;
+    }
   {
     return units::quantity(lhs - rhs.number());
   }
@@ -445,14 +445,14 @@ public:
 // CTAD
 #if !UNITS_COMP_CLANG || UNITS_COMP_CLANG > 17
 template<typename D, typename U, typename Rep>
-explicit(false) quantity(Rep&&)->quantity<D, U, Rep>;
+explicit(false) quantity(Rep&&) -> quantity<D, U, Rep>;
 #endif
 
 template<typename D, typename U, typename Rep>
-explicit(false) quantity(quantity<D, U, Rep>)->quantity<D, U, Rep>;
+explicit(false) quantity(quantity<D, U, Rep>) -> quantity<D, U, Rep>;
 
 template<Representation Rep>
-explicit(false) quantity(Rep)->quantity<dim_one, one, Rep>;
+explicit(false) quantity(Rep) -> quantity<dim_one, one, Rep>;
 
 template<QuantityLike Q>
 explicit quantity(Q) -> quantity<typename quantity_like_traits<Q>::dimension, typename quantity_like_traits<Q>::unit,
diff --git a/src/core/include/units/quantity_cast.h b/src/core/include/units/quantity_cast.h
index 4449d722..8faf23e1 100644
--- a/src/core/include/units/quantity_cast.h
+++ b/src/core/include/units/quantity_cast.h
@@ -213,10 +213,10 @@ template<Representation ToRep, typename D, typename U, scalable_with_<ToRep> Rep
 template<typename CastSpec, typename O, typename U, typename Rep>
 [[nodiscard]] constexpr auto quantity_point_cast(const quantity_point<O, U, Rep>& qp)
   requires requires {
-             requires is_specialization_of<CastSpec, quantity_point>;
-             requires requires { quantity_cast<typename CastSpec::quantity_type>(qp.relative()); };
-             requires equivalent<O, typename CastSpec::origin>;
-           } ||  // TODO: Simplify when Clang catches up.
+    requires is_specialization_of<CastSpec, quantity_point>;
+    requires requires { quantity_cast<typename CastSpec::quantity_type>(qp.relative()); };
+    requires equivalent<O, typename CastSpec::origin>;
+  } ||  // TODO: Simplify when Clang catches up.
            requires { quantity_cast<CastSpec>(qp.relative()); }
 {
   if constexpr (is_specialization_of<CastSpec, quantity_point>)
@@ -268,12 +268,12 @@ template<Dimension ToD, Unit ToU, typename O, typename U, typename Rep>
 template<typename CastSpec, typename K, typename U, typename Rep>
 [[nodiscard]] constexpr QuantityKind auto quantity_kind_cast(const quantity_kind<K, U, Rep>& qk)
   requires requires {
-             requires is_specialization_of<CastSpec, quantity_kind>;
-             requires requires { quantity_cast<typename CastSpec::quantity_type>(qk.common()); };
-           } || requires {
-                  requires Kind<CastSpec>;
-                  requires UnitOf<U, typename CastSpec::dimension>;
-                } || requires { quantity_cast<CastSpec>(qk.common()); }  // TODO: Simplify when Clang catches up.
+    requires is_specialization_of<CastSpec, quantity_kind>;
+    requires requires { quantity_cast<typename CastSpec::quantity_type>(qk.common()); };
+  } || requires {
+    requires Kind<CastSpec>;
+    requires UnitOf<U, typename CastSpec::dimension>;
+  } || requires { quantity_cast<CastSpec>(qk.common()); }  // TODO: Simplify when Clang catches up.
 {
   if constexpr (is_specialization_of<CastSpec, quantity_kind>)
     return CastSpec(quantity_cast<typename CastSpec::quantity_type>(qk.common()));
@@ -331,10 +331,10 @@ template<Kind ToK, Unit ToU, typename K, typename U, typename Rep>
 template<typename CastSpec, typename PK, typename U, typename Rep>
 [[nodiscard]] constexpr QuantityPointKind auto quantity_point_kind_cast(const quantity_point_kind<PK, U, Rep>& qpk)
   requires requires {
-             requires is_specialization_of<CastSpec, quantity_point_kind>;
-             requires requires { quantity_kind_cast<typename CastSpec::quantity_kind_type>(qpk.relative()); };
-             requires equivalent<typename PK::origin, typename CastSpec::point_kind_type::origin>;
-           } || requires { requires PointKind<CastSpec> && UnitOf<U, typename CastSpec::dimension>; } ||
+    requires is_specialization_of<CastSpec, quantity_point_kind>;
+    requires requires { quantity_kind_cast<typename CastSpec::quantity_kind_type>(qpk.relative()); };
+    requires equivalent<typename PK::origin, typename CastSpec::point_kind_type::origin>;
+  } || requires { requires PointKind<CastSpec> && UnitOf<U, typename CastSpec::dimension>; } ||
            requires { quantity_kind_cast<CastSpec>(qpk.relative()); }  // TODO: Simplify when Clang catches up.
 {
   if constexpr (is_specialization_of<CastSpec, quantity_point_kind>)
diff --git a/src/core/include/units/quantity_kind.h b/src/core/include/units/quantity_kind.h
index a47fd547..e806074f 100644
--- a/src/core/include/units/quantity_kind.h
+++ b/src/core/include/units/quantity_kind.h
@@ -250,10 +250,10 @@ public:
   template<Representation Value>
   [[nodiscard]] friend constexpr QuantityKind auto operator*(const quantity_kind& qk, const Value& v)
     requires requires(quantity_type q) {
-               {
-                 q* v
-                 } -> Quantity;
-             }
+      {
+        q* v
+      } -> Quantity;
+    }
   {
     return detail::make_quantity_kind<quantity_kind>(qk.common() * v);
   }
@@ -261,10 +261,10 @@ public:
   template<Representation Value>
   [[nodiscard]] friend constexpr QuantityKind auto operator*(const Value& v, const quantity_kind& qk)
     requires requires(quantity_type q) {
-               {
-                 v* q
-                 } -> Quantity;
-             }
+      {
+        v* q
+      } -> Quantity;
+    }
   {
     return detail::make_quantity_kind<quantity_kind>(v * qk.common());
   }
@@ -272,10 +272,10 @@ public:
   template<Representation Value>
   [[nodiscard]] friend constexpr QuantityKind auto operator/(const quantity_kind& qk, const Value& v)
     requires requires(quantity_type q) {
-               {
-                 q / v
-                 } -> Quantity;
-             }
+      {
+        q / v
+      } -> Quantity;
+    }
   {
     gsl_ExpectsAudit(v != quantity_values<Value>::zero());
     return detail::make_quantity_kind<quantity_kind>(qk.common() / v);
@@ -284,10 +284,10 @@ public:
   template<Representation Value>
   [[nodiscard]] friend constexpr QuantityKind auto operator/(const Value& v, const quantity_kind& qk)
     requires requires(quantity_type q) {
-               {
-                 v / q
-                 } -> Quantity;
-             }
+      {
+        v / q
+      } -> Quantity;
+    }
   {
     gsl_ExpectsAudit(qk.common().number() != quantity_values<rep>::zero());
     return detail::downcasted_kind<quantity_kind>(v / qk.common());
diff --git a/src/core/include/units/symbol_text.h b/src/core/include/units/symbol_text.h
index 6eb71e6d..5ca2d12d 100644
--- a/src/core/include/units/symbol_text.h
+++ b/src/core/include/units/symbol_text.h
@@ -162,7 +162,7 @@ struct basic_symbol_text {
   }
 };
 
-basic_symbol_text(char)->basic_symbol_text<char, 1, 1>;
+basic_symbol_text(char) -> basic_symbol_text<char, 1, 1>;
 
 template<typename StandardCharT>
 basic_symbol_text(StandardCharT, char) -> basic_symbol_text<StandardCharT, 1, 1>;
diff --git a/src/core/include/units/unit.h b/src/core/include/units/unit.h
index c388369c..f6a3aba1 100644
--- a/src/core/include/units/unit.h
+++ b/src/core/include/units/unit.h
@@ -211,7 +211,7 @@ template<typename U, typename P, typename AU>
 void is_named_impl(const volatile prefixed_alias_unit<U, P, AU>*);
 
 template<Unit U>
-inline constexpr bool is_named<U> = requires(U * u) { is_named_impl(u); };
+inline constexpr bool is_named<U> = requires(U* u) { is_named_impl(u); };
 
 template<typename Child, basic_symbol_text Symbol>
 void can_be_prefixed_impl(const volatile named_unit<Child, Symbol>*);
@@ -223,7 +223,7 @@ template<typename U, basic_symbol_text Symbol>
 void can_be_prefixed_impl(const volatile alias_unit<U, Symbol>*);
 
 template<Unit U>
-inline constexpr bool can_be_prefixed<U> = requires(U * u) { can_be_prefixed_impl(u); };
+inline constexpr bool can_be_prefixed<U> = requires(U* u) { can_be_prefixed_impl(u); };
 
 template<Magnitude auto M, typename U>
 inline constexpr bool can_be_prefixed<scaled_unit<M, U>> = can_be_prefixed<typename U::reference>;
diff --git a/test/unit_test/runtime/almost_equals.h b/test/unit_test/runtime/almost_equals.h
index 561fc08a..19d4ed8e 100644
--- a/test/unit_test/runtime/almost_equals.h
+++ b/test/unit_test/runtime/almost_equals.h
@@ -31,8 +31,8 @@ struct AlmostEqualsMatcher : Catch::Matchers::MatcherGenericBase {
   AlmostEqualsMatcher(const T& target) : target_{target} {}
 
   template<QuantityEquivalentTo<T> U>
-    requires std::same_as<typename T::rep, typename U::rep> && treat_as_floating_point<typename T::rep> bool
-  match(const U& other) const
+    requires std::same_as<typename T::rep, typename U::rep> && treat_as_floating_point<typename T::rep>
+  bool match(const U& other) const
   {
     using std::abs;
     using common = std::common_type_t<T, U>;
diff --git a/test/unit_test/static/custom_rep_test_min_expl.cpp b/test/unit_test/static/custom_rep_test_min_expl.cpp
index b1f367c1..689c9666 100644
--- a/test/unit_test/static/custom_rep_test_min_expl.cpp
+++ b/test/unit_test/static/custom_rep_test_min_expl.cpp
@@ -187,42 +187,42 @@ static_assert(!Representation<min_expl<9>>);
 // quantity's operators should mirror the representation type capabilities
 template<typename Rep>
 concept invalid_member_operations = requires(length<metre, Rep> lhs) {
-                                      requires !requires { +lhs; };
-                                      requires !requires { -lhs; };
-                                      requires !requires { ++lhs; };
-                                      requires !requires { lhs++; };
-                                      requires !requires { --lhs; };
-                                      requires !requires { lhs--; };
+  requires !requires { +lhs; };
+  requires !requires { -lhs; };
+  requires !requires { ++lhs; };
+  requires !requires { lhs++; };
+  requires !requires { --lhs; };
+  requires !requires { lhs--; };
 
-                                      requires !requires(length<metre, Rep> rhs) { lhs += rhs; };
-                                      requires !requires(length<metre, Rep> rhs) { lhs -= rhs; };
-                                      requires !requires(Rep rhs) { lhs *= rhs; };
-                                      requires !requires(Rep rhs) { lhs /= rhs; };
-                                      requires !requires(Rep rhs) { lhs %= rhs; };
-                                      requires !requires(length<metre, Rep> rhs) { lhs %= rhs; };
+  requires !requires(length<metre, Rep> rhs) { lhs += rhs; };
+  requires !requires(length<metre, Rep> rhs) { lhs -= rhs; };
+  requires !requires(Rep rhs) { lhs *= rhs; };
+  requires !requires(Rep rhs) { lhs /= rhs; };
+  requires !requires(Rep rhs) { lhs %= rhs; };
+  requires !requires(length<metre, Rep> rhs) { lhs %= rhs; };
 
-                                      requires !requires(length<metre, Rep> rhs) { lhs + rhs; };
-                                      requires !requires(length<metre, Rep> rhs) { lhs - rhs; };
-                                      requires !requires(Rep rhs) { lhs % rhs; };
-                                      requires !requires(length<metre, Rep> rhs) { lhs % rhs; };
-                                      requires !requires(length<metre, Rep> rhs) { lhs < rhs; };
-                                      requires !requires(length<metre, Rep> rhs) { lhs > rhs; };
-                                      requires !requires(length<metre, Rep> rhs) { lhs <= rhs; };
-                                      requires !requires(length<metre, Rep> rhs) { lhs >= rhs; };
+  requires !requires(length<metre, Rep> rhs) { lhs + rhs; };
+  requires !requires(length<metre, Rep> rhs) { lhs - rhs; };
+  requires !requires(Rep rhs) { lhs % rhs; };
+  requires !requires(length<metre, Rep> rhs) { lhs % rhs; };
+  requires !requires(length<metre, Rep> rhs) { lhs < rhs; };
+  requires !requires(length<metre, Rep> rhs) { lhs > rhs; };
+  requires !requires(length<metre, Rep> rhs) { lhs <= rhs; };
+  requires !requires(length<metre, Rep> rhs) { lhs >= rhs; };
 
-                                      requires !requires(length<metre, int> rhs) { lhs + rhs; };
-                                      requires !requires(length<metre, int> rhs) { lhs - rhs; };
-                                      requires !requires(int rhs) { lhs % rhs; };
-                                      requires !requires(length<metre, int> rhs) { lhs % rhs; };
-                                      requires !requires(length<metre, int> rhs) { lhs == rhs; };
-                                      requires !requires(length<metre, int> rhs) { lhs != rhs; };
-                                      requires !requires(length<metre, int> rhs) { lhs < rhs; };
-                                      requires !requires(length<metre, int> rhs) { lhs > rhs; };
-                                      requires !requires(length<metre, int> rhs) { lhs <= rhs; };
-                                      requires !requires(length<metre, int> rhs) { lhs >= rhs; };
+  requires !requires(length<metre, int> rhs) { lhs + rhs; };
+  requires !requires(length<metre, int> rhs) { lhs - rhs; };
+  requires !requires(int rhs) { lhs % rhs; };
+  requires !requires(length<metre, int> rhs) { lhs % rhs; };
+  requires !requires(length<metre, int> rhs) { lhs == rhs; };
+  requires !requires(length<metre, int> rhs) { lhs != rhs; };
+  requires !requires(length<metre, int> rhs) { lhs < rhs; };
+  requires !requires(length<metre, int> rhs) { lhs > rhs; };
+  requires !requires(length<metre, int> rhs) { lhs <= rhs; };
+  requires !requires(length<metre, int> rhs) { lhs >= rhs; };
 
-                                      requires !requires(std::ostream os) { os << lhs; };
-                                    };
+  requires !requires(std::ostream os) { os << lhs; };
+};
 static_assert(invalid_member_operations<min_expl<>>);
 
 // equality
diff --git a/test/unit_test/static/quantity_kind_test.cpp b/test/unit_test/static/quantity_kind_test.cpp
index 1d246f23..7ff5786c 100644
--- a/test/unit_test/static/quantity_kind_test.cpp
+++ b/test/unit_test/static/quantity_kind_test.cpp
@@ -110,17 +110,16 @@ static_assert(sizeof(width<metre, double>) == sizeof(double));
 static_assert(sizeof(height<metre, short>) == sizeof(short));
 
 template<typename Width>
-concept invalid_types =
-  requires {
-    requires !requires { typename quantity_kind<Width, second, int>; };           // unit of a different dimension
-    requires !requires { typename quantity_kind<Width, metre, length<metre>>; };  // quantity used as Rep
-    requires !requires {                                                          // quantity point used as Rep
-                typename quantity_kind<Width, metre, quantity_point<dynamic_origin<dim_length>, metre>>;
-              };
-    requires !requires { typename quantity_kind<Width, metre, width<metre>>; };  // quantity kind used as Rep
-    requires !requires { typename quantity_kind<metre, Width, double>; };        // reordered arguments
-    requires !requires { typename quantity_kind<metre, double, Width>; };        // reordered arguments
+concept invalid_types = requires {
+  requires !requires { typename quantity_kind<Width, second, int>; };           // unit of a different dimension
+  requires !requires { typename quantity_kind<Width, metre, length<metre>>; };  // quantity used as Rep
+  requires !requires {                                                          // quantity point used as Rep
+    typename quantity_kind<Width, metre, quantity_point<dynamic_origin<dim_length>, metre>>;
   };
+  requires !requires { typename quantity_kind<Width, metre, width<metre>>; };  // quantity kind used as Rep
+  requires !requires { typename quantity_kind<metre, Width, double>; };        // reordered arguments
+  requires !requires { typename quantity_kind<metre, double, Width>; };        // reordered arguments
+};
 static_assert(invalid_types<width_kind>);
 
 static_assert(std::is_trivially_default_constructible_v<width<metre>>);
@@ -437,39 +436,38 @@ static_assert(same((-width<metre, short>(short{1} * m)).common(), int{-1} * m));
 
 template<typename K, typename U, typename Qx>
 concept invalid_compound_assignments_ = requires(quantity_kind<K, U, int> w, Qx q) {
-                                          requires !requires { w += q; };
-                                          requires !requires { w -= q; };
-                                          requires !requires { w *= q; };
-                                          requires !requires { w /= q; };
-                                          requires !requires { w %= q; };
-                                        };
+  requires !requires { w += q; };
+  requires !requires { w -= q; };
+  requires !requires { w *= q; };
+  requires !requires { w /= q; };
+  requires !requires { w %= q; };
+};
 template<typename Width>
-concept invalid_compound_assignments =
-  requires(quantity_kind<Width, metre, int> w, height<metre, int> h) {
-    requires !requires { w += 1; };
-    requires !requires { w -= 1; };
-    requires !requires { w *= 1 * (km / m); };
-    requires !requires { w /= 1 * (km / m); };
-    requires !requires { w %= 1 * (km / m); };
-    requires !requires { w += m; };
-    requires !requires { w -= m; };
-    requires !requires { w *= m; };
-    requires !requires { w /= m; };
-    requires !requires { w %= m; };
-    requires !requires { w *= quantity_kind<downcast_kind<Width, dim_one>, scaled_unit<mag<1000>(), one>, int>{1}; };
-    requires !requires { w /= quantity_kind<downcast_kind<Width, dim_one>, scaled_unit<mag<1000>(), one>, int>{1}; };
-    requires !requires { w %= quantity_kind<downcast_kind<Width, dim_one>, scaled_unit<mag<1000>(), one>, int>{1}; };
-    requires !requires { w %= 1.0; };
-    requires !requires { w %= quantity(1.0); };
-    requires !requires { w %= 1.0 * (w / w); };
-    requires !requires { w %= 1.0 * w; };
-    requires !requires { w %= h / h; };
-    requires invalid_compound_assignments_<Width, metre, length<metre, int>>;
-    requires invalid_compound_assignments_<Width, metre, height<metre, int>>;
-    requires invalid_compound_assignments_<Width, metre, horizontal_area<square_metre, int>>;
-    requires invalid_compound_assignments_<Width, metre, quantity_point<dynamic_origin<dim_length>, metre, int>>;
-    requires invalid_compound_assignments_<Width, metre, std::chrono::seconds>;
-  };
+concept invalid_compound_assignments = requires(quantity_kind<Width, metre, int> w, height<metre, int> h) {
+  requires !requires { w += 1; };
+  requires !requires { w -= 1; };
+  requires !requires { w *= 1 * (km / m); };
+  requires !requires { w /= 1 * (km / m); };
+  requires !requires { w %= 1 * (km / m); };
+  requires !requires { w += m; };
+  requires !requires { w -= m; };
+  requires !requires { w *= m; };
+  requires !requires { w /= m; };
+  requires !requires { w %= m; };
+  requires !requires { w *= quantity_kind<downcast_kind<Width, dim_one>, scaled_unit<mag<1000>(), one>, int>{1}; };
+  requires !requires { w /= quantity_kind<downcast_kind<Width, dim_one>, scaled_unit<mag<1000>(), one>, int>{1}; };
+  requires !requires { w %= quantity_kind<downcast_kind<Width, dim_one>, scaled_unit<mag<1000>(), one>, int>{1}; };
+  requires !requires { w %= 1.0; };
+  requires !requires { w %= quantity(1.0); };
+  requires !requires { w %= 1.0 * (w / w); };
+  requires !requires { w %= 1.0 * w; };
+  requires !requires { w %= h / h; };
+  requires invalid_compound_assignments_<Width, metre, length<metre, int>>;
+  requires invalid_compound_assignments_<Width, metre, height<metre, int>>;
+  requires invalid_compound_assignments_<Width, metre, horizontal_area<square_metre, int>>;
+  requires invalid_compound_assignments_<Width, metre, quantity_point<dynamic_origin<dim_length>, metre, int>>;
+  requires invalid_compound_assignments_<Width, metre, std::chrono::seconds>;
+};
 static_assert(invalid_compound_assignments<width_kind>);
 static_assert(invalid_compound_assignments_<time_kind, second, std::chrono::seconds>);
 
@@ -721,24 +719,24 @@ static_assert(std::equality_comparable_with<width<cgs::centimetre, int>, width<m
 static_assert(std::equality_comparable_with<width<metre>, width<cgs::centimetre>>);
 template<typename Width>
 concept invalid_equality = requires(quantity_kind<Width, metre, int> w) {
-                             requires !requires { w == 1; };
-                             requires !requires { w != 1.0; };
-                             requires !requires { w == 1 * m; };
-                             requires !requires { w != 1.0 * cgs_cm; };
-                             requires !requires { w == 1 * km; };
-                             requires !requires { w != m; };
-                             requires !requires { w == km; };
-                             requires !requires { w != quantity(1); };
-                             requires !requires { w == dimensionless<percent>(1.0); };
-                             requires !requires { w != height<metre, int>(1 * m); };
-                             requires !requires { w == height<kilometre, double>(1.0 * km); };
-                             requires !requires { w != horizontal_area<square_metre, int>(1 * (m * m)); };
-                             requires !requires { w == rate_of_climb<kilometre_per_hour, double>(1.0 * (km / h)); };
-                             requires !requires { w != quantity_point(1 * m); };
-                             requires !requires { w == quantity_point(1.0 * mm); };
-                             requires !requires { w != quantity_point(quantity(1)); };
-                             requires !requires { w == quantity_point(dimensionless<percent>(1.0)); };
-                           };
+  requires !requires { w == 1; };
+  requires !requires { w != 1.0; };
+  requires !requires { w == 1 * m; };
+  requires !requires { w != 1.0 * cgs_cm; };
+  requires !requires { w == 1 * km; };
+  requires !requires { w != m; };
+  requires !requires { w == km; };
+  requires !requires { w != quantity(1); };
+  requires !requires { w == dimensionless<percent>(1.0); };
+  requires !requires { w != height<metre, int>(1 * m); };
+  requires !requires { w == height<kilometre, double>(1.0 * km); };
+  requires !requires { w != horizontal_area<square_metre, int>(1 * (m * m)); };
+  requires !requires { w == rate_of_climb<kilometre_per_hour, double>(1.0 * (km / h)); };
+  requires !requires { w != quantity_point(1 * m); };
+  requires !requires { w == quantity_point(1.0 * mm); };
+  requires !requires { w != quantity_point(quantity(1)); };
+  requires !requires { w == quantity_point(dimensionless<percent>(1.0)); };
+};
 static_assert(invalid_equality<width_kind>);
 
 static_assert(width<metre, int>(1 * m) < width<metre, int>(2 * m));
@@ -753,22 +751,22 @@ static_assert(std::three_way_comparable_with<width<cgs::centimetre, int>, width<
 static_assert(std::three_way_comparable_with<width<metre>, width<cgs::centimetre>>);
 template<typename Width>
 concept invalid_relational = requires(quantity_kind<Width, metre, int> w) {
-                               requires !requires { w < 1; };
-                               requires !requires { w <= 1.0; };
-                               requires !requires { w >= 1 * m; };
-                               requires !requires { w > 1.0 * cgs_cm; };
-                               requires !requires { w <=> 1 * km; };
-                               requires !requires { w < quantity(1); };
-                               requires !requires { w <= dimensionless<percent>(1.0); };
-                               requires !requires { w >= height<metre, int>(1 * m); };
-                               requires !requires { w > height<kilometre, double>(1.0 * km); };
-                               requires !requires { w <=> horizontal_area<square_metre, int>(1 * (m * m)); };
-                               requires !requires { w < rate_of_climb<kilometre_per_hour, double>(1.0 * (km / h)); };
-                               requires !requires { w <= quantity_point(1 * m); };
-                               requires !requires { w >= quantity_point(1.0 * mm); };
-                               requires !requires { w > quantity_point(quantity(1)); };
-                               requires !requires { w <=> quantity_point(dimensionless<percent>(1.0)); };
-                             };
+  requires !requires { w < 1; };
+  requires !requires { w <= 1.0; };
+  requires !requires { w >= 1 * m; };
+  requires !requires { w > 1.0 * cgs_cm; };
+  requires !requires { w <=> 1 * km; };
+  requires !requires { w < quantity(1); };
+  requires !requires { w <= dimensionless<percent>(1.0); };
+  requires !requires { w >= height<metre, int>(1 * m); };
+  requires !requires { w > height<kilometre, double>(1.0 * km); };
+  requires !requires { w <=> horizontal_area<square_metre, int>(1 * (m * m)); };
+  requires !requires { w < rate_of_climb<kilometre_per_hour, double>(1.0 * (km / h)); };
+  requires !requires { w <= quantity_point(1 * m); };
+  requires !requires { w >= quantity_point(1.0 * mm); };
+  requires !requires { w > quantity_point(quantity(1)); };
+  requires !requires { w <=> quantity_point(dimensionless<percent>(1.0)); };
+};
 static_assert(invalid_relational<width_kind>);
 
 
@@ -807,37 +805,34 @@ static_assert(same(quantity_kind_cast<length<centimetre, int>>(width<metre, doub
 static_assert(same(quantity_kind_cast<length<centimetre, int>>(width<cgs::centimetre, int>(1 * cgs_cm)), width<cgs::centimetre, int>(1 * cgs_cm)));
 // clang-format on
 template<typename Width>
-concept invalid_cast =
-  requires {
-    requires !requires { quantity_kind_cast<apples<one, int>>(quantity_kind<Width, metre, int>(1 * m)); };
-    requires !requires {
-                quantity_kind_cast<horizontal_area<square_metre, int>>(quantity_kind<Width, metre, int>(1 * m));
-              };
-    requires !requires {
-                quantity_kind_cast<rate_of_climb<metre_per_second, int>>(quantity_kind<Width, metre, int>(1 * m));
-              };
-    requires !requires { quantity_kind_cast<apple>(quantity_kind<Width, metre, int>(1 * m)); };
-    requires !requires { quantity_kind_cast<horizontal_area_kind>(quantity_kind<Width, metre, int>(1 * m)); };
-    requires !requires { quantity_kind_cast<rate_of_climb_kind>(quantity_kind<Width, metre, int>(1 * m)); };
-    requires !requires { quantity_kind_cast<apple, one>(quantity_kind<Width, metre, int>(1 * m)); };
-    requires !requires {
-                quantity_kind_cast<horizontal_area_kind, square_metre>(quantity_kind<Width, metre, int>(1 * m));
-              };
-    requires !requires {
-                quantity_kind_cast<rate_of_climb_kind, metre_per_second>(quantity_kind<Width, metre, int>(1 * m));
-              };
-    requires !requires { quantity_kind_cast<dimensionless<one>>(quantity_kind<Width, metre, int>(1 * m)); };
-    requires !requires { quantity_kind_cast<square_metre>(quantity_kind<Width, metre, int>(1 * m)); };
-    requires !requires { quantity_kind_cast<second>(quantity_kind<Width, metre, int>(1 * m)); };
-    requires !requires {
-                quantity_kind_cast<quantity_point<dynamic_origin<dim_length>, metre, int>>(
-                  quantity_kind<Width, metre, int>(1 * m));
-              };
-    requires !requires {
-                quantity_kind_cast<quantity_point<dynamic_origin<dim_one>, one, int>>(
-                  quantity_kind<Width, metre, int>(1 * m));
-              };
+concept invalid_cast = requires {
+  requires !requires { quantity_kind_cast<apples<one, int>>(quantity_kind<Width, metre, int>(1 * m)); };
+  requires !requires {
+    quantity_kind_cast<horizontal_area<square_metre, int>>(quantity_kind<Width, metre, int>(1 * m));
   };
+  requires !requires {
+    quantity_kind_cast<rate_of_climb<metre_per_second, int>>(quantity_kind<Width, metre, int>(1 * m));
+  };
+  requires !requires { quantity_kind_cast<apple>(quantity_kind<Width, metre, int>(1 * m)); };
+  requires !requires { quantity_kind_cast<horizontal_area_kind>(quantity_kind<Width, metre, int>(1 * m)); };
+  requires !requires { quantity_kind_cast<rate_of_climb_kind>(quantity_kind<Width, metre, int>(1 * m)); };
+  requires !requires { quantity_kind_cast<apple, one>(quantity_kind<Width, metre, int>(1 * m)); };
+  requires !requires {
+    quantity_kind_cast<horizontal_area_kind, square_metre>(quantity_kind<Width, metre, int>(1 * m));
+  };
+  requires !requires {
+    quantity_kind_cast<rate_of_climb_kind, metre_per_second>(quantity_kind<Width, metre, int>(1 * m));
+  };
+  requires !requires { quantity_kind_cast<dimensionless<one>>(quantity_kind<Width, metre, int>(1 * m)); };
+  requires !requires { quantity_kind_cast<square_metre>(quantity_kind<Width, metre, int>(1 * m)); };
+  requires !requires { quantity_kind_cast<second>(quantity_kind<Width, metre, int>(1 * m)); };
+  requires !requires {
+    quantity_kind_cast<quantity_point<dynamic_origin<dim_length>, metre, int>>(quantity_kind<Width, metre, int>(1 * m));
+  };
+  requires !requires {
+    quantity_kind_cast<quantity_point<dynamic_origin<dim_one>, one, int>>(quantity_kind<Width, metre, int>(1 * m));
+  };
+};
 static_assert(invalid_cast<width_kind>);
 
 
diff --git a/test/unit_test/static/quantity_point_kind_test.cpp b/test/unit_test/static/quantity_point_kind_test.cpp
index 9a234a29..07de439b 100644
--- a/test/unit_test/static/quantity_point_kind_test.cpp
+++ b/test/unit_test/static/quantity_point_kind_test.cpp
@@ -150,21 +150,20 @@ static_assert(sizeof(abscissa<metre, double>) == sizeof(double));
 static_assert(sizeof(ordinate<metre, short>) == sizeof(short));
 
 template<typename Width, typename Abscissa>
-concept invalid_types =
-  requires {
-    requires !requires { typename quantity_point_kind<Width, metre, int>; };      // width_kind is not a point kind
-    requires !requires { typename quantity_point_kind<Abscissa, second, int>; };  // unit of a different dimension
-    requires !requires { typename quantity_point_kind<Abscissa, metre, length<metre>>; };  // quantity used as Rep
-    requires !requires {
-                typename quantity_point_kind<Abscissa, metre, quantity_point<dynamic_origin<dim_length>, metre>>;
-              };                                                                          // quantity point used as Rep
-    requires !requires { typename quantity_point_kind<Abscissa, metre, width<metre>>; };  // quantity kind used as Rep
-    requires !requires {
-                typename quantity_point_kind<Abscissa, metre, abscissa<metre>>;
-              };                                                                    // quantity point kind used as Rep
-    requires !requires { typename quantity_point_kind<metre, Abscissa, double>; };  // reordered arguments
-    requires !requires { typename quantity_point_kind<metre, double, Abscissa>; };  // reordered arguments
-  };
+concept invalid_types = requires {
+  requires !requires { typename quantity_point_kind<Width, metre, int>; };      // width_kind is not a point kind
+  requires !requires { typename quantity_point_kind<Abscissa, second, int>; };  // unit of a different dimension
+  requires !requires { typename quantity_point_kind<Abscissa, metre, length<metre>>; };  // quantity used as Rep
+  requires !requires {
+    typename quantity_point_kind<Abscissa, metre, quantity_point<dynamic_origin<dim_length>, metre>>;
+  };                                                                                    // quantity point used as Rep
+  requires !requires { typename quantity_point_kind<Abscissa, metre, width<metre>>; };  // quantity kind used as Rep
+  requires !requires {
+    typename quantity_point_kind<Abscissa, metre, abscissa<metre>>;
+  };                                                                              // quantity point kind used as Rep
+  requires !requires { typename quantity_point_kind<metre, Abscissa, double>; };  // reordered arguments
+  requires !requires { typename quantity_point_kind<metre, double, Abscissa>; };  // reordered arguments
+};
 static_assert(invalid_types<width_kind, abscissa_kind>);
 
 static_assert(std::is_trivially_default_constructible_v<abscissa<metre>>);
@@ -474,20 +473,19 @@ static_assert([]() {
 
 template<typename PK, typename U, typename Qx>
 concept invalid_compound_assignments_ = requires(quantity_point_kind<PK, U, int> x, Qx q) {
-                                          requires !requires { x += q; };
-                                          requires !requires { x -= q; };
-                                        };
+  requires !requires { x += q; };
+  requires !requires { x -= q; };
+};
 template<typename Abscissa>
-concept invalid_compound_assignments =
-  requires(quantity_point_kind<Abscissa, metre, int> x) {
-    requires !requires { x += 1; };
-    requires !requires { x -= 1; };
-    requires invalid_compound_assignments_<Abscissa, metre, length<metre, int>>;
-    requires invalid_compound_assignments_<Abscissa, metre, height<metre, int>>;
-    requires invalid_compound_assignments_<Abscissa, metre, rate_of_climb<metre_per_second, int>>;
-    requires invalid_compound_assignments_<Abscissa, metre, quantity_point<dynamic_origin<dim_length>, metre, int>>;
-    requires invalid_compound_assignments_<Abscissa, metre, std::chrono::seconds>;
-  };
+concept invalid_compound_assignments = requires(quantity_point_kind<Abscissa, metre, int> x) {
+  requires !requires { x += 1; };
+  requires !requires { x -= 1; };
+  requires invalid_compound_assignments_<Abscissa, metre, length<metre, int>>;
+  requires invalid_compound_assignments_<Abscissa, metre, height<metre, int>>;
+  requires invalid_compound_assignments_<Abscissa, metre, rate_of_climb<metre_per_second, int>>;
+  requires invalid_compound_assignments_<Abscissa, metre, quantity_point<dynamic_origin<dim_length>, metre, int>>;
+  requires invalid_compound_assignments_<Abscissa, metre, std::chrono::seconds>;
+};
 static_assert(invalid_compound_assignments<abscissa_kind>);
 static_assert(invalid_compound_assignments_<time_point_kind, second, std::chrono::seconds>);
 #if __cpp_lib_chrono >= 201907L
@@ -564,26 +562,26 @@ static_assert(std::equality_comparable_with<abscissa<metre>, abscissa<cgs::centi
 // clang-format on
 template<typename Int>
 concept invalid_equality = requires(quantity_point_kind<abscissa_kind, metre, Int> x, Int i) {
-                             requires !requires { x == 1; };
-                             requires !requires { x != 1.0; };
-                             requires !requires { x == 1 * m; };
-                             requires !requires { x != 1.0 * cgs_cm; };
-                             requires !requires { x == 1 * km; };
-                             requires !requires { x != quantity(1); };
-                             requires !requires { x == dimensionless<percent>(1.0); };
-                             requires !requires { x != width<metre, int>(1 * m); };
-                             requires !requires { x == width<kilometre, double>(1.0 * km); };
-                             requires !requires { x != height<metre, int>(1 * m); };
-                             requires !requires { x == height<kilometre, double>(1.0 * km); };
-                             requires !requires { x == rate_of_climb<kilometre_per_hour, double>(1.0 * (km / h)); };
-                             requires !requires { x != quantity_point(1 * m); };
-                             requires !requires { x == quantity_point(1.0 * mm); };
-                             requires !requires { x != quantity_point(quantity(1)); };
-                             requires !requires { x == quantity_point(dimensionless<percent>(1.0)); };
-                             requires !requires { x != quantity_point_kind(cgs_width<metre, int>(1 * m)); };
-                             requires !requires { x == ordinate<metre, int>(1 * m); };
-                             requires !requires { screen_si_width<metre, Int>{} != screen_si_cgs_width<metre, Int>{}; };
-                           };
+  requires !requires { x == 1; };
+  requires !requires { x != 1.0; };
+  requires !requires { x == 1 * m; };
+  requires !requires { x != 1.0 * cgs_cm; };
+  requires !requires { x == 1 * km; };
+  requires !requires { x != quantity(1); };
+  requires !requires { x == dimensionless<percent>(1.0); };
+  requires !requires { x != width<metre, int>(1 * m); };
+  requires !requires { x == width<kilometre, double>(1.0 * km); };
+  requires !requires { x != height<metre, int>(1 * m); };
+  requires !requires { x == height<kilometre, double>(1.0 * km); };
+  requires !requires { x == rate_of_climb<kilometre_per_hour, double>(1.0 * (km / h)); };
+  requires !requires { x != quantity_point(1 * m); };
+  requires !requires { x == quantity_point(1.0 * mm); };
+  requires !requires { x != quantity_point(quantity(1)); };
+  requires !requires { x == quantity_point(dimensionless<percent>(1.0)); };
+  requires !requires { x != quantity_point_kind(cgs_width<metre, int>(1 * m)); };
+  requires !requires { x == ordinate<metre, int>(1 * m); };
+  requires !requires { screen_si_width<metre, Int>{} != screen_si_cgs_width<metre, Int>{}; };
+};
 static_assert(invalid_equality<int>);
 
 // clang-format off
@@ -599,28 +597,27 @@ static_assert(std::three_way_comparable_with<abscissa<cgs::centimetre, int>, abs
 static_assert(std::three_way_comparable_with<abscissa<metre>, abscissa<cgs::centimetre>>);
 // clang-format on
 template<typename Int>
-concept invalid_relational =
-  requires(quantity_point_kind<abscissa_kind, metre, Int> x, Int i) {
-    requires !requires { x < 1; };
-    requires !requires { x <= 1.0; };
-    requires !requires { x >= 1 * m; };
-    requires !requires { x > 1.0 * cgs_cm; };
-    requires !requires { x <=> 1 * km; };
-    requires !requires { x < quantity(1); };
-    requires !requires { x <= dimensionless<percent>(1.0); };
-    requires !requires { x >= width<metre, int>(1 * m); };
-    requires !requires { x > width<kilometre, double>(1.0 * km); };
-    requires !requires { x <=> height<metre, int>(1 * m); };
-    requires !requires { x < height<kilometre, double>(1.0 * km); };
-    requires !requires { x <= rate_of_climb<kilometre_per_hour, double>(1.0 * (km / h)); };
-    requires !requires { x >= quantity_point(1 * m); };
-    requires !requires { x > quantity_point(1.0 * mm); };
-    requires !requires { x <=> quantity_point(quantity(1)); };
-    requires !requires { x < quantity_point(dimensionless<percent>(1.0)); };
-    requires !requires { x <= quantity_point_kind(cgs_width<metre, int>(1 * m)); };
-    requires !requires { x >= ordinate<metre, int>(1 * m); };
-    requires !requires { screen_si_width<metre, Int>{} > screen_si_cgs_width<metre, Int>{}; };
-  };
+concept invalid_relational = requires(quantity_point_kind<abscissa_kind, metre, Int> x, Int i) {
+  requires !requires { x < 1; };
+  requires !requires { x <= 1.0; };
+  requires !requires { x >= 1 * m; };
+  requires !requires { x > 1.0 * cgs_cm; };
+  requires !requires { x <=> 1 * km; };
+  requires !requires { x < quantity(1); };
+  requires !requires { x <= dimensionless<percent>(1.0); };
+  requires !requires { x >= width<metre, int>(1 * m); };
+  requires !requires { x > width<kilometre, double>(1.0 * km); };
+  requires !requires { x <=> height<metre, int>(1 * m); };
+  requires !requires { x < height<kilometre, double>(1.0 * km); };
+  requires !requires { x <= rate_of_climb<kilometre_per_hour, double>(1.0 * (km / h)); };
+  requires !requires { x >= quantity_point(1 * m); };
+  requires !requires { x > quantity_point(1.0 * mm); };
+  requires !requires { x <=> quantity_point(quantity(1)); };
+  requires !requires { x < quantity_point(dimensionless<percent>(1.0)); };
+  requires !requires { x <= quantity_point_kind(cgs_width<metre, int>(1 * m)); };
+  requires !requires { x >= ordinate<metre, int>(1 * m); };
+  requires !requires { screen_si_width<metre, Int>{} > screen_si_cgs_width<metre, Int>{}; };
+};
 static_assert(invalid_relational<int>);
 
 
@@ -672,35 +669,32 @@ static_assert(comp(quantity_point_kind_cast<length<centimetre, int>>(abscissa<cg
 static_assert(same(quantity_point_kind_cast<screen_si_cgs_width<metre, int>>(screen_si_width<metre, int>(1 * m)), screen_si_cgs_width<metre, int>(1 * m)));
 // clang-format on
 template<typename Int>
-concept invalid_cast =
-  requires(Int i) {
-    requires !requires { quantity_point_kind_cast<apples<one, Int>>(abscissa<metre, Int>(i * m)); };
-    requires !requires { quantity_point_kind_cast<rate_of_climb<metre_per_second, Int>>(abscissa<metre, Int>(i * m)); };
-    requires !requires { quantity_point_kind_cast<apple>(abscissa<metre, Int>(i * m)); };
-    requires !requires { quantity_point_kind_cast<rate_of_climb_kind>(abscissa<metre, Int>(i * m)); };
-    requires !requires { quantity_point_kind_cast<apple, one>(abscissa<metre, Int>(i * m)); };
-    requires !requires { quantity_point_kind_cast<width_kind, metre>(abscissa<metre, Int>(i * m)); };
-    requires !requires { quantity_point_kind_cast<width_kind, kilometre>(abscissa<metre, Int>(i * m)); };
-    requires !requires { quantity_point_kind_cast<height_kind, metre>(abscissa<metre, Int>(i * m)); };
-    requires !requires { quantity_point_kind_cast<height_kind, kilometre>(abscissa<metre, Int>(i * m)); };
-    requires !requires { quantity_point_kind_cast<cgs_width_kind, cgs::centimetre>(abscissa<metre, Int>(i * m)); };
-    requires !requires { quantity_point_kind_cast<rate_of_climb_kind, metre_per_second>(abscissa<metre, Int>(i * m)); };
-    requires !requires { quantity_point_kind_cast<dimensionless<one>>(abscissa<metre, Int>(i * m)); };
-    requires !requires { quantity_point_kind_cast<square_metre>(abscissa<metre, Int>(i * m)); };
-    requires !requires { quantity_point_kind_cast<second>(abscissa<metre, Int>(i * m)); };
-    requires !requires {
-                quantity_point_kind_cast<quantity_point<dynamic_origin<dim_length>, metre, Int>>(
-                  abscissa<metre, Int>(i * m));
-              };
-    requires !requires {
-                quantity_point_kind_cast<quantity_point<dynamic_origin<dim_one>, one, Int>>(
-                  abscissa<metre, Int>(i * m));
-              };
-    requires !requires {
-                quantity_point_kind_cast<quantity_point<dynamic_origin<dim_length>, metre, Int>>(
-                  screen_si_width<metre, Int>(i * m));
-              };
+concept invalid_cast = requires(Int i) {
+  requires !requires { quantity_point_kind_cast<apples<one, Int>>(abscissa<metre, Int>(i * m)); };
+  requires !requires { quantity_point_kind_cast<rate_of_climb<metre_per_second, Int>>(abscissa<metre, Int>(i * m)); };
+  requires !requires { quantity_point_kind_cast<apple>(abscissa<metre, Int>(i * m)); };
+  requires !requires { quantity_point_kind_cast<rate_of_climb_kind>(abscissa<metre, Int>(i * m)); };
+  requires !requires { quantity_point_kind_cast<apple, one>(abscissa<metre, Int>(i * m)); };
+  requires !requires { quantity_point_kind_cast<width_kind, metre>(abscissa<metre, Int>(i * m)); };
+  requires !requires { quantity_point_kind_cast<width_kind, kilometre>(abscissa<metre, Int>(i * m)); };
+  requires !requires { quantity_point_kind_cast<height_kind, metre>(abscissa<metre, Int>(i * m)); };
+  requires !requires { quantity_point_kind_cast<height_kind, kilometre>(abscissa<metre, Int>(i * m)); };
+  requires !requires { quantity_point_kind_cast<cgs_width_kind, cgs::centimetre>(abscissa<metre, Int>(i * m)); };
+  requires !requires { quantity_point_kind_cast<rate_of_climb_kind, metre_per_second>(abscissa<metre, Int>(i * m)); };
+  requires !requires { quantity_point_kind_cast<dimensionless<one>>(abscissa<metre, Int>(i * m)); };
+  requires !requires { quantity_point_kind_cast<square_metre>(abscissa<metre, Int>(i * m)); };
+  requires !requires { quantity_point_kind_cast<second>(abscissa<metre, Int>(i * m)); };
+  requires !requires {
+    quantity_point_kind_cast<quantity_point<dynamic_origin<dim_length>, metre, Int>>(abscissa<metre, Int>(i * m));
   };
+  requires !requires {
+    quantity_point_kind_cast<quantity_point<dynamic_origin<dim_one>, one, Int>>(abscissa<metre, Int>(i * m));
+  };
+  requires !requires {
+    quantity_point_kind_cast<quantity_point<dynamic_origin<dim_length>, metre, Int>>(
+      screen_si_width<metre, Int>(i * m));
+  };
+};
 static_assert(invalid_cast<int>);
 
 
diff --git a/test/unit_test/static/quantity_point_test.cpp b/test/unit_test/static/quantity_point_test.cpp
index 8eb42c4c..cd57a32d 100644
--- a/test/unit_test/static/quantity_point_test.cpp
+++ b/test/unit_test/static/quantity_point_test.cpp
@@ -46,22 +46,20 @@ struct sea_level_origin : point_origin<dim_length> {};
 // class invariants
 
 template<typename DimLength>
-concept invalid_types =
-  requires {
-    // unit of a different dimension:
-    requires !requires { typename quantity_point<dynamic_origin<DimLength>, second, int>; };
-    // quantity used as Rep:
-    requires !requires { typename quantity_point<dynamic_origin<DimLength>, metre, quantity<DimLength, metre, int>>; };
-    // quantity point used as Rep:
-    requires !requires {
-                typename quantity_point<dynamic_origin<DimLength>, metre,
-                                        quantity_point<dynamic_origin<DimLength>, metre, int>>;
-              };
-    // reordered arguments:
-    requires !requires { typename quantity_point<metre, dynamic_origin<DimLength>, double>; };
-    // dimension used as origin:
-    requires !requires { typename quantity_point<DimLength, second, int>; };
+concept invalid_types = requires {
+  // unit of a different dimension:
+  requires !requires { typename quantity_point<dynamic_origin<DimLength>, second, int>; };
+  // quantity used as Rep:
+  requires !requires { typename quantity_point<dynamic_origin<DimLength>, metre, quantity<DimLength, metre, int>>; };
+  // quantity point used as Rep:
+  requires !requires {
+    typename quantity_point<dynamic_origin<DimLength>, metre, quantity_point<dynamic_origin<DimLength>, metre, int>>;
   };
+  // reordered arguments:
+  requires !requires { typename quantity_point<metre, dynamic_origin<DimLength>, double>; };
+  // dimension used as origin:
+  requires !requires { typename quantity_point<DimLength, second, int>; };
+};
 
 static_assert(invalid_types<dim_length>);
 
@@ -237,9 +235,9 @@ static_assert(quantity_point(1000_q_m) <= quantity_point(1_q_km));
 template<typename Int>
 concept invalid_comparisons = requires(quantity_point<dynamic_origin<dim_length>, metre, Int> lhs,
                                        quantity_point<sea_level_origin, metre, Int> rhs) {
-                                requires !requires { lhs == rhs; };
-                                requires !requires { lhs < rhs; };
-                              };
+  requires !requires { lhs == rhs; };
+  requires !requires { lhs < rhs; };
+};
 static_assert(invalid_comparisons<int>);
 
 // alias units
@@ -295,16 +293,15 @@ static_assert(
   quantity_point_cast<dim_speed, kilometre_per_hour>(quantity_point(2000.0_q_m / 3600.0_q_s)).relative().number() == 2);
 
 template<typename Int>
-concept invalid_cast =
-  requires(Int i) {
-    requires !requires {
-                quantity_point_cast<quantity_point<dynamic_origin<dim_time>, second, Int>>(quantity_point(i * m));
-              };
-    requires !requires {
-                quantity_point_cast<quantity_point<dynamic_origin<dim_length>, metre, Int>>(
-                  quantity_point<sea_level_origin, metre, Int>(i * m));
-              };
+concept invalid_cast = requires(Int i) {
+  requires !requires {
+    quantity_point_cast<quantity_point<dynamic_origin<dim_time>, second, Int>>(quantity_point(i * m));
   };
+  requires !requires {
+    quantity_point_cast<quantity_point<dynamic_origin<dim_length>, metre, Int>>(
+      quantity_point<sea_level_origin, metre, Int>(i * m));
+  };
+};
 static_assert(invalid_cast<int>);
 
 // time
diff --git a/test/unit_test/static/quantity_test.cpp b/test/unit_test/static/quantity_test.cpp
index 2a7bc682..1c285a87 100644
--- a/test/unit_test/static/quantity_test.cpp
+++ b/test/unit_test/static/quantity_test.cpp
@@ -58,11 +58,11 @@ static_assert(sizeof(length<metre, short>) == sizeof(short));
 #if UNITS_COMP_GCC != 10 || UNITS_COMP_GCC_MINOR > 2
 template<template<typename, typename, typename> typename Q>
 concept invalid_types = requires {
-                          requires !requires { typename Q<dim_length, second, int>; };  // unit of a different dimension
-                          requires !requires { typename Q<dim_length, metre, length<metre>>; };  // quantity used as Rep
-                          requires !requires { typename Q<metre, dim_length, double>; };         // reordered arguments
-                          requires !requires { typename Q<metre, double, dim_length>; };         // reordered arguments
-                        };
+  requires !requires { typename Q<dim_length, second, int>; };           // unit of a different dimension
+  requires !requires { typename Q<dim_length, metre, length<metre>>; };  // quantity used as Rep
+  requires !requires { typename Q<metre, dim_length, double>; };         // reordered arguments
+  requires !requires { typename Q<metre, double, dim_length>; };         // reordered arguments
+};
 static_assert(invalid_types<quantity>);
 #endif
 
@@ -408,44 +408,43 @@ static_assert((22_q_m /= quantity(3.33)).number() == 6);
 #endif
 
 template<typename Metre, typename Kilometre>
-concept invalid_compound_assignments =
-  requires() {
-    // truncating not allowed
-    requires !requires(length<Metre, int> l) { l += 2.5_q_m; };
-    requires !requires(length<Metre, int> l) { l -= 2.5_q_m; };
-    requires !requires(length<Kilometre, int> l) { l += length<Metre, int>(2); };
-    requires !requires(length<Kilometre, int> l) { l -= length<Metre, int>(2); };
-    requires !requires(length<Kilometre, int> l) { l %= length<Metre, int>(2); };
-    requires !requires(length<Kilometre, int> l) { l %= dimensionless<percent, int>(2); };
-    requires !requires(length<Kilometre, int> l) { l %= dimensionless<percent, double>(2); };
+concept invalid_compound_assignments = requires() {
+  // truncating not allowed
+  requires !requires(length<Metre, int> l) { l += 2.5_q_m; };
+  requires !requires(length<Metre, int> l) { l -= 2.5_q_m; };
+  requires !requires(length<Kilometre, int> l) { l += length<Metre, int>(2); };
+  requires !requires(length<Kilometre, int> l) { l -= length<Metre, int>(2); };
+  requires !requires(length<Kilometre, int> l) { l %= length<Metre, int>(2); };
+  requires !requires(length<Kilometre, int> l) { l %= dimensionless<percent, int>(2); };
+  requires !requires(length<Kilometre, int> l) { l %= dimensionless<percent, double>(2); };
 
-    // TODO: accept non-truncating argument
-    requires !requires(length<Kilometre, int> l) { l *= 1 * (km / m); };
-    requires !requires(length<Kilometre, int> l) { l /= 1 * (km / m); };
-    requires !requires(length<Kilometre, int> l) { l %= 1 * (km / m); };
+  // TODO: accept non-truncating argument
+  requires !requires(length<Kilometre, int> l) { l *= 1 * (km / m); };
+  requires !requires(length<Kilometre, int> l) { l /= 1 * (km / m); };
+  requires !requires(length<Kilometre, int> l) { l %= 1 * (km / m); };
 
-    // only quantities can be added or subtracted
-    requires !requires(length<Metre, int> l) { l += 2; };
-    requires !requires(length<Metre, int> l) { l -= 2; };
+  // only quantities can be added or subtracted
+  requires !requires(length<Metre, int> l) { l += 2; };
+  requires !requires(length<Metre, int> l) { l -= 2; };
 
-    // compound multiply/divide by another quantity not allowed
-    requires !requires(length<Metre, int> l) { l *= 2_q_m; };
-    requires !requires(length<Metre, int> l) { l /= 2_q_m; };
+  // compound multiply/divide by another quantity not allowed
+  requires !requires(length<Metre, int> l) { l *= 2_q_m; };
+  requires !requires(length<Metre, int> l) { l /= 2_q_m; };
 
-    // modulo operations on a floating point representation not allowed
-    requires !requires(length<Metre, double> l) { l %= 2.; };
-    requires !requires(length<Metre, double> l) { l %= 2; };
-    requires !requires(length<Metre, double> l) { l %= 2._q_m; };
-    requires !requires(length<Metre, double> l) { l %= 2_q_m; };
-    requires !requires(length<Metre, int> l) { l %= 2._q_m; };
+  // modulo operations on a floating point representation not allowed
+  requires !requires(length<Metre, double> l) { l %= 2.; };
+  requires !requires(length<Metre, double> l) { l %= 2; };
+  requires !requires(length<Metre, double> l) { l %= 2._q_m; };
+  requires !requires(length<Metre, double> l) { l %= 2_q_m; };
+  requires !requires(length<Metre, int> l) { l %= 2._q_m; };
 
-    // no unit constants
-    requires !requires(length<Metre, int> l) { l += m; };
-    requires !requires(length<Metre, int> l) { l -= m; };
-    requires !requires(length<Metre, int> l) { l *= m; };
-    requires !requires(length<Metre, int> l) { l /= m; };
-    requires !requires(length<Metre, int> l) { l %= m; };
-  };
+  // no unit constants
+  requires !requires(length<Metre, int> l) { l += m; };
+  requires !requires(length<Metre, int> l) { l -= m; };
+  requires !requires(length<Metre, int> l) { l *= m; };
+  requires !requires(length<Metre, int> l) { l /= m; };
+  requires !requires(length<Metre, int> l) { l %= m; };
+};
 static_assert(invalid_compound_assignments<metre, kilometre>);
 
 
@@ -455,26 +454,26 @@ static_assert(invalid_compound_assignments<metre, kilometre>);
 
 template<typename Metre>
 concept invalid_binary_operations = requires {
-                                      // no crossdimensional addition and subtraction
-                                      requires !requires { 1_q_s + length<Metre, int>(1); };
-                                      requires !requires { 1_q_s - length<Metre, int>(1); };
+  // no crossdimensional addition and subtraction
+  requires !requires { 1_q_s + length<Metre, int>(1); };
+  requires !requires { 1_q_s - length<Metre, int>(1); };
 
-                                      // no floating-point modulo
-                                      requires !requires(length<Metre, double> a) { a % 2_q_m; };
-                                      requires !requires(length<Metre, double> a) { 2_q_m % a; };
-                                      requires !requires(length<Metre, double> a) { a % 2; };
-                                      requires !requires(length<Metre, double> a, length<Metre, double> b) { a % b; };
-                                      requires !requires(length<Metre, double> a, length<Metre, int> b) { a % b; };
-                                      requires !requires(length<Metre, double> a, length<Metre, int> b) { b % a; };
+  // no floating-point modulo
+  requires !requires(length<Metre, double> a) { a % 2_q_m; };
+  requires !requires(length<Metre, double> a) { 2_q_m % a; };
+  requires !requires(length<Metre, double> a) { a % 2; };
+  requires !requires(length<Metre, double> a, length<Metre, double> b) { a % b; };
+  requires !requires(length<Metre, double> a, length<Metre, int> b) { a % b; };
+  requires !requires(length<Metre, double> a, length<Metre, int> b) { b % a; };
 
-                                      // unit constants
-                                      requires !requires { length<Metre, int>(1) + m; };
-                                      requires !requires { length<Metre, int>(1) - m; };
-                                      requires !requires { length<Metre, int>(1) % m; };
-                                      requires !requires { m + length<Metre, int>(1); };
-                                      requires !requires { m - length<Metre, int>(1); };
-                                      requires !requires { m % length<Metre, int>(1); };
-                                    };
+  // unit constants
+  requires !requires { length<Metre, int>(1) + m; };
+  requires !requires { length<Metre, int>(1) - m; };
+  requires !requires { length<Metre, int>(1) % m; };
+  requires !requires { m + length<Metre, int>(1); };
+  requires !requires { m - length<Metre, int>(1); };
+  requires !requires { m % length<Metre, int>(1); };
+};
 static_assert(invalid_binary_operations<metre>);
 
 // same representation type
@@ -725,9 +724,9 @@ static_assert(quantity{2} / (1 * m) == 2 / 1_q_m);
 
 template<typename Metre>
 concept no_crossdimensional_equality = requires {
-                                         requires !requires { 1_q_s == length<Metre, int>(1); };
-                                         requires !requires { 1_q_s != length<Metre, int>(1); };
-                                       };
+  requires !requires { 1_q_s == length<Metre, int>(1); };
+  requires !requires { 1_q_s != length<Metre, int>(1); };
+};
 static_assert(no_crossdimensional_equality<metre>);
 
 // same type
@@ -761,11 +760,11 @@ static_assert(123 != quantity{321});
 
 template<typename Metre>
 concept no_crossdimensional_ordering = requires {
-                                         requires !requires { 1_q_s < length<Metre, int>(1); };
-                                         requires !requires { 1_q_s > length<Metre, int>(1); };
-                                         requires !requires { 1_q_s <= length<Metre, int>(1); };
-                                         requires !requires { 1_q_s >= length<Metre, int>(1); };
-                                       };
+  requires !requires { 1_q_s < length<Metre, int>(1); };
+  requires !requires { 1_q_s > length<Metre, int>(1); };
+  requires !requires { 1_q_s <= length<Metre, int>(1); };
+  requires !requires { 1_q_s >= length<Metre, int>(1); };
+};
 static_assert(no_crossdimensional_ordering<metre>);
 
 // same type
@@ -837,9 +836,9 @@ static_assert(!std::equality_comparable_with<dimensionless<one, int>, double>);
 
 template<typename Int>
 concept invalid_dimensionless_operations = requires {
-                                             requires !requires(dimensionless<percent, Int> d) { 1 + d; };
-                                             requires !requires(dimensionless<percent, Int> d) { d + 1; };
-                                           };
+  requires !requires(dimensionless<percent, Int> d) { 1 + d; };
+  requires !requires(dimensionless<percent, Int> d) { d + 1; };
+};
 static_assert(invalid_dimensionless_operations<int>);
 
 static_assert(compare<decltype(10_q_km / 5_q_km), quantity<dim_one, one, std::int64_t>>);
diff --git a/test/unit_test/static/references_test.cpp b/test/unit_test/static/references_test.cpp
index 56714358..0447e098 100644
--- a/test/unit_test/static/references_test.cpp
+++ b/test/unit_test/static/references_test.cpp
@@ -37,24 +37,24 @@ static_assert(2 * m == 2_q_m);
 static_assert(2 * s == 2_q_s);
 template<auto& s>
 concept invalid_operations = requires {
-                               requires !requires { 2 / s; };
-                               requires !requires { s / 2; };
-                               requires !requires { s * 2; };
-                               requires !requires { s + 2; };
-                               requires !requires { 2 + s; };
-                               requires !requires { s + s; };
-                               requires !requires { s - 2; };
-                               requires !requires { 2 - s; };
-                               requires !requires { s - s; };
-                               requires !requires { s + 1_q_s; };
-                               requires !requires { s - 1_q_s; };
-                               requires !requires { s * 1_q_s; };
-                               requires !requires { s / 1_q_s; };
-                               requires !requires { 1_q_s + s; };
-                               requires !requires { 1_q_s - s; };
-                               requires !requires { 1_q_s * s; };
-                               requires !requires { 1_q_s / s; };
-                             };
+  requires !requires { 2 / s; };
+  requires !requires { s / 2; };
+  requires !requires { s * 2; };
+  requires !requires { s + 2; };
+  requires !requires { 2 + s; };
+  requires !requires { s + s; };
+  requires !requires { s - 2; };
+  requires !requires { 2 - s; };
+  requires !requires { s - s; };
+  requires !requires { s + 1_q_s; };
+  requires !requires { s - 1_q_s; };
+  requires !requires { s * 1_q_s; };
+  requires !requires { s / 1_q_s; };
+  requires !requires { 1_q_s + s; };
+  requires !requires { 1_q_s - s; };
+  requires !requires { 1_q_s * s; };
+  requires !requires { 1_q_s / s; };
+};
 static_assert(invalid_operations<s>);
 
 static_assert(2_q_m / (1 * s) == 2_q_m_per_s);