diff --git a/example/include/ranged_representation.h b/example/include/ranged_representation.h
index 0ffd5d70d..1643ec68b 100644
--- a/example/include/ranged_representation.h
+++ b/example/include/ranged_representation.h
@@ -62,9 +62,6 @@ class ranged_representation : public validated_type<T, is_in_range_t<T, Min, Max
   }
 };
 
-template<typename T, auto Min, auto Max>
-constexpr bool mp_units::is_scalar<ranged_representation<T, Min, Max>> = mp_units::is_scalar<T>;
-
 template<typename T, auto Min, auto Max, typename Char>
 struct MP_UNITS_STD_FMT::formatter<ranged_representation<T, Min, Max>, Char> : formatter<T, Char> {
   template<typename FormatContext>
diff --git a/example/include/validated_type.h b/example/include/validated_type.h
index 70be6dac3..67ae53354 100644
--- a/example/include/validated_type.h
+++ b/example/include/validated_type.h
@@ -113,9 +113,6 @@ class validated_type {
   = default;
 };
 
-template<typename T, typename Validator>
-constexpr bool mp_units::is_scalar<validated_type<T, Validator>> = mp_units::is_scalar<T>;
-
 
 template<typename CharT, typename Traits, typename T, typename Validator>
 std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& os,
diff --git a/example/kalman_filter/kalman_filter-example_2.cpp b/example/kalman_filter/kalman_filter-example_2.cpp
index 5a07edebd..9a3c562c7 100644
--- a/example/kalman_filter/kalman_filter-example_2.cpp
+++ b/example/kalman_filter/kalman_filter-example_2.cpp
@@ -38,10 +38,6 @@ import mp_units;
 
 // Based on: https://www.kalmanfilter.net/alphabeta.html#ex2
 
-template<class T>
-  requires mp_units::is_scalar<T>
-constexpr bool mp_units::is_vector<T> = true;
-
 using namespace mp_units;
 
 void print_header(const kalman::SystemState auto& initial)
diff --git a/example/kalman_filter/kalman_filter-example_3.cpp b/example/kalman_filter/kalman_filter-example_3.cpp
index 65aa2b1f2..437ffc172 100644
--- a/example/kalman_filter/kalman_filter-example_3.cpp
+++ b/example/kalman_filter/kalman_filter-example_3.cpp
@@ -38,10 +38,6 @@ import mp_units;
 
 // Based on: https://www.kalmanfilter.net/alphabeta.html#ex3
 
-template<class T>
-  requires mp_units::is_scalar<T>
-constexpr bool mp_units::is_vector<T> = true;
-
 using namespace mp_units;
 
 void print_header(const kalman::SystemState auto& initial)
diff --git a/example/kalman_filter/kalman_filter-example_4.cpp b/example/kalman_filter/kalman_filter-example_4.cpp
index 64e240e1f..d28b591fb 100644
--- a/example/kalman_filter/kalman_filter-example_4.cpp
+++ b/example/kalman_filter/kalman_filter-example_4.cpp
@@ -38,10 +38,6 @@ import mp_units;
 
 // Based on: https://www.kalmanfilter.net/alphabeta.html#ex4
 
-template<class T>
-  requires mp_units::is_scalar<T>
-constexpr bool mp_units::is_vector<T> = true;
-
 using namespace mp_units;
 
 void print_header(const kalman::SystemState auto& initial)
diff --git a/example/measurement.cpp b/example/measurement.cpp
index 596361132..1f291cee2 100644
--- a/example/measurement.cpp
+++ b/example/measurement.cpp
@@ -124,6 +124,13 @@ class measurement {
     return os << v.value() << " ± " << v.uncertainty();
   }
 
+  [[nodiscard]] friend constexpr measurement abs(const measurement& v)
+    requires requires { abs(v.value()); } || requires { std::abs(v.value()); }
+  {
+    using std::abs;
+    return measurement(abs(v.value()), v.uncertainty());
+  }
+
 private:
   value_type value_{};
   value_type uncertainty_{};
@@ -131,12 +138,8 @@ class measurement {
 
 }  // namespace
 
-template<typename T>
-constexpr bool mp_units::is_scalar<measurement<T>> = true;
-template<typename T>
-constexpr bool mp_units::is_vector<measurement<T>> = true;
-
 static_assert(mp_units::RepresentationOf<measurement<double>, mp_units::quantity_character::scalar>);
+static_assert(mp_units::RepresentationOf<measurement<double>, mp_units::quantity_character::vector>);
 
 namespace {
 
diff --git a/example/storage_tank.cpp b/example/storage_tank.cpp
index 86bc32ffa..e733f56f4 100644
--- a/example/storage_tank.cpp
+++ b/example/storage_tank.cpp
@@ -40,12 +40,6 @@ import mp_units;
 #include <mp-units/systems/si.h>
 #endif
 
-// allows standard gravity (acceleration) and weight (force) to be expressed with scalar representation
-// types instead of requiring the usage of Linear Algebra library for this simple example
-template<class T>
-  requires mp_units::is_scalar<T>
-constexpr bool mp_units::is_vector<T> = true;
-
 namespace {
 
 using namespace mp_units;
diff --git a/example/strong_angular_quantities.cpp b/example/strong_angular_quantities.cpp
index 9c03b36c1..88b80abe0 100644
--- a/example/strong_angular_quantities.cpp
+++ b/example/strong_angular_quantities.cpp
@@ -33,10 +33,6 @@ import mp_units;
 #include <mp-units/systems/si.h>
 #endif
 
-template<class T>
-  requires mp_units::is_scalar<T>
-constexpr bool mp_units::is_vector<T> = true;
-
 int main()
 {
   using namespace mp_units;
diff --git a/example/total_energy.cpp b/example/total_energy.cpp
index 75416bb7f..eced87bba 100644
--- a/example/total_energy.cpp
+++ b/example/total_energy.cpp
@@ -37,10 +37,6 @@ import mp_units;
 #include <mp-units/systems/si.h>
 #endif
 
-template<class T>
-  requires mp_units::is_scalar<T>
-constexpr bool mp_units::is_vector<T> = true;
-
 namespace {
 
 using namespace mp_units;
diff --git a/src/core/include/mp-units/bits/get_associated_quantity.h b/src/core/include/mp-units/bits/get_associated_quantity.h
index 2282ffb2d..dc7b4211b 100644
--- a/src/core/include/mp-units/bits/get_associated_quantity.h
+++ b/src/core/include/mp-units/bits/get_associated_quantity.h
@@ -80,7 +80,7 @@ template<AssociatedUnit U>
   else if constexpr (requires { U::_reference_unit_; })
     return determine_associated_quantity(U::_reference_unit_);
   else if constexpr (requires { typename U::_num_; }) {
-    return expr_map<to_quantity_spec, derived_quantity_spec, struct dimensionless, type_list_of_quantity_spec_less>(u);
+    return expr_map<to_quantity_spec, derived_quantity_spec, struct dimensionless>(u);
   }
 }
 
diff --git a/src/core/include/mp-units/bits/text_tools.h b/src/core/include/mp-units/bits/text_tools.h
index f14e0f7d7..4af3762f2 100644
--- a/src/core/include/mp-units/bits/text_tools.h
+++ b/src/core/include/mp-units/bits/text_tools.h
@@ -33,8 +33,11 @@
 import std;
 #else
 #include <cstdint>
-#endif
-#endif
+#if __cpp_lib_text_encoding
+#include <text_encoding>
+#endif  // __cpp_lib_text_encoding
+#endif  // MP_UNITS_IMPORT_STD
+#endif  // MP_UNITS_IN_MODULE_INTERFACE
 
 namespace mp_units::detail {
 
@@ -102,6 +105,11 @@ constexpr Out copy(const symbol_text<N, M>& txt, character_set char_set, Out out
     if constexpr (is_same_v<CharT, char8_t>)
       return ::mp_units::detail::copy(txt.utf8().begin(), txt.utf8().end(), out);
     else if constexpr (is_same_v<CharT, char>) {
+#if __cpp_lib_text_encoding
+      if (std::text_encoding::literal().mib() != std::text_encoding::id::UTF8)
+        // fallback to portable mode
+        return ::mp_units::detail::copy(txt.portable().begin(), txt.portable().end(), out);
+#endif
       for (const char8_t ch : txt.utf8()) *out++ = static_cast<char>(ch);
       return out;
     } else
diff --git a/src/core/include/mp-units/cartesian_vector.h b/src/core/include/mp-units/cartesian_vector.h
index af5e7e366..4af2679ab 100644
--- a/src/core/include/mp-units/cartesian_vector.h
+++ b/src/core/include/mp-units/cartesian_vector.h
@@ -215,7 +215,7 @@ class cartesian_vector {
            lhs._coordinates_[2] == rhs._coordinates_[2];
   }
 
-  [[nodiscard]] friend constexpr T norm(const cartesian_vector& vec)
+  [[nodiscard]] friend constexpr T magnitude(const cartesian_vector& vec)
     requires treat_as_floating_point<T>
   {
     return vec.magnitude();
@@ -263,9 +263,6 @@ template<typename Arg, typename... Args>
   requires(sizeof...(Args) <= 2) && requires { typename std::common_type_t<Arg, Args...>; }
 cartesian_vector(Arg, Args...) -> cartesian_vector<std::common_type_t<Arg, Args...>>;
 
-template<class T>
-constexpr bool is_vector<cartesian_vector<T>> = true;
-
 }  // namespace mp_units
 
 #if MP_UNITS_HOSTED
diff --git a/src/core/include/mp-units/complex.h b/src/core/include/mp-units/complex.h
index 9f09c05f7..537fbcc87 100644
--- a/src/core/include/mp-units/complex.h
+++ b/src/core/include/mp-units/complex.h
@@ -25,7 +25,7 @@
 #include <mp-units/bits/requires_hosted.h>
 //
 #include <mp-units/bits/module_macros.h>
-#include <mp-units/framework/customization_points.h>
+#include <mp-units/framework/representation_concepts.h>
 
 #ifndef MP_UNITS_IN_MODULE_INTERFACE
 #ifdef MP_UNITS_IMPORT_STD
@@ -38,6 +38,6 @@ import std;
 namespace mp_units {
 
 template<typename T>
-constexpr bool is_complex<std::complex<T>> = true;
+constexpr bool disable_scalar<std::complex<T>> = true;
 
-}
+}  // namespace mp_units
diff --git a/src/core/include/mp-units/ext/type_name.h b/src/core/include/mp-units/ext/type_name.h
index d368f869c..403ecd65c 100644
--- a/src/core/include/mp-units/ext/type_name.h
+++ b/src/core/include/mp-units/ext/type_name.h
@@ -10,6 +10,7 @@
 import std;
 #else
 #include <string_view>
+#include <type_traits>
 #endif
 #endif
 
@@ -37,6 +38,8 @@ template<typename T>
   return name;
 }
 
+template<typename Lhs, typename Rhs>
+struct type_name_less : std::bool_constant<type_name<Lhs>() < type_name<Rhs>()> {};
 
 // This is typically used to deterministically chose one of the alternatives
 // to guarantee the commutation of the operation (e.g., `a + b` should return
diff --git a/src/core/include/mp-units/framework/customization_points.h b/src/core/include/mp-units/framework/customization_points.h
index 43f8cfff2..d33b111d2 100644
--- a/src/core/include/mp-units/framework/customization_points.h
+++ b/src/core/include/mp-units/framework/customization_points.h
@@ -60,157 +60,22 @@ constexpr bool treat_as_floating_point =
   std::is_floating_point_v<value_type_t<Rep>>;
 #endif
 
-/**
- * @brief Specifies a type to have a scalar character
- *
- * A scalar is a physical quantity that has magnitude but no direction.
- */
 template<typename Rep>
-constexpr bool is_scalar = std::is_floating_point_v<Rep> || (std::is_integral_v<Rep> && !is_same_v<Rep, bool>);
+[[deprecated("`is_scalar` is no longer necessary and can simply be removed")]]
+constexpr bool is_scalar = false;
 
-/**
- * @brief Specifies a type to have a complex character
- *
- * A complex is a physical quantity that has a complex representation type.
- */
 template<typename Rep>
+[[deprecated("`is_complex` is no longer necessary and can simply be removed")]]
 constexpr bool is_complex = false;
 
-/**
- * @brief Specifies a type to have a vector character
- *
- * Vectors are physical quantities that possess both magnitude and direction
- * and whose operations obey the axioms of a vector space.
- *
- * In specific cases a scalar can represent a vector with the default direction.
- * If that is the intent, a user should provide a partial specialization:
- *
- * @code{.cpp}
- * template<class T>
- *   requires mp_units::is_scalar<T>
- * constexpr bool mp_units::is_vector<T> = true;
- * @endcode
- */
 template<typename Rep>
+[[deprecated("`is_vector` is no longer necessary and can simply be removed")]]
 constexpr bool is_vector = false;
 
-/**
- * @brief Specifies a type to have a tensor character
- *
- * Tensors can be used to describe more general physical quantities.
- *
- * A vector is a tensor of the first order and a scalar is a tensor of order zero.
- * Similarly to `is_vector` a partial specialization is needed in such cases.
- */
 template<typename Rep>
+[[deprecated("`is_tensor` is no longer necessary and can simply be removed")]]
 constexpr bool is_tensor = false;
 
-MP_UNITS_EXPORT_END
-
-namespace detail::norm_impl {
-
-void norm() = delete;  // poison pill
-
-struct norm_t {
-  template<typename T>
-  [[nodiscard]] constexpr auto operator()(const T& vec) const
-  {
-    if constexpr (requires { vec.norm(); })
-      return vec.norm();
-    else if constexpr (requires { norm(vec); })
-      return norm(vec);
-    else if constexpr (requires { vec.magnitude(); })
-      return vec.magnitude();
-    else if constexpr (requires { magnitude(vec); })
-      return magnitude(vec);
-    // TODO Is it a good idea to enable fundamental types to represent vector quantities?
-    // else if constexpr (is_scalar<T>)
-    //   return std::abs(vec);
-  }
-};
-
-}  // namespace detail::norm_impl
-
-inline namespace cpo {
-
-MP_UNITS_EXPORT inline constexpr ::mp_units::detail::norm_impl::norm_t norm;
-
-}
-
-namespace detail::real_impl {
-
-void real() = delete;  // poison pill
-
-struct real_t {
-  template<typename T>
-  [[nodiscard]] constexpr auto operator()(const T& clx) const
-  {
-    if constexpr (requires { clx.real(); })
-      return clx.real();
-    else if constexpr (requires { real(clx); })
-      return real(clx);
-  }
-};
-
-}  // namespace detail::real_impl
-
-inline namespace cpo {
-
-MP_UNITS_EXPORT inline constexpr ::mp_units::detail::real_impl::real_t real;
-
-}
-
-namespace detail::imag_impl {
-
-void imag() = delete;  // poison pill
-
-struct imag_t {
-  template<typename T>
-  [[nodiscard]] constexpr auto operator()(const T& clx) const
-  {
-    if constexpr (requires { clx.imag(); })
-      return clx.imag();
-    else if constexpr (requires { imag(clx); })
-      return imag(clx);
-  }
-};
-
-}  // namespace detail::imag_impl
-
-inline namespace cpo {
-
-MP_UNITS_EXPORT inline constexpr ::mp_units::detail::imag_impl::imag_t imag;
-
-}
-
-namespace detail::modulus_impl {
-
-void modulus() = delete;  // poison pill
-
-struct modulus_t {
-  template<typename T>
-  [[nodiscard]] constexpr auto operator()(const T& clx) const
-  {
-    if constexpr (requires { clx.modulus(); })
-      return clx.modulus();
-    else if constexpr (requires { modulus(clx); })
-      return modulus(clx);
-    // `std` made a precedence of using `abs` for modulo on `std::complex`
-    else if constexpr (requires { abs(clx); })
-      return abs(clx);
-  }
-};
-
-}  // namespace detail::modulus_impl
-
-inline namespace cpo {
-
-MP_UNITS_EXPORT inline constexpr ::mp_units::detail::modulus_impl::modulus_t modulus;
-
-}
-
-MP_UNITS_EXPORT_BEGIN
-
 /**
  * @brief A type trait that defines zero, one, min, and max for a representation type
  *
@@ -222,9 +87,9 @@ MP_UNITS_EXPORT_BEGIN
  */
 template<typename Rep>
 #if MP_UNITS_HOSTED
-struct quantity_values : std::chrono::duration_values<Rep> {
+struct representation_values : std::chrono::duration_values<Rep> {
 #else
-struct quantity_values {
+struct representation_values {
   static constexpr Rep zero() noexcept
     requires std::constructible_from<Rep, int>
   {
@@ -255,6 +120,9 @@ struct quantity_values {
   }
 };
 
+template<typename Rep>
+using quantity_values [[deprecated("Use `representation_values` instead")]] = representation_values<Rep>;
+
 /**
  * @brief Provides support for external quantity-like types
  *
diff --git a/src/core/include/mp-units/framework/dimension.h b/src/core/include/mp-units/framework/dimension.h
index b0ff804f6..21c77929e 100644
--- a/src/core/include/mp-units/framework/dimension.h
+++ b/src/core/include/mp-units/framework/dimension.h
@@ -29,7 +29,6 @@
 #include <mp-units/compat_macros.h>
 #include <mp-units/ext/fixed_string.h>
 #include <mp-units/ext/inplace_vector.h>
-#include <mp-units/ext/type_name.h>
 #include <mp-units/ext/type_traits.h>
 #include <mp-units/framework/dimension_concepts.h>
 #include <mp-units/framework/expression_template.h>
@@ -59,12 +58,6 @@ MP_UNITS_EXPORT struct dimension_one;
 
 namespace detail {
 
-template<typename Lhs, typename Rhs>
-struct base_dimension_less : std::bool_constant<type_name<Lhs>() < type_name<Rhs>()> {};
-
-template<typename T1, typename T2>
-using type_list_of_base_dimension_less = expr_less<T1, T2, base_dimension_less>;
-
 template<typename... Expr>
 struct derived_dimension_impl : expr_fractions<dimension_one, Expr...> {};
 
@@ -72,13 +65,13 @@ struct dimension_interface {
   template<Dimension Lhs, Dimension Rhs>
   [[nodiscard]] friend consteval Dimension auto operator*(Lhs, Rhs)
   {
-    return expr_multiply<derived_dimension, struct dimension_one, type_list_of_base_dimension_less>(Lhs{}, Rhs{});
+    return expr_multiply<derived_dimension, struct dimension_one>(Lhs{}, Rhs{});
   }
 
   template<Dimension Lhs, Dimension Rhs>
   [[nodiscard]] friend consteval Dimension auto operator/(Lhs, Rhs)
   {
-    return expr_divide<derived_dimension, struct dimension_one, type_list_of_base_dimension_less>(Lhs{}, Rhs{});
+    return expr_divide<derived_dimension, struct dimension_one>(Lhs{}, Rhs{});
   }
 
   template<Dimension Lhs, Dimension Rhs>
@@ -197,8 +190,7 @@ template<std::intmax_t Num, std::intmax_t Den = 1, Dimension D>
   requires detail::non_zero<Den>
 [[nodiscard]] consteval Dimension auto pow(D d)
 {
-  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>(d);
 }
 
 /**
diff --git a/src/core/include/mp-units/framework/expression_template.h b/src/core/include/mp-units/framework/expression_template.h
index 891396ab6..a0e0bc61e 100644
--- a/src/core/include/mp-units/framework/expression_template.h
+++ b/src/core/include/mp-units/framework/expression_template.h
@@ -25,6 +25,7 @@
 #include <mp-units/bits/math_concepts.h>
 #include <mp-units/bits/ratio.h>
 #include <mp-units/bits/type_list.h>
+#include <mp-units/ext/type_name.h>
 #include <mp-units/ext/type_traits.h>
 
 #ifndef MP_UNITS_IN_MODULE_INTERFACE
@@ -117,8 +118,8 @@ constexpr bool ratio_one<N, N> = true;
 template<detail::SymbolicArg F, int Num, int... Den>
   requires(detail::valid_ratio<Num, Den...> && detail::positive_ratio<Num, Den...> && !detail::ratio_one<Num, Den...>)
 struct power final {
-  using factor = F;
-  static constexpr detail::ratio exponent{Num, Den...};
+  using _factor_ = F;
+  static constexpr detail::ratio _exponent_{Num, Den...};
 };
 
 namespace detail {
@@ -146,7 +147,7 @@ template<SymbolicArg T, ratio R>
 consteval auto power_or_T_impl()
 {
   if constexpr (is_specialization_of_power<T>) {
-    return power_or_T_impl<typename T::factor, T::exponent * R>();
+    return power_or_T_impl<typename T::_factor_, T::_exponent_ * R>();
   } else {
     if constexpr (R.den == 1) {
       if constexpr (R.num == 1)
@@ -198,13 +199,13 @@ struct expr_consolidate_impl<type_list<T, T, Rest...>> {
 // replaces the instance of a type and a power of it with one with incremented power
 template<typename T, int... Ints, typename... Rest>
 struct expr_consolidate_impl<type_list<T, power<T, Ints...>, Rest...>> {
-  using type = expr_consolidate_impl<type_list<power_or_T<T, power<T, Ints...>::exponent + 1>, Rest...>>::type;
+  using type = expr_consolidate_impl<type_list<power_or_T<T, power<T, Ints...>::_exponent_ + 1>, Rest...>>::type;
 };
 
 // accumulates the powers of instances of the same type (removes the element in case the accumulation result is `0`)
 template<typename T, int... Ints1, int... Ints2, typename... Rest>
 struct expr_consolidate_impl<type_list<power<T, Ints1...>, power<T, Ints2...>, Rest...>> {
-  static constexpr ratio r = power<T, Ints1...>::exponent + power<T, Ints2...>::exponent;
+  static constexpr ratio r = power<T, Ints1...>::_exponent_ + power<T, Ints2...>::_exponent_;
   using type = expr_consolidate_impl<type_list<power_or_T<T, r>, Rest...>>::type;
 };
 
@@ -260,7 +261,7 @@ struct expr_simplify_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 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>;
 };
@@ -269,7 +270,7 @@ struct expr_simplify<type_list<power<T, Ints...>, NRest...>, type_list<T, DRest.
 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 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>;
 };
@@ -280,7 +281,7 @@ template<typename T, typename... NRest, int... Ints1, typename... DRest, int...
   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 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>;
 };
@@ -302,6 +303,8 @@ struct expr_less_impl<T, power<T, Ints...>, Pred> : std::true_type {};
 template<typename Lhs, typename Rhs, template<typename, typename, auto...> typename Pred>
 using expr_less = expr_less_impl<Lhs, Rhs, Pred>;
 
+template<typename T1, typename T2>
+using type_list_name_less = expr_less<T1, T2, type_name_less>;
 
 // expr_fractions
 template<typename Num = type_list<>, typename Den = type_list<>>
@@ -387,8 +390,8 @@ template<typename NumList, typename DenList, SymbolicArg OneType, template<typen
  * @tparam Lhs lhs of the operation
  * @tparam Rhs rhs of the operation
  */
-template<template<typename...> typename To, SymbolicArg OneType, template<typename, typename> typename Pred,
-         typename Lhs, typename Rhs>
+template<template<typename...> typename To, SymbolicArg OneType,
+         template<typename, typename> typename Pred = type_list_name_less, typename Lhs, typename Rhs>
 [[nodiscard]] MP_UNITS_CONSTEVAL auto expr_multiply(Lhs, Rhs)
 {
   if constexpr (is_same_v<Lhs, OneType>) {
@@ -422,8 +425,8 @@ template<template<typename...> typename To, SymbolicArg OneType, template<typena
  * @tparam Lhs lhs of the operation
  * @tparam Rhs rhs of the operation
  */
-template<template<typename...> typename To, SymbolicArg OneType, template<typename, typename> typename Pred,
-         typename Lhs, typename Rhs>
+template<template<typename...> typename To, SymbolicArg OneType,
+         template<typename, typename> typename Pred = type_list_name_less, typename Lhs, typename Rhs>
 [[nodiscard]] MP_UNITS_CONSTEVAL auto expr_divide(Lhs lhs, Rhs rhs)
 {
   if constexpr (is_same_v<Lhs, Rhs>) {
@@ -489,7 +492,7 @@ template<std::intmax_t Num, std::intmax_t Den, template<typename...> typename To
  * @tparam T Expression being the base of the operation
  */
 template<std::intmax_t Num, std::intmax_t Den, template<typename...> typename To, SymbolicArg OneType,
-         template<typename, typename> typename Pred, typename T>
+         template<typename, typename> typename Pred = type_list_name_less, typename T>
   requires detail::non_zero<Den>
 [[nodiscard]] consteval auto expr_pow(T v)
 {
@@ -552,7 +555,7 @@ template<template<typename> typename Proj, template<typename...> typename To, Sy
  * @tparam T expression template to map from
  */
 template<template<typename> typename Proj, template<typename...> typename To, SymbolicArg OneType,
-         template<typename, typename> typename Pred, typename T>
+         template<typename, typename> typename Pred = type_list_name_less, typename T>
 [[nodiscard]] consteval auto expr_map(T)
 {
   if constexpr (type_list_size<typename T::_num_> + type_list_size<typename T::_den_> == 0)
diff --git a/src/core/include/mp-units/framework/quantity.h b/src/core/include/mp-units/framework/quantity.h
index ec6f26bfa..3d829769e 100644
--- a/src/core/include/mp-units/framework/quantity.h
+++ b/src/core/include/mp-units/framework/quantity.h
@@ -143,27 +143,27 @@ class quantity {
 
   // static member functions
   [[nodiscard]] static constexpr quantity zero() noexcept
-    requires requires { quantity_values<rep>::zero(); }
+    requires requires { representation_values<rep>::zero(); }
   {
-    return {quantity_values<rep>::zero(), R};
+    return {representation_values<rep>::zero(), R};
   }
 
   [[nodiscard]] static constexpr quantity one() noexcept
-    requires requires { quantity_values<rep>::one(); }
+    requires requires { representation_values<rep>::one(); }
   {
-    return {quantity_values<rep>::one(), R};
+    return {representation_values<rep>::one(), R};
   }
 
   [[nodiscard]] static constexpr quantity min() noexcept
-    requires requires { quantity_values<rep>::min(); }
+    requires requires { representation_values<rep>::min(); }
   {
-    return {quantity_values<rep>::min(), R};
+    return {representation_values<rep>::min(), R};
   }
 
   [[nodiscard]] static constexpr quantity max() noexcept
-    requires requires { quantity_values<rep>::max(); }
+    requires requires { representation_values<rep>::max(); }
   {
-    return {quantity_values<rep>::max(), R};
+    return {representation_values<rep>::max(), R};
   }
 
   // construction, assignment, destruction
@@ -446,7 +446,7 @@ class quantity {
     }
   friend constexpr decltype(auto) operator/=(Q&& lhs, const Value& val)
   {
-    MP_UNITS_EXPECTS_DEBUG(val != quantity_values<Value>::zero());
+    MP_UNITS_EXPECTS_DEBUG(val != representation_values<Value>::zero());
     // TODO use /= when compiler bug is resolved:
     // https://developercommunity.visualstudio.com/t/Discrepancy-in-Behavior-of-operator-an/10732445
     lhs.numerical_value_is_an_implementation_detail_ = lhs.numerical_value_is_an_implementation_detail_ / val;
@@ -577,7 +577,7 @@ class quantity {
             (!Reference<Value>) && detail::InvokeResultOf<quantity_spec, std::divides<>, Rep, const Value&>
   [[nodiscard]] friend constexpr QuantityOf<quantity_spec> auto operator/(const Q& q, const Value& val)
   {
-    MP_UNITS_EXPECTS_DEBUG(val != quantity_values<Value>::zero());
+    MP_UNITS_EXPECTS_DEBUG(val != representation_values<Value>::zero());
     return ::mp_units::quantity{q.numerical_value_ref_in(unit) / val, R};
   }
 
diff --git a/src/core/include/mp-units/framework/quantity_concepts.h b/src/core/include/mp-units/framework/quantity_concepts.h
index 275763ce7..c4bba5e32 100644
--- a/src/core/include/mp-units/framework/quantity_concepts.h
+++ b/src/core/include/mp-units/framework/quantity_concepts.h
@@ -43,6 +43,10 @@ template<typename T>
 constexpr bool is_derived_from_specialization_of_quantity =
   requires(T* type) { to_base_specialization_of_quantity(type); };
 
+template<typename T>
+  requires is_derived_from_specialization_of_quantity<T>
+constexpr bool is_quantity<T> = true;
+
 }  // namespace detail
 
 /**
diff --git a/src/core/include/mp-units/framework/quantity_spec.h b/src/core/include/mp-units/framework/quantity_spec.h
index c0395069d..54437067c 100644
--- a/src/core/include/mp-units/framework/quantity_spec.h
+++ b/src/core/include/mp-units/framework/quantity_spec.h
@@ -106,12 +106,6 @@ template<auto... Args>
     return ch;
 }
 
-template<NamedQuantitySpec Lhs, NamedQuantitySpec Rhs>
-struct quantity_spec_less : std::bool_constant<type_name<Lhs>() < type_name<Rhs>()> {};
-
-template<typename T1, typename T2>
-using type_list_of_quantity_spec_less = expr_less<T1, T2, quantity_spec_less>;
-
 template<NamedQuantitySpec Q>
   requires requires { Q::dimension; }
 using to_dimension = MP_UNITS_NONCONST_TYPE(Q::dimension);
@@ -127,16 +121,14 @@ struct quantity_spec_interface_base {
   [[nodiscard]] friend consteval QuantitySpec auto operator*(Lhs lhs, Rhs rhs)
   {
     return clone_kind_of<Lhs{}, Rhs{}>(
-      expr_multiply<derived_quantity_spec, struct dimensionless, type_list_of_quantity_spec_less>(remove_kind(lhs),
-                                                                                                  remove_kind(rhs)));
+      expr_multiply<derived_quantity_spec, struct dimensionless>(remove_kind(lhs), remove_kind(rhs)));
   }
 
   template<QuantitySpec Lhs, QuantitySpec Rhs>
   [[nodiscard]] friend consteval QuantitySpec auto operator/(Lhs lhs, Rhs rhs)
   {
     return clone_kind_of<Lhs{}, Rhs{}>(
-      expr_divide<derived_quantity_spec, struct dimensionless, type_list_of_quantity_spec_less>(remove_kind(lhs),
-                                                                                                remove_kind(rhs)));
+      expr_divide<derived_quantity_spec, struct dimensionless>(remove_kind(lhs), remove_kind(rhs)));
   }
 
   template<QuantitySpec Lhs, QuantitySpec Rhs>
@@ -433,8 +425,7 @@ struct derived_quantity_spec_impl :
   using _base_type_ = derived_quantity_spec_impl;
   using _base_ = expr_fractions<dimensionless, Expr...>;
 
-  static constexpr Dimension auto dimension =
-    expr_map<to_dimension, derived_dimension, struct dimension_one, type_list_of_base_dimension_less>(_base_{});
+  static constexpr Dimension auto dimension = expr_map<to_dimension, derived_dimension, struct dimension_one>(_base_{});
   static constexpr quantity_character character =
     derived_quantity_character(typename _base_::_num_{}, typename _base_::_den_{});
 };
@@ -563,8 +554,7 @@ template<std::intmax_t Num, std::intmax_t Den = 1, QuantitySpec Q>
 [[nodiscard]] consteval QuantitySpec auto pow(Q 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::remove_kind(q)));
 }
 
 
@@ -703,7 +693,7 @@ template<QuantitySpec Q, int... Ints>
   requires requires { Q::_equation_; }
 [[nodiscard]] consteval auto explode_to_equation(power<Q, Ints...>)
 {
-  constexpr ratio exp = power<Q, Ints...>::exponent;
+  constexpr ratio exp = power<Q, Ints...>::_exponent_;
   return explode_to_equation_result{
     pow<exp.num, exp.den>(Q::_equation_),
     defines_equation(Q{}) ? specs_convertible_result::yes : specs_convertible_result::explicit_conversion};
@@ -917,13 +907,13 @@ template<typename From, typename To>
   constexpr auto qto = map_power(To{});
   if constexpr (get_kind_tree_root(qfrom) == get_kind_tree_root(qto)) {
     if constexpr (is_specialization_of_power<From> && is_specialization_of_power<To>)
-      return extract_results{true, typename From::factor{}, typename To::factor{}, prepend_rest::no};
+      return extract_results{true, typename From::_factor_{}, typename To::_factor_{}, prepend_rest::no};
     else
       return extract_results{true, qfrom, qto, prepend_rest::no};
   } else {
     auto normalize = []<typename Q>(Q) {
       if constexpr (is_specialization_of_power<Q>)
-        return std::tuple{typename Q::factor{}, Q::exponent};
+        return std::tuple{typename Q::_factor_{}, Q::_exponent_};
       else
         return std::tuple{Q{}, ratio{1}};
     };
@@ -1526,7 +1516,7 @@ template<QuantitySpec Q>
   } else if constexpr (requires { Q::_parent_; }) {
     return get_kind_tree_root(Q::_parent_);
   } else if constexpr (DerivedQuantitySpec<Q>) {
-    return expr_map<to_kind, derived_quantity_spec, struct dimensionless, type_list_of_quantity_spec_less>(q);
+    return expr_map<to_kind, derived_quantity_spec, struct dimensionless>(q);
   } else {
     // root quantity
     return q;
diff --git a/src/core/include/mp-units/framework/representation_concepts.h b/src/core/include/mp-units/framework/representation_concepts.h
index 66a6db2ff..414c08752 100644
--- a/src/core/include/mp-units/framework/representation_concepts.h
+++ b/src/core/include/mp-units/framework/representation_concepts.h
@@ -33,10 +33,11 @@ import std;
 #else
 #include <concepts>
 #include <cstdint>
+#include <cstdlib>
 #include <functional>
 #include <type_traits>
-#endif
-#endif
+#endif  // MP_UNITS_IMPORT_STD
+#endif  // MP_UNITS_IN_MODULE_INTERFACE
 
 namespace mp_units {
 
@@ -62,105 +63,244 @@ namespace mp_units {
  */
 MP_UNITS_EXPORT enum class quantity_character : std::int8_t { scalar, complex, vector, tensor };
 
+MP_UNITS_EXPORT template<typename T>
+constexpr bool disable_scalar = false;
+
+template<>
+MP_UNITS_INLINE constexpr bool disable_scalar<bool> = true;
+
 namespace detail {
 
 template<typename T>
 concept WeaklyRegular = std::copyable<T> && std::equality_comparable<T>;
 
 template<typename T>
-concept Scalar = is_scalar<T>;
+concept Scalar = (!disable_scalar<T>) && WeaklyRegular<T> && requires(T a, T b) {
+  // scalar operations
+  { -a } -> std::common_with<T>;
+  { a + b } -> std::common_with<T>;
+  { a - b } -> std::common_with<T>;
+  { a* b } -> std::common_with<T>;
+  { a / b } -> std::common_with<T>;
+};
 
-template<typename T>
-concept Complex = is_complex<T>;
+namespace real_impl {
+
+void real() = delete;  // poison pill
+
+struct real_t {
+  [[nodiscard]] constexpr Scalar auto operator()(const WeaklyRegular auto& clx) const
+    requires requires { clx.real(); } || requires { real(clx); }
+  {
+    if constexpr (requires { clx.real(); })
+      return clx.real();
+    else if constexpr (requires { real(clx); })
+      return real(clx);
+  }
+};
+
+}  // namespace real_impl
+
+}  // namespace detail
+
+inline namespace cpo {
+
+MP_UNITS_EXPORT inline constexpr ::mp_units::detail::real_impl::real_t real;
+
+}
+
+namespace detail::imag_impl {
+
+void imag() = delete;  // poison pill
+
+struct imag_t {
+  [[nodiscard]] constexpr Scalar auto operator()(const WeaklyRegular auto& clx) const
+    requires requires { clx.imag(); } || requires { imag(clx); }
+  {
+    if constexpr (requires { clx.imag(); })
+      return clx.imag();
+    else if constexpr (requires { imag(clx); })
+      return imag(clx);
+  }
+};
+
+}  // namespace detail::imag_impl
+
+inline namespace cpo {
+
+MP_UNITS_EXPORT inline constexpr ::mp_units::detail::imag_impl::imag_t imag;
+
+}
+
+namespace detail::modulus_impl {
+
+void modulus() = delete;  // poison pill
+void abs() = delete;      // poison pill
+
+struct modulus_t {
+  [[nodiscard]] constexpr Scalar auto operator()(const WeaklyRegular auto& clx) const
+    requires requires { clx.modulus(); } || requires { modulus(clx); } || requires { clx.abs(); } ||
+             requires { abs(clx); }
+  {
+    if constexpr (requires { clx.modulus(); })
+      return clx.modulus();
+    else if constexpr (requires { modulus(clx); })
+      return modulus(clx);
+    // `std` made a precedence of using `abs` for modulo on `std::complex`
+    else if constexpr (requires { clx.abs(); })
+      return clx.abs();
+    else if constexpr (requires { abs(clx); })
+      return abs(clx);
+  }
+};
+
+}  // namespace detail::modulus_impl
+
+inline namespace cpo {
+
+MP_UNITS_EXPORT inline constexpr ::mp_units::detail::modulus_impl::modulus_t modulus;
+
+}
+
+MP_UNITS_EXPORT template<typename T>
+constexpr bool disable_complex = false;
+
+namespace detail {
 
 template<typename T>
-concept Vector = is_vector<T>;
+concept Complex =
+  (!disable_complex<T>) && WeaklyRegular<T> && Scalar<value_type_t<T>> &&
+  std::constructible_from<T, value_type_t<T>, value_type_t<T>> && requires(T a, T b, value_type_t<T> s) {
+    // complex operations
+    { -a } -> std::common_with<T>;
+    { a + b } -> std::common_with<T>;
+    { a - b } -> std::common_with<T>;
+    { a* b } -> std::common_with<T>;
+    { a / b } -> std::common_with<T>;
+    { a* s } -> std::common_with<T>;
+    { s* a } -> std::common_with<T>;
+    { a / s } -> std::common_with<T>;
+    ::mp_units::real(a);
+    ::mp_units::imag(a);
+    ::mp_units::modulus(a);
+  };
+
+namespace magnitude_impl {
+
+void magnitude() = delete;  // poison pill
+void abs() = delete;        // poison pill
+
+struct magnitude_t {
+  template<WeaklyRegular T>
+  [[nodiscard]] constexpr Scalar auto operator()(const T& vec) const
+    requires requires { vec.magnitude(); } || requires { magnitude(vec); } ||
+             (Scalar<T> &&
+              (requires { vec.abs(); } || requires { abs(vec); } || (std::is_arithmetic_v<T> && (!is_same_v<T, bool>))))
+  {
+    if constexpr (requires { vec.magnitude(); })
+      return vec.magnitude();
+    else if constexpr (requires { magnitude(vec); })
+      return magnitude(vec);
+    // allow scalar types to represent one dimensional vector quantities
+    if constexpr (Scalar<T>) {
+      if constexpr (requires { vec.abs(); })
+        return vec.abs();
+      else if constexpr (requires { abs(vec); })
+        return abs(vec);
+      else if constexpr (std::is_arithmetic_v<T> && (!is_same_v<T, bool>))
+#if MP_UNITS_HOSTED || __cpp_lib_freestanding_cstdlib >= 202306L
+        return std::abs(vec);
+#else
+        return vec >= 0 ? vec : -vec;
+#endif
+    }
+  }
+};
+
+}  // namespace magnitude_impl
+
+}  // namespace detail
+
+inline namespace cpo {
+
+MP_UNITS_EXPORT inline constexpr ::mp_units::detail::magnitude_impl::magnitude_t magnitude;
+
+}
+
+MP_UNITS_EXPORT template<typename T>
+constexpr bool disable_vector = false;
+
+namespace detail {
 
 template<typename T>
-concept Tensor = is_tensor<T>;
+concept Vector =
+  (!disable_vector<T>) && WeaklyRegular<T> && Scalar<value_type_t<T>> && requires(T a, T b, value_type_t<T> s) {
+    // vector operations
+    { -a } -> std::common_with<T>;
+    { a + b } -> std::common_with<T>;
+    { a - b } -> std::common_with<T>;
+    { a* s } -> std::common_with<T>;
+    { s* a } -> std::common_with<T>;
+    { a / s } -> std::common_with<T>;
+    ::mp_units::magnitude(a);
+    // TODO should we check for the below as well (e.g., when `size() > 1` or `2`)
+    // { zero_vector<T>() } -> Vector;
+    // { unit_vector(a) } -> Vector;
+    // { scalar_product(a, b) } -> Scalar;
+    // { vector_product(a, b) } -> Vector;
+    // { tensor_product(a, b) } -> Tensor2;
+  };
 
-template<typename T, quantity_character Ch>
-concept IsOfCharacter =
-  (Ch == quantity_character::scalar && is_scalar<T>) || (Ch == quantity_character::complex && is_complex<T>) ||
-  (Ch == quantity_character::vector && is_vector<T>) || (Ch == quantity_character::tensor && is_tensor<T>);
+// TODO provide when some actual operations will be required
+// template<typename T>
+// concept Tensor = is_tensor<T> && WeaklyRegular<T>;  // && requires(T a, T b) {
+//                                                     // tensor operations
+//                                                     // { tensor_product(a, b) } -> Tensor4;
+//                                                     // { inner_product(a, b) } -> Tensor2;
+//                                                     // { scalar_product(a, b) } -> Scalar;
+// //};
+
+template<typename T>
+constexpr bool is_quantity = false;
 
 template<typename T>
 using scaling_factor_type_t = conditional<treat_as_floating_point<T>, long double, std::intmax_t>;
 
 template<typename T>
-concept ScalarRepresentation = Scalar<T> && WeaklyRegular<T> && requires(T a, T b, scaling_factor_type_t<T> f) {
+concept ScalarRepresentation = (!is_quantity<T>) && Scalar<T> && requires(T a, T b, scaling_factor_type_t<T> f) {
   // scaling
-  { a* f } -> Scalar;
-  { f* a } -> Scalar;
-  { a / f } -> Scalar;
-
-  // scalar operations
-  { -a } -> Scalar;
-  { a + b } -> Scalar;
-  { a - b } -> Scalar;
-  { a* b } -> Scalar;
-  { a / b } -> Scalar;
+  { a* f } -> std::common_with<T>;
+  { f* a } -> std::common_with<T>;
+  { a / f } -> std::common_with<T>;
 };
 
 template<typename T>
-concept ComplexRepresentation = Complex<T> && WeaklyRegular<T> && requires(T a, T b, scaling_factor_type_t<T> f) {
+concept ComplexRepresentation = (!is_quantity<T>) && Complex<T> && requires(T a, T b, scaling_factor_type_t<T> f) {
   // scaling
   // TODO The below conversion to `T` is an exception compared to other representation types
   // `std::complex<T>` * `U` do not work, but `std::complex<T>` is convertible from `U`
   // Maybe expose this as a customization point?
-  { a* T(f) } -> Complex;
-  { T(f) * a } -> Complex;
-  { a / T(f) } -> Complex;
-
-  // complex operations
-  { -a } -> Complex;
-  { a + b } -> Complex;
-  { a - b } -> Complex;
-  { a* b } -> Complex;
-  { a / b } -> Complex;
-  { ::mp_units::real(a) } -> Scalar;
-  { ::mp_units::imag(a) } -> Scalar;
-  { ::mp_units::modulus(a) } -> Scalar;
+  { a* T(f) } -> std::common_with<T>;
+  { T(f) * a } -> std::common_with<T>;
+  { a / T(f) } -> std::common_with<T>;
 };
 
-// TODO how to check for a complex(Scalar, Scalar) -> Complex?
-
 template<typename T>
-concept VectorRepresentation = Vector<T> && WeaklyRegular<T> && requires(T a, T b, scaling_factor_type_t<T> f) {
-  // scaling
-  { a* f } -> Vector;
-  { f* a } -> Vector;
-  { a / f } -> Vector;
-
-  // vector operations
-  { -a } -> Vector;
-  { a + b } -> Vector;
-  { a - b } -> Vector;
-  { ::mp_units::norm(a) } -> Scalar;
-  // TBD
-  // { zero_vector<T>() } -> Vector;
-  // { unit_vector(a) } -> Vector;
-  // { scalar_product(a, b) } -> Scalar;
-  // { vector_product(a, b) } -> Vector;
-  // { tensor_product(a, b) } -> Tensor2;
-  // divergence(a)
-  // rotation(a)
-};
+concept VectorRepresentation = (!is_quantity<T>) && Vector<T>;
 
-template<typename T>
-concept TensorRepresentation = Tensor<T> && WeaklyRegular<T>;  // && requires(T a, T b) {
-                                                               // TBD
-                                                               // tensor operations
-                                                               // { tensor_product(a, b) } -> Tensor4;
-                                                               // { inner_product(a, b) } -> Tensor2;
-                                                               // { scalar_product(a, b) } -> Scalar;
-//};
+// template<typename T>
+// concept TensorRepresentation = (!is_quantity<T>) && Tensor<T>;
+
+template<typename T, quantity_character Ch>
+concept IsOfCharacter =
+  (Ch == quantity_character::scalar && Scalar<T>) || (Ch == quantity_character::complex && Complex<T>) ||
+  (Ch == quantity_character::vector && Vector<T>);  // || (Ch == quantity_character::tensor && Tensor<T>);
 
 }  // namespace detail
 
 MP_UNITS_EXPORT template<typename T>
 concept Representation = detail::ScalarRepresentation<T> || detail::ComplexRepresentation<T> ||
-                         detail::VectorRepresentation<T> || detail::TensorRepresentation<T>;
+                         detail::VectorRepresentation<T>;  // || detail::TensorRepresentation<T>;
 
 MP_UNITS_EXPORT template<typename T, auto V>
 concept RepresentationOf =
diff --git a/src/core/include/mp-units/framework/symbol_text.h b/src/core/include/mp-units/framework/symbol_text.h
index 71fc98b02..af3a84528 100644
--- a/src/core/include/mp-units/framework/symbol_text.h
+++ b/src/core/include/mp-units/framework/symbol_text.h
@@ -38,19 +38,8 @@ import std;
 #include <compare>  // IWYU pragma: export
 #include <cstddef>
 #include <cstdint>
-#endif
-#endif
-
-#if __cpp_lib_text_encoding
-#ifndef MP_UNITS_IN_MODULE_INTERFACE
-#ifdef MP_UNITS_IMPORT_STD
-import std;
-#else
-#include <text_encoding>
-#endif
-#endif
-static_assert(std::text_encoding::literal().mib() == std::text_encoding::id::UTF8);
-#endif
+#endif  // MP_UNITS_IMPORT_STD
+#endif  // MP_UNITS_IN_MODULE_INTERFACE
 
 namespace mp_units {
 
@@ -74,15 +63,22 @@ constexpr bool is_basic_literal_character_set_char(char ch)
   return ch == 0x00 || (0x07 <= ch && ch <= 0x0D) || (0x20 <= ch && ch <= 0x7E);
 };
 
+template<typename InputIt>
+constexpr bool is_basic_literal_character_set(InputIt begin, InputIt end) noexcept
+{
+  return all_of(begin, end, is_basic_literal_character_set_char);
+}
+
 template<std::size_t N>
 constexpr bool is_basic_literal_character_set(const char (&txt)[N]) noexcept
 {
-  return detail::all_of(std::begin(txt), std::end(txt), is_basic_literal_character_set_char);
+  return is_basic_literal_character_set(std::begin(txt), std::end(txt));
 }
 
 template<std::size_t N>
 constexpr fixed_u8string<N> to_u8string(fixed_string<N> txt)
 {
+  MP_UNITS_EXPECTS(is_basic_literal_character_set(txt.begin(), txt.end()));
   return std::bit_cast<fixed_u8string<N>>(txt);
 }
 
diff --git a/src/core/include/mp-units/framework/unit.h b/src/core/include/mp-units/framework/unit.h
index ffea57200..132b5fd37 100644
--- a/src/core/include/mp-units/framework/unit.h
+++ b/src/core/include/mp-units/framework/unit.h
@@ -152,12 +152,6 @@ struct derived_unit;
 
 namespace detail {
 
-template<Unit Lhs, Unit Rhs>
-struct unit_less : std::bool_constant<type_name<Lhs>() < type_name<Rhs>()> {};
-
-template<typename T1, typename T2>
-using type_list_of_unit_less = expr_less<T1, T2, unit_less>;
-
 struct unit_interface {
   /**
    * Multiplication by `1` returns the same unit, otherwise `scaled_unit` is being returned.
@@ -200,7 +194,7 @@ struct unit_interface {
   template<Unit Lhs, Unit Rhs>
   [[nodiscard]] friend MP_UNITS_CONSTEVAL Unit auto operator*(Lhs lhs, Rhs rhs)
   {
-    return expr_multiply<derived_unit, struct one, type_list_of_unit_less>(lhs, rhs);
+    return expr_multiply<derived_unit, struct one>(lhs, rhs);
   }
 
   /**
@@ -211,7 +205,7 @@ struct unit_interface {
   template<Unit Lhs, Unit Rhs>
   [[nodiscard]] friend MP_UNITS_CONSTEVAL Unit auto operator/(Lhs lhs, Rhs rhs)
   {
-    return expr_divide<derived_unit, struct one, type_list_of_unit_less>(lhs, rhs);
+    return expr_divide<derived_unit, struct one>(lhs, rhs);
   }
 
   template<Unit Lhs, Unit Rhs>
@@ -621,7 +615,7 @@ template<std::intmax_t Num, std::intmax_t Den = 1, Unit U>
   requires detail::non_zero<Den>
 [[nodiscard]] consteval Unit auto pow(U 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>(u);
 }
 
 /**
@@ -696,7 +690,7 @@ template<Unit U1, Unit U2>
     else if constexpr (is_positive_integral_power(canonical_rhs.mag / canonical_lhs.mag))
       return u1;
     else {
-      if constexpr (detail::unit_less<U1, U2>::value)
+      if constexpr (detail::type_name_less<U1, U2>::value)
         return common_unit<U1, U2>{};
       else
         return common_unit<U2, U1>{};
@@ -730,7 +724,7 @@ struct collapse_common_unit_impl<List, NewUnit, true> {
 
 template<Unit NewUnit, Unit... Us>
 using collapse_common_unit = type_list_unique<
-  type_list_sort<typename collapse_common_unit_impl<type_list<>, NewUnit, false, Us...>::type, type_list_of_unit_less>>;
+  type_list_sort<typename collapse_common_unit_impl<type_list<>, NewUnit, false, Us...>::type, type_list_name_less>>;
 
 }  // namespace detail
 
diff --git a/src/core/include/mp-units/math.h b/src/core/include/mp-units/math.h
index 490445a2f..8b9e63a70 100644
--- a/src/core/include/mp-units/math.h
+++ b/src/core/include/mp-units/math.h
@@ -55,7 +55,7 @@ namespace mp_units {
  */
 template<std::intmax_t Num, std::intmax_t Den = 1, auto R, typename Rep>
   requires detail::non_zero<Den> && requires(Rep v) {
-    quantity_values<Rep>::one();
+    representation_values<Rep>::one();
     requires requires { pow(v, 1.0); } || requires { std::pow(v, 1.0); };
   }
 [[nodiscard]] constexpr quantity<pow<Num, Den>(R), Rep> pow(const quantity<R, Rep>& q) noexcept
@@ -328,7 +328,7 @@ template<Unit auto To, auto R, typename Rep>
   requires((!treat_as_floating_point<Rep>) || requires(Rep v) { floor(v); } || requires(Rep v) { std::floor(v); }) &&
           (equivalent(To, get_unit(R)) || requires {
             q.force_in(To);
-            quantity_values<Rep>::one();
+            representation_values<Rep>::one();
           })
 {
   const auto handle_signed_results = [&]<typename T>(const T& res) {
@@ -365,7 +365,7 @@ template<Unit auto To, auto R, typename Rep>
   requires((!treat_as_floating_point<Rep>) || requires(Rep v) { ceil(v); } || requires(Rep v) { std::ceil(v); }) &&
           (equivalent(To, get_unit(R)) || requires {
             q.force_in(To);
-            quantity_values<Rep>::one();
+            representation_values<Rep>::one();
           })
 {
   const auto handle_signed_results = [&]<typename T>(const T& res) {
@@ -404,7 +404,7 @@ template<Unit auto To, auto R, typename Rep>
   requires((!treat_as_floating_point<Rep>) || requires(Rep v) { round(v); } || requires(Rep v) { std::round(v); }) &&
           (equivalent(To, get_unit(R)) || requires {
             ::mp_units::floor<To>(q);
-            quantity_values<Rep>::one();
+            representation_values<Rep>::one();
           })
 {
   if constexpr (equivalent(To, get_unit(R))) {
@@ -438,11 +438,11 @@ template<Unit auto To, auto R, typename Rep>
 template<Unit auto To, auto R, typename Rep>
 [[nodiscard]] constexpr QuantityOf<dimensionless / get_quantity_spec(R)> auto inverse(const quantity<R, Rep>& q)
   requires requires {
-    quantity_values<Rep>::one();
+    representation_values<Rep>::one();
     value_cast<To>(1 / q);
   }
 {
-  return (quantity_values<Rep>::one() * one).force_in(To * quantity<R, Rep>::unit) / q;
+  return (representation_values<Rep>::one() * one).force_in(To * quantity<R, Rep>::unit) / q;
 }
 
 /**
diff --git a/test/runtime/linear_algebra_test.cpp b/test/runtime/linear_algebra_test.cpp
index 85a7afc72..200bf644b 100644
--- a/test/runtime/linear_algebra_test.cpp
+++ b/test/runtime/linear_algebra_test.cpp
@@ -43,12 +43,6 @@ import mp_units;
 template<typename Rep = double>
 using vector = STD_LA::fixed_size_column_vector<Rep, 3>;
 
-template<class Rep>
-constexpr bool mp_units::treat_as_floating_point<vector<Rep>> = mp_units::treat_as_floating_point<Rep>;
-
-template<typename Rep>
-constexpr bool mp_units::is_vector<vector<Rep>> = true;
-
 template<typename Rep>
 std::ostream& operator<<(std::ostream& os, const vector<Rep>& v)
 {
@@ -87,8 +81,6 @@ template<typename T, typename U>
 }
 
 template<Quantity Q1, Quantity Q2>
-  requires is_vector<typename Q1::rep> && is_vector<typename Q2::rep> &&
-           requires(typename Q1::rep v1, typename Q2::rep v2) { cross_product(v1, v2); }
 [[nodiscard]] constexpr QuantityOf<Q1::quantity_spec * Q2::quantity_spec> auto cross_product(const Q1& q1, const Q2& q2)
 {
   return cross_product(q1.numerical_value_ref_in(q1.unit), q2.numerical_value_ref_in(q2.unit)) *
@@ -299,10 +291,6 @@ TEST_CASE("vector quantity", "[la]")
   }
 }
 
-template<class T>
-  requires mp_units::is_scalar<T>
-constexpr bool mp_units::is_vector<T> = true;
-
 TEST_CASE("vector of quantities", "[la]")
 {
   SECTION("cast of unit")
diff --git a/test/static/concepts_test.cpp b/test/static/concepts_test.cpp
index fbd20241a..d0d4552b0 100644
--- a/test/static/concepts_test.cpp
+++ b/test/static/concepts_test.cpp
@@ -278,13 +278,16 @@ static_assert(!Representation<std::chrono::seconds>);
 // RepresentationOf
 static_assert(RepresentationOf<int, quantity_character::scalar>);
 static_assert(!RepresentationOf<int, quantity_character::complex>);
-static_assert(!RepresentationOf<int, quantity_character::vector>);
+static_assert(RepresentationOf<int, quantity_character::vector>);
 static_assert(!RepresentationOf<int, quantity_character::tensor>);
 static_assert(RepresentationOf<double, quantity_character::scalar>);
 static_assert(!RepresentationOf<double, quantity_character::complex>);
-static_assert(!RepresentationOf<double, quantity_character::vector>);
+static_assert(RepresentationOf<double, quantity_character::vector>);
 static_assert(!RepresentationOf<double, quantity_character::tensor>);
 static_assert(!RepresentationOf<bool, quantity_character::scalar>);
+static_assert(!RepresentationOf<bool, quantity_character::complex>);
+static_assert(!RepresentationOf<bool, quantity_character::vector>);
+static_assert(!RepresentationOf<bool, quantity_character::tensor>);
 static_assert(!RepresentationOf<std::optional<int>, quantity_character::scalar>);
 #if MP_UNITS_HOSTED
 static_assert(RepresentationOf<std::complex<double>, quantity_character::complex>);
diff --git a/test/static/custom_rep_test_min_impl.cpp b/test/static/custom_rep_test_min_impl.cpp
index e2810eaac..a07524d04 100644
--- a/test/static/custom_rep_test_min_impl.cpp
+++ b/test/static/custom_rep_test_min_impl.cpp
@@ -60,9 +60,6 @@ class min_impl {
 
 }  // namespace
 
-template<typename T>
-constexpr bool mp_units::is_scalar<min_impl<T>> = true;
-
 template<typename T, typename U>
 struct std::common_type<min_impl<T>, min_impl<U>> : std::type_identity<min_impl<std::common_type_t<T, U>>> {};
 template<typename T, typename U>
diff --git a/test/static/hep_test.cpp b/test/static/hep_test.cpp
index 62407bd40..623963f55 100644
--- a/test/static/hep_test.cpp
+++ b/test/static/hep_test.cpp
@@ -24,10 +24,6 @@
 #include <mp-units/systems/isq/mechanics.h>
 #include <mp-units/systems/si.h>
 
-template<class T>
-  requires mp_units::is_scalar<T>
-constexpr bool mp_units::is_vector<T> = true;
-
 namespace {
 
 using namespace mp_units;
diff --git a/test/static/international_test.cpp b/test/static/international_test.cpp
index 755eea73c..8d845f9a9 100644
--- a/test/static/international_test.cpp
+++ b/test/static/international_test.cpp
@@ -26,10 +26,6 @@
 #include <mp-units/systems/si/constants.h>
 #include <mp-units/systems/si/units.h>
 
-template<class T>
-  requires mp_units::is_scalar<T>
-constexpr bool mp_units::is_vector<T> = true;
-
 namespace {
 
 using namespace mp_units;
diff --git a/test/static/natural_test.cpp b/test/static/natural_test.cpp
index 9986149a5..3281192fd 100644
--- a/test/static/natural_test.cpp
+++ b/test/static/natural_test.cpp
@@ -22,10 +22,6 @@
 
 #include <mp-units/systems/natural.h>
 
-template<class T>
-  requires mp_units::is_scalar<T>
-constexpr bool mp_units::is_vector<T> = true;
-
 namespace {
 
 using namespace mp_units;
diff --git a/test/static/quantity_test.cpp b/test/static/quantity_test.cpp
index a9a4a5e74..3b8d14d58 100644
--- a/test/static/quantity_test.cpp
+++ b/test/static/quantity_test.cpp
@@ -47,9 +47,6 @@ import std;
 #endif
 #endif
 
-template<>
-constexpr bool mp_units::is_vector<int> = true;
-
 namespace {
 
 using namespace mp_units;
@@ -74,8 +71,10 @@ concept invalid_types = requires {
   requires !requires { typename Q<isq::length, double>; };      // quantity_spec instead of reference
   requires !requires { typename Q<isq::length[m], bool>; };     // bool is not a valid representation type
   requires !requires { typename Q<isq::length[m], quantity<isq::length[m]>>; };  // quantity used as Rep
-  requires !requires { typename Q<isq::position_vector[si::metre], double>; };   // vector representation expected
 #if MP_UNITS_HOSTED
+  requires !requires {
+    typename Q<isq::position_vector[si::metre], std::complex<double>>;
+  };  // vector representation expected
   requires !requires {
     typename Q<isq::length[si::metre], cartesian_vector<double>>;
   };  // scalar representation expected