From c30f62e7f5cfa6b8202b729fb40203917f8c1760 Mon Sep 17 00:00:00 2001
From: Mateusz Pusz <mateusz.pusz@gmail.com>
Date: Thu, 4 Jul 2024 22:57:49 +0100
Subject: [PATCH] docs: 2.2.0 release announcement updated to point to 2.2.1

---
 docs/blog/posts/2.2.0-released.md             |   6 +-
 .../include/mp-units/framework/dimension.h    |  11 +-
 .../mp-units/framework/expression_template.h  | 223 ++++++++++--------
 .../mp-units/framework/quantity_spec.h        |  13 +-
 src/core/include/mp-units/framework/unit.h    |   6 +-
 5 files changed, 143 insertions(+), 116 deletions(-)

diff --git a/docs/blog/posts/2.2.0-released.md b/docs/blog/posts/2.2.0-released.md
index bd30c471..451a1f53 100644
--- a/docs/blog/posts/2.2.0-released.md
+++ b/docs/blog/posts/2.2.0-released.md
@@ -9,14 +9,14 @@ categories:
 # mp-units 2.2.0 released!
 
 **A new product version can be obtained from
-[GitHub](https://github.com/mpusz/mp-units/releases/tag/v2.2.0) and
-[Conan](https://conan.io/center/recipes/mp-units?version=2.2.0).**
+[GitHub](https://github.com/mpusz/mp-units/releases/tag/v2.2.1) and
+[Conan](https://conan.io/center/recipes/mp-units?version=2.2.1).**
 
 Among other features, this release provides long-awaited support for C++20 modules, redesigns and
 enhances text output formatting, and greatly simplifies quantity point usage. This post describes
 those and a few other smaller interesting improvements, while a much longer list of the most
 significant changes introduced by the new version can be found in our
-[Release Notes](../../release_notes.md#2.2.0).
+[Release Notes](../../release_notes.md#2.2.1).
 
 <!-- more -->
 
diff --git a/src/core/include/mp-units/framework/dimension.h b/src/core/include/mp-units/framework/dimension.h
index cbd3609d..eed17936 100644
--- a/src/core/include/mp-units/framework/dimension.h
+++ b/src/core/include/mp-units/framework/dimension.h
@@ -160,15 +160,15 @@ struct is_dimension_one<struct dimension_one> : std::true_type {};
 MP_UNITS_EXPORT template<Dimension Lhs, Dimension Rhs>
 [[nodiscard]] consteval Dimension auto operator*(Lhs, Rhs)
 {
-  return detail::expr_multiply<derived_dimension, struct dimension_one, detail::type_list_of_base_dimension_less>(
+  return detail::expr_multiply<derived_dimension, struct dimension_one, detail::type_list_of_base_dimension_less, true>(
     Lhs{}, Rhs{});
 }
 
 MP_UNITS_EXPORT template<Dimension Lhs, Dimension Rhs>
 [[nodiscard]] consteval Dimension auto operator/(Lhs, Rhs)
 {
-  return detail::expr_divide<derived_dimension, struct dimension_one, detail::type_list_of_base_dimension_less>(Lhs{},
-                                                                                                                Rhs{});
+  return detail::expr_divide<derived_dimension, struct dimension_one, detail::type_list_of_base_dimension_less, true>(
+    Lhs{}, Rhs{});
 }
 
 namespace detail {
@@ -213,8 +213,8 @@ template<std::intmax_t Num, std::intmax_t Den = 1, Dimension D>
     else
       return derived_dimension<power<D, Num, Den>>{};
   } else
-    return detail::expr_pow<Num, Den, derived_dimension, struct dimension_one,
-                            detail::type_list_of_base_dimension_less>(d);
+    return detail::expr_pow<Num, Den, derived_dimension, struct dimension_one, detail::type_list_of_base_dimension_less,
+                            true>(d);
 }
 
 /**
@@ -235,7 +235,6 @@ template<std::intmax_t Num, std::intmax_t Den = 1, Dimension D>
  */
 [[nodiscard]] consteval Dimension auto cbrt(Dimension auto d) { return pow<1, 3>(d); }
 
-
 struct dimension_symbol_formatting {
   text_encoding encoding = text_encoding::default_encoding;
 };
diff --git a/src/core/include/mp-units/framework/expression_template.h b/src/core/include/mp-units/framework/expression_template.h
index 0e1c0dc2..45b77ff3 100644
--- a/src/core/include/mp-units/framework/expression_template.h
+++ b/src/core/include/mp-units/framework/expression_template.h
@@ -199,80 +199,6 @@ template<typename List>
 using expr_consolidate = MP_UNITS_TYPENAME expr_consolidate_impl<List>::type;
 
 
-/**
- * @brief Simplifies the expression template
- *
- * Analyzes provided numerator and denominator type lists and simplifies elements with the same type.
- * If the same power exists in both list, this elements gets omitted. Otherwise, the power of its
- * exponent gets subtracted according to numerator and denominator elements powers.
- *
- * @tparam NumList type list for expression numerator
- * @tparam DenList type list for expression denominator
- * @tparam Pred predicate to be used for elements comparisons
- */
-template<typename NumList, typename DenList, template<typename, typename> typename Pred>
-struct expr_simplify;
-
-// when one of the lists is empty there is nothing to do
-template<typename NumList, typename DenList, template<typename, typename> typename Pred>
-  requires(type_list_size<NumList> == 0) || (type_list_size<DenList> == 0)
-struct expr_simplify<NumList, DenList, Pred> {
-  using num = NumList;
-  using den = DenList;
-};
-
-// in case when front elements are different progress to the next element
-template<typename Num, typename... NRest, typename Den, typename... DRest, template<typename, typename> typename Pred>
-struct expr_simplify<type_list<Num, NRest...>, type_list<Den, DRest...>, Pred> {
-  using impl = conditional<Pred<Num, Den>::value, expr_simplify<type_list<NRest...>, type_list<Den, DRest...>, Pred>,
-                           expr_simplify<type_list<Num, NRest...>, type_list<DRest...>, Pred>>;
-  using num = conditional<Pred<Num, Den>::value, type_list_push_front<typename impl::num, Num>, typename impl::num>;
-  using den = conditional<Pred<Num, Den>::value, typename impl::den, type_list_push_front<typename impl::den, Den>>;
-};
-
-// in case two elements are of the same power such element gets omitted
-template<typename T, typename... NRest, typename... DRest, template<typename, typename> typename Pred>
-struct expr_simplify<type_list<T, NRest...>, type_list<T, DRest...>, Pred> :
-    expr_simplify<type_list<NRest...>, type_list<DRest...>, Pred> {};
-
-template<typename T, ratio Num, ratio Den>
-struct expr_simplify_power {
-  static constexpr ratio r = Num - Den;
-  using type = power_or_T<T, ratio{abs(r.num), r.den}>;
-  using num = conditional<(r > 0), type_list<type>, type_list<>>;
-  using den = conditional<(r < 0), type_list<type>, type_list<>>;
-};
-
-// in case there are different powers for the same element simplify the power
-template<typename T, typename... NRest, int... Ints, typename... DRest, template<typename, typename> typename Pred>
-struct expr_simplify<type_list<power<T, Ints...>, NRest...>, type_list<T, DRest...>, Pred> {
-  using impl = expr_simplify<type_list<NRest...>, type_list<DRest...>, Pred>;
-  using type = expr_simplify_power<T, power<T, Ints...>::exponent, ratio{1}>;
-  using num = type_list_join<typename type::num, typename impl::num>;
-  using den = type_list_join<typename type::den, typename impl::den>;
-};
-
-// in case there are different powers for the same element simplify the power
-template<typename T, typename... NRest, typename... DRest, int... Ints, template<typename, typename> typename Pred>
-struct expr_simplify<type_list<T, NRest...>, type_list<power<T, Ints...>, DRest...>, Pred> {
-  using impl = expr_simplify<type_list<NRest...>, type_list<DRest...>, Pred>;
-  using type = expr_simplify_power<T, ratio{1}, power<T, Ints...>::exponent>;
-  using num = type_list_join<typename type::num, typename impl::num>;
-  using den = type_list_join<typename type::den, typename impl::den>;
-};
-
-// in case there are different powers for the same element simplify the power
-template<typename T, typename... NRest, int... Ints1, typename... DRest, int... Ints2,
-         template<typename, typename> typename Pred>
-  requires(!std::same_as<power<T, Ints1...>, power<T, Ints2...>>)
-struct expr_simplify<type_list<power<T, Ints1...>, NRest...>, type_list<power<T, Ints2...>, DRest...>, Pred> {
-  using impl = expr_simplify<type_list<NRest...>, type_list<DRest...>, Pred>;
-  using type = expr_simplify_power<T, power<T, Ints1...>::exponent, power<T, Ints2...>::exponent>;
-  using num = type_list_join<typename type::num, typename impl::num>;
-  using den = type_list_join<typename type::den, typename impl::den>;
-};
-
-
 // expr_less
 template<typename Lhs, typename Rhs, template<typename, typename, auto...> typename Pred>
 struct expr_less_impl : Pred<expr_type<Lhs>, expr_type<Rhs>> {};
@@ -328,9 +254,9 @@ template<template<typename> typename OneType, typename List>
 template<template<typename> typename OneType, typename... Ts>
 struct expr_fractions : decltype(expr_fractions_impl<OneType, type_list<Ts...>>()) {};
 
-// expr_make_spec
+// make_expr
 template<typename NumList, typename DenList, typename OneType, template<typename...> typename To>
-[[nodiscard]] consteval auto expr_make_spec_impl()
+[[nodiscard]] consteval auto make_expr()
 {
   constexpr std::size_t num = type_list_size<NumList>;
   constexpr std::size_t den = type_list_size<DenList>;
@@ -350,19 +276,110 @@ template<typename NumList, typename DenList, typename OneType, template<typename
   }
 }
 
+/**
+ * @brief Simplifies the expression template
+ *
+ * Analyzes provided numerator and denominator type lists and simplifies elements with the same type.
+ * If the same power exists in both list, this elements gets omitted. Otherwise, the power of its
+ * exponent gets subtracted according to numerator and denominator elements powers.
+ *
+ * @tparam NumList type list for expression numerator
+ * @tparam DenList type list for expression denominator
+ * @tparam Pred predicate to be used for elements comparisons
+ */
+template<typename NumList, typename DenList, template<typename, typename> typename Pred>
+struct expr_simplify_impl;
+
+// when one of the lists is empty there is nothing to do
+template<typename NumList, typename DenList, template<typename, typename> typename Pred>
+  requires(type_list_size<NumList> == 0) || (type_list_size<DenList> == 0)
+struct expr_simplify_impl<NumList, DenList, Pred> {
+  using num = NumList;
+  using den = DenList;
+};
+
+// in case when front elements are different progress to the next element
+template<typename Num, typename... NRest, typename Den, typename... DRest, template<typename, typename> typename Pred>
+struct expr_simplify_impl<type_list<Num, NRest...>, type_list<Den, DRest...>, Pred> {
+  using impl =
+    conditional<Pred<Num, Den>::value, expr_simplify_impl<type_list<NRest...>, type_list<Den, DRest...>, Pred>,
+                expr_simplify_impl<type_list<Num, NRest...>, type_list<DRest...>, Pred>>;
+  using num = conditional<Pred<Num, Den>::value, type_list_push_front<typename impl::num, Num>, typename impl::num>;
+  using den = conditional<Pred<Num, Den>::value, typename impl::den, type_list_push_front<typename impl::den, Den>>;
+};
+
+// in case two elements are of the same power such element gets omitted
+template<typename T, typename... NRest, typename... DRest, template<typename, typename> typename Pred>
+struct expr_simplify_impl<type_list<T, NRest...>, type_list<T, DRest...>, Pred> :
+    expr_simplify_impl<type_list<NRest...>, type_list<DRest...>, Pred> {};
+
+template<typename T, ratio Num, ratio Den>
+struct expr_simplify_power {
+  static constexpr ratio r = Num - Den;
+  using type = power_or_T<T, ratio{abs(r.num), r.den}>;
+  using num = conditional<(r > 0), type_list<type>, type_list<>>;
+  using den = conditional<(r < 0), type_list<type>, type_list<>>;
+};
+
+// in case there are different powers for the same element simplify the power
+template<typename T, typename... NRest, int... Ints, typename... DRest, template<typename, typename> typename Pred>
+struct expr_simplify_impl<type_list<power<T, Ints...>, NRest...>, type_list<T, DRest...>, Pred> {
+  using impl = expr_simplify_impl<type_list<NRest...>, type_list<DRest...>, Pred>;
+  using type = expr_simplify_power<T, power<T, Ints...>::exponent, ratio{1}>;
+  using num = type_list_join<typename type::num, typename impl::num>;
+  using den = type_list_join<typename type::den, typename impl::den>;
+};
+
+// in case there are different powers for the same element simplify the power
+template<typename T, typename... NRest, typename... DRest, int... Ints, template<typename, typename> typename Pred>
+struct expr_simplify_impl<type_list<T, NRest...>, type_list<power<T, Ints...>, DRest...>, Pred> {
+  using impl = expr_simplify_impl<type_list<NRest...>, type_list<DRest...>, Pred>;
+  using type = expr_simplify_power<T, ratio{1}, power<T, Ints...>::exponent>;
+  using num = type_list_join<typename type::num, typename impl::num>;
+  using den = type_list_join<typename type::den, typename impl::den>;
+};
+
+// in case there are different powers for the same element simplify the power
+template<typename T, typename... NRest, int... Ints1, typename... DRest, int... Ints2,
+         template<typename, typename> typename Pred>
+  requires(!std::same_as<power<T, Ints1...>, power<T, Ints2...>>)
+struct expr_simplify_impl<type_list<power<T, Ints1...>, NRest...>, type_list<power<T, Ints2...>, DRest...>, Pred> {
+  using impl = expr_simplify_impl<type_list<NRest...>, type_list<DRest...>, Pred>;
+  using type = expr_simplify_power<T, power<T, Ints1...>::exponent, power<T, Ints2...>::exponent>;
+  using num = type_list_join<typename type::num, typename impl::num>;
+  using den = type_list_join<typename type::den, typename impl::den>;
+};
+
+template<template<typename...> typename To, typename OneType, template<typename, typename> typename Pred, typename T>
+[[nodiscard]] consteval auto expr_simplify(T)
+{
+  if constexpr (is_specialization_of<T, To>) {
+    using simple = expr_simplify_impl<typename T::_num_, typename T::_den_, Pred>;
+    // the usage of `std::identity` below helps to resolve an using alias identifier to the actual
+    // type identifier in the clang compile-time errors
+    return std::identity{}(make_expr<typename simple::num, typename simple::den, OneType, To>());
+  } else
+    return T{};
+}
+
 /**
  * @brief Creates an expression template spec based on provided numerator and denominator parts
  */
 template<typename NumList, typename DenList, typename OneType, template<typename, typename> typename Pred,
-         template<typename...> typename To>
+         bool Simplify, template<typename...> typename To>
 [[nodiscard]] consteval auto get_optimized_expression()
 {
   using num_list = expr_consolidate<NumList>;
   using den_list = expr_consolidate<DenList>;
-  using simple = expr_simplify<num_list, den_list, Pred>;
-  // the usage of `std::identity` below helps to resolve an using alias identifier to the actual
-  // type identifier in the clang compile-time errors
-  return std::identity{}(expr_make_spec_impl<typename simple::num, typename simple::den, OneType, To>());
+  if constexpr (Simplify) {
+    using simple = expr_simplify_impl<num_list, den_list, Pred>;
+    // the usage of `std::identity` below helps to resolve an using alias identifier to the actual
+    // type identifier in the clang compile-time errors
+    return std::identity{}(make_expr<typename simple::num, typename simple::den, OneType, To>());
+  } else
+    // the usage of `std::identity` below helps to resolve an using alias identifier to the actual
+    // type identifier in the clang compile-time errors
+    return std::identity{}(make_expr<num_list, den_list, OneType, To>());
 }
 
 /**
@@ -371,11 +388,12 @@ template<typename NumList, typename DenList, typename OneType, template<typename
  * @tparam To destination type list to put the result to
  * @tparam OneType type that represents the value `1`
  * @tparam Pred binary less then predicate
+ * @tparam Simplify specifies whether the resulting expression should be immediately simplified
  * @tparam Lhs lhs of the operation
  * @tparam Rhs rhs of the operation
  */
-template<template<typename...> typename To, typename OneType, template<typename, typename> typename Pred, typename Lhs,
-         typename Rhs>
+template<template<typename...> typename To, typename OneType, template<typename, typename> typename Pred, bool Simplify,
+         typename Lhs, typename Rhs>
 [[nodiscard]] consteval auto expr_multiply(Lhs, Rhs)
 {
   if constexpr (is_same_v<Lhs, OneType>) {
@@ -386,17 +404,17 @@ template<template<typename...> typename To, typename OneType, template<typename,
     // two derived dimensions
     return get_optimized_expression<type_list_merge_sorted<typename Lhs::_num_, typename Rhs::_num_, Pred>,
                                     type_list_merge_sorted<typename Lhs::_den_, typename Rhs::_den_, Pred>, OneType,
-                                    Pred, To>();
+                                    Pred, Simplify, To>();
   } else if constexpr (is_specialization_of<Lhs, To>) {
     return get_optimized_expression<type_list_merge_sorted<typename Lhs::_num_, type_list<Rhs>, Pred>,
-                                    typename Lhs::_den_, OneType, Pred, To>();
+                                    typename Lhs::_den_, OneType, Pred, Simplify, To>();
   } else if constexpr (is_specialization_of<Rhs, To>) {
     return get_optimized_expression<type_list_merge_sorted<typename Rhs::_num_, type_list<Lhs>, Pred>,
-                                    typename Rhs::_den_, OneType, Pred, To>();
+                                    typename Rhs::_den_, OneType, Pred, Simplify, To>();
   } else {
     // two base dimensions
     return get_optimized_expression<type_list_merge_sorted<type_list<Lhs>, type_list<Rhs>, Pred>, type_list<>, OneType,
-                                    Pred, To>();
+                                    Pred, Simplify, To>();
   }
 }
 
@@ -406,11 +424,12 @@ template<template<typename...> typename To, typename OneType, template<typename,
  * @tparam To destination type list to put the result to
  * @tparam OneType type that represents the value `1`
  * @tparam Pred binary less then predicate
+ * @tparam Simplify specifies whether the resulting expression should be immediately simplified
  * @tparam Lhs lhs of the operation
  * @tparam Rhs rhs of the operation
  */
-template<template<typename...> typename To, typename OneType, template<typename, typename> typename Pred, typename Lhs,
-         typename Rhs>
+template<template<typename...> typename To, typename OneType, template<typename, typename> typename Pred, bool Simplify,
+         typename Lhs, typename Rhs>
 [[nodiscard]] consteval auto expr_divide(Lhs lhs, Rhs rhs)
 {
   if constexpr (is_same_v<Lhs, Rhs>) {
@@ -418,18 +437,19 @@ template<template<typename...> typename To, typename OneType, template<typename,
   } else if constexpr (is_same_v<Rhs, OneType>) {
     return lhs;
   } else if constexpr (is_same_v<Lhs, OneType>) {
-    return expr_divide<To, OneType, Pred>(To<>{}, rhs);
+    return expr_divide<To, OneType, Pred, Simplify>(To<>{}, rhs);
   } else if constexpr (is_specialization_of<Lhs, To> && is_specialization_of<Rhs, To>) {
     // two derived entities
     return get_optimized_expression<type_list_merge_sorted<typename Lhs::_num_, typename Rhs::_den_, Pred>,
                                     type_list_merge_sorted<typename Lhs::_den_, typename Rhs::_num_, Pred>, OneType,
-                                    Pred, To>();
+                                    Pred, Simplify, To>();
   } else if constexpr (is_specialization_of<Lhs, To>) {
-    return get_optimized_expression<
-      typename Lhs::_num_, type_list_merge_sorted<typename Lhs::_den_, type_list<Rhs>, Pred>, OneType, Pred, To>();
+    return get_optimized_expression<typename Lhs::_num_,
+                                    type_list_merge_sorted<typename Lhs::_den_, type_list<Rhs>, Pred>, OneType, Pred,
+                                    Simplify, To>();
   } else if constexpr (is_specialization_of<Rhs, To>) {
     return get_optimized_expression<type_list_merge_sorted<typename Rhs::_den_, type_list<Lhs>, Pred>,
-                                    typename Rhs::_num_, OneType, Pred, To>();
+                                    typename Rhs::_num_, OneType, Pred, Simplify, To>();
   } else {
     // two named entities
     return To<Lhs, per<Rhs>>{};
@@ -442,26 +462,28 @@ template<template<typename...> typename To, typename OneType, template<typename,
  * @tparam T expression template spec to invert
  * @tparam OneType type that represents the value `1`
  * @tparam To destination type list to put the result to
+ * @tparam Simplify specifies whether the resulting expression should be immediately simplified
  */
-template<template<typename...> typename To, typename OneType, typename T>
+template<template<typename...> typename To, typename OneType, bool Simplify, typename T>
 [[nodiscard]] consteval auto expr_invert(T)
 {
   if constexpr (is_specialization_of<T, To>)
     // the usage of `std::identity` below helps to resolve an using alias identifier to the actual
     // type identifier in the clang compile-time errors
-    return std::identity{}(expr_make_spec_impl<typename T::_den_, typename T::_num_, OneType, To>());
+    return std::identity{}(make_expr<typename T::_den_, typename T::_num_, OneType, Simplify, To>());
   else
     return To<OneType, per<T>>{};
 }
 
 
 template<std::intmax_t Num, std::intmax_t Den, template<typename...> typename To, typename OneType,
-         template<typename, typename> typename Pred, typename... Nums, typename... Dens>
+         template<typename, typename> typename Pred, bool Simplify, typename... Nums, typename... Dens>
   requires detail::non_zero<Den>
 [[nodiscard]] consteval auto expr_pow_impl(type_list<Nums...>, type_list<Dens...>)
 {
   return detail::get_optimized_expression<type_list<power_or_T<Nums, ratio{Num, Den}>...>,
-                                          type_list<power_or_T<Dens, ratio{Num, Den}>...>, OneType, Pred, To>();
+                                          type_list<power_or_T<Dens, ratio{Num, Den}>...>, OneType, Pred, Simplify,
+                                          To>();
 }
 
 
@@ -473,14 +495,15 @@ template<std::intmax_t Num, std::intmax_t Den, template<typename...> typename To
  * @tparam To destination type list to put the result to
  * @tparam OneType type that represents the value `1`
  * @tparam Pred binary less then predicate
+ * @tparam Simplify specifies whether the resulting expression should be immediately simplified
  * @tparam T Expression being the base of the operation
  */
 template<std::intmax_t Num, std::intmax_t Den, template<typename...> typename To, typename OneType,
-         template<typename, typename> typename Pred, typename T>
+         template<typename, typename> typename Pred, bool Simplify, typename T>
   requires detail::non_zero<Den>
 [[nodiscard]] consteval auto expr_pow(T)
 {
-  return expr_pow_impl<Num, Den, To, OneType, Pred>(typename T::_num_{}, typename T::_den_{});
+  return expr_pow_impl<Num, Den, To, OneType, Pred, Simplify>(typename T::_num_{}, typename T::_den_{});
 }
 
 
diff --git a/src/core/include/mp-units/framework/quantity_spec.h b/src/core/include/mp-units/framework/quantity_spec.h
index 3c24b88c..458592e3 100644
--- a/src/core/include/mp-units/framework/quantity_spec.h
+++ b/src/core/include/mp-units/framework/quantity_spec.h
@@ -552,7 +552,7 @@ template<QuantitySpec Lhs, QuantitySpec Rhs>
 [[nodiscard]] consteval QuantitySpec auto operator*(Lhs lhs, Rhs rhs)
 {
   return detail::clone_kind_of<Lhs{}, Rhs{}>(
-    detail::expr_multiply<derived_quantity_spec, struct dimensionless, detail::type_list_of_quantity_spec_less>(
+    detail::expr_multiply<derived_quantity_spec, struct dimensionless, detail::type_list_of_quantity_spec_less, false>(
       detail::remove_kind(lhs), detail::remove_kind(rhs)));
 }
 
@@ -560,10 +560,15 @@ template<QuantitySpec Lhs, QuantitySpec Rhs>
 [[nodiscard]] consteval QuantitySpec auto operator/(Lhs lhs, Rhs rhs)
 {
   return detail::clone_kind_of<Lhs{}, Rhs{}>(
-    detail::expr_divide<derived_quantity_spec, struct dimensionless, detail::type_list_of_quantity_spec_less>(
+    detail::expr_divide<derived_quantity_spec, struct dimensionless, detail::type_list_of_quantity_spec_less, false>(
       detail::remove_kind(lhs), detail::remove_kind(rhs)));
 }
 
+[[nodiscard]] consteval QuantitySpec auto simplify(QuantitySpec auto q)
+{
+  return detail::expr_simplify<derived_quantity_spec, struct dimensionless, detail::type_list_of_quantity_spec_less>(q);
+}
+
 template<QuantitySpec Lhs, QuantitySpec Rhs>
 [[nodiscard]] consteval bool operator==(Lhs, Rhs)
 {
@@ -592,8 +597,8 @@ template<std::intmax_t Num, std::intmax_t Den = 1, QuantitySpec Q>
     return q;
   else if constexpr (detail::DerivedQuantitySpec<Q>)
     return detail::clone_kind_of<Q{}>(
-      detail::expr_pow<Num, Den, derived_quantity_spec, struct dimensionless, detail::type_list_of_quantity_spec_less>(
-        detail::remove_kind(q)));
+      detail::expr_pow<Num, Den, derived_quantity_spec, struct dimensionless, detail::type_list_of_quantity_spec_less,
+                       false>(detail::remove_kind(q)));
   else if constexpr (Den == 1)
     return detail::clone_kind_of<Q{}>(derived_quantity_spec<power<decltype(detail::remove_kind(Q{})), Num>>{});
   else
diff --git a/src/core/include/mp-units/framework/unit.h b/src/core/include/mp-units/framework/unit.h
index f32f4b40..af0ed993 100644
--- a/src/core/include/mp-units/framework/unit.h
+++ b/src/core/include/mp-units/framework/unit.h
@@ -481,7 +481,7 @@ template<Unit Lhs, Unit Rhs>
   else if constexpr (detail::is_specialization_of_scaled_unit<Rhs>)
     return Rhs::mag * (lhs * Rhs::reference_unit);
   else
-    return detail::expr_multiply<derived_unit, struct one, detail::type_list_of_unit_less>(lhs, rhs);
+    return detail::expr_multiply<derived_unit, struct one, detail::type_list_of_unit_less, false>(lhs, rhs);
 }
 
 /**
@@ -499,7 +499,7 @@ template<Unit Lhs, Unit Rhs>
   else if constexpr (detail::is_specialization_of_scaled_unit<Rhs>)
     return mag<1> / Rhs::mag * (lhs / Rhs::reference_unit);
   else
-    return detail::expr_divide<derived_unit, struct one, detail::type_list_of_unit_less>(lhs, rhs);
+    return detail::expr_divide<derived_unit, struct one, detail::type_list_of_unit_less, false>(lhs, rhs);
 }
 
 [[nodiscard]] MP_UNITS_CONSTEVAL Unit auto inverse(Unit auto u) { return one / u; }
@@ -559,7 +559,7 @@ template<std::intmax_t Num, std::intmax_t Den = 1, Unit U>
   else if constexpr (detail::is_specialization_of_scaled_unit<U>)
     return scaled_unit<pow<Num, Den>(U::mag), decltype(pow<Num, Den>(U::reference_unit))>{};
   else if constexpr (detail::is_specialization_of_derived_unit<U>)
-    return detail::expr_pow<Num, Den, derived_unit, struct one, detail::type_list_of_unit_less>(u);
+    return detail::expr_pow<Num, Den, derived_unit, struct one, detail::type_list_of_unit_less, false>(u);
   else if constexpr (Den == 1)
     return derived_unit<power<U, Num>>{};
   else