diff --git a/src/core/include/mp-units/bits/hacks.h b/src/core/include/mp-units/bits/hacks.h
index 9dd88298..253738e3 100644
--- a/src/core/include/mp-units/bits/hacks.h
+++ b/src/core/include/mp-units/bits/hacks.h
@@ -79,7 +79,6 @@
 
 #if MP_UNITS_COMP_MSVC
 
-#define MP_UNITS_TYPENAME typename
 #define MP_UNITS_EXPRESSION(x) (x)
 #define MP_UNITS_IS_VALUE(x) (x)
 #define MP_UNITS_IS_CONST_EXPR(x) \
@@ -87,7 +86,6 @@
 
 #else
 
-#define MP_UNITS_TYPENAME
 #define MP_UNITS_EXPRESSION(x) x
 #define MP_UNITS_IS_VALUE(x) x
 #define MP_UNITS_IS_CONST_EXPR(x) x
diff --git a/src/core/include/mp-units/bits/sudo_cast.h b/src/core/include/mp-units/bits/sudo_cast.h
index 0873fd59..b96c3e34 100644
--- a/src/core/include/mp-units/bits/sudo_cast.h
+++ b/src/core/include/mp-units/bits/sudo_cast.h
@@ -46,7 +46,7 @@ template<typename T, typename Other>
 struct get_common_type : std::common_type<T, Other> {};
 
 template<typename T, typename Other>
-using maybe_common_type = MP_UNITS_TYPENAME
+using maybe_common_type =  
   std::conditional_t<has_common_type_v<T, Other>, get_common_type<T, Other>, std::type_identity<T>>::type;
 
 /**
@@ -108,7 +108,7 @@ template<Quantity To, typename From>
   constexpr auto q_unit = std::remove_reference_t<From>::unit;
   if constexpr (q_unit == To::unit) {
     // no scaling of the number needed
-    return {static_cast<MP_UNITS_TYPENAME To::rep>(std::forward<From>(q).numerical_value_is_an_implementation_detail_),
+    return {static_cast<  To::rep>(std::forward<From>(q).numerical_value_is_an_implementation_detail_),
             To::reference};  // this is the only (and recommended) way to do a truncating conversion on a number, so we
                              // are using static_cast to suppress all the compiler warnings on conversions
   } else {
@@ -116,12 +116,12 @@ template<Quantity To, typename From>
     using traits = magnitude_conversion_traits<To, std::remove_reference_t<From>>;
     if constexpr (std::is_floating_point_v<typename traits::multiplier_type>) {
       // this results in great assembly
-      auto res = static_cast<MP_UNITS_TYPENAME To::rep>(
+      auto res = static_cast<  To::rep>(
         static_cast<traits::c_type>(q.numerical_value_is_an_implementation_detail_) * traits::ratio);
       return {res, To::reference};
     } else {
       // this is slower but allows conversions like 2000 m -> 2 km without loosing data
-      auto res = static_cast<MP_UNITS_TYPENAME To::rep>(
+      auto res = static_cast<  To::rep>(
         static_cast<traits::c_type>(q.numerical_value_is_an_implementation_detail_) * traits::num_mult /
         traits::den_mult * traits::irr_mult);
       return {res, To::reference};
diff --git a/src/core/include/mp-units/bits/type_list.h b/src/core/include/mp-units/bits/type_list.h
index 203326c6..be9ea15c 100644
--- a/src/core/include/mp-units/bits/type_list.h
+++ b/src/core/include/mp-units/bits/type_list.h
@@ -68,7 +68,7 @@ struct type_list_map_impl<From<Args...>, To> {
 };
 
 template<TypeList From, template<typename...> typename To>
-using type_list_map = MP_UNITS_TYPENAME type_list_map_impl<From, To>::type;
+using type_list_map =   type_list_map_impl<From, To>::type;
 
 
 // element
@@ -105,7 +105,7 @@ struct type_list_front_impl<List<T, Ts...>> {
 };
 
 template<TypeList List>
-using type_list_front = MP_UNITS_TYPENAME type_list_front_impl<List>::type;
+using type_list_front =   type_list_front_impl<List>::type;
 
 // back
 template<TypeList List>
@@ -121,7 +121,7 @@ struct type_list_push_front_impl<List<OldTypes...>, NewTypes...> {
 };
 
 template<TypeList List, typename... Types>
-using type_list_push_front = MP_UNITS_TYPENAME type_list_push_front_impl<List, Types...>::type;
+using type_list_push_front =   type_list_push_front_impl<List, Types...>::type;
 
 // push_back
 template<typename List, typename... Types>
@@ -133,7 +133,7 @@ struct type_list_push_back_impl<List<OldTypes...>, NewTypes...> {
 };
 
 template<TypeList List, typename... Types>
-using type_list_push_back = MP_UNITS_TYPENAME type_list_push_back_impl<List, Types...>::type;
+using type_list_push_back =   type_list_push_back_impl<List, Types...>::type;
 
 // join
 template<typename List, typename... Rest>
@@ -143,11 +143,11 @@ struct type_list_join_impl {
 
 template<template<typename...> typename List, typename... First, typename... Second, typename... Rest>
 struct type_list_join_impl<List<First...>, List<Second...>, Rest...> {
-  using type = MP_UNITS_TYPENAME type_list_join_impl<List<First..., Second...>, Rest...>::type;
+  using type =   type_list_join_impl<List<First..., Second...>, Rest...>::type;
 };
 
 template<TypeList... Lists>
-using type_list_join = MP_UNITS_TYPENAME type_list_join_impl<Lists...>::type;
+using type_list_join =   type_list_join_impl<Lists...>::type;
 
 // split
 template<typename List, typename First, typename Second>
@@ -195,19 +195,19 @@ template<template<typename...> typename List, typename Lhs1, typename... LhsRest
          template<typename, typename> typename Pred>
   requires Pred<Lhs1, Rhs1>::value
 struct type_list_merge_sorted_impl<List<Lhs1, LhsRest...>, List<Rhs1, RhsRest...>, Pred> {
-  using type = MP_UNITS_TYPENAME type_list_push_front_impl<
+  using type =   type_list_push_front_impl<
     typename type_list_merge_sorted_impl<List<LhsRest...>, List<Rhs1, RhsRest...>, Pred>::type, Lhs1>::type;
 };
 
 template<template<typename...> typename List, typename Lhs1, typename... LhsRest, typename Rhs1, typename... RhsRest,
          template<typename, typename> typename Pred>
 struct type_list_merge_sorted_impl<List<Lhs1, LhsRest...>, List<Rhs1, RhsRest...>, Pred> {
-  using type = MP_UNITS_TYPENAME type_list_push_front_impl<
+  using type =   type_list_push_front_impl<
     typename type_list_merge_sorted_impl<List<Lhs1, LhsRest...>, List<RhsRest...>, Pred>::type, Rhs1>::type;
 };
 
 template<TypeList SortedList1, TypeList SortedList2, template<typename, typename> typename Pred>
-using type_list_merge_sorted = MP_UNITS_TYPENAME type_list_merge_sorted_impl<SortedList1, SortedList2, Pred>::type;
+using type_list_merge_sorted =   type_list_merge_sorted_impl<SortedList1, SortedList2, Pred>::type;
 
 // sort
 template<typename List, template<typename, typename> typename Pred>
@@ -227,13 +227,13 @@ template<template<typename...> typename List, typename... Types, template<typena
 struct type_list_sort_impl<List<Types...>, Pred> {
   using types = List<Types...>;
   using split = type_list_split_half<List<Types...>>;
-  using sorted_left = MP_UNITS_TYPENAME type_list_sort_impl<typename split::first_list, Pred>::type;
-  using sorted_right = MP_UNITS_TYPENAME type_list_sort_impl<typename split::second_list, Pred>::type;
-  using type = MP_UNITS_TYPENAME type_list_merge_sorted_impl<sorted_left, sorted_right, Pred>::type;
+  using sorted_left =   type_list_sort_impl<typename split::first_list, Pred>::type;
+  using sorted_right =   type_list_sort_impl<typename split::second_list, Pred>::type;
+  using type =   type_list_merge_sorted_impl<sorted_left, sorted_right, Pred>::type;
 };
 
 template<TypeList List, template<typename, typename> typename Pred>
-using type_list_sort = MP_UNITS_TYPENAME type_list_sort_impl<List, Pred>::type;
+using type_list_sort =   type_list_sort_impl<List, Pred>::type;
 
 }  // namespace mp_units::detail
 
diff --git a/src/core/include/mp-units/ext/type_traits.h b/src/core/include/mp-units/ext/type_traits.h
index 62e39f09..1ffd715e 100644
--- a/src/core/include/mp-units/ext/type_traits.h
+++ b/src/core/include/mp-units/ext/type_traits.h
@@ -56,7 +56,7 @@ struct conditional_impl<true> {
 MP_UNITS_EXPORT_BEGIN
 
 template<bool B, typename T, typename F>
-using conditional = MP_UNITS_TYPENAME detail::conditional_impl<B>::template type<T, F>;
+using conditional =   detail::conditional_impl<B>::template type<T, F>;
 
 // is_same
 template<class T, class U>
@@ -99,7 +99,7 @@ namespace detail {
 
 template<typename T>
 struct get_value_type {
-  using type = MP_UNITS_TYPENAME T::value_type;
+  using type =   T::value_type;
 };
 
 template<typename T>
@@ -112,13 +112,13 @@ struct get_element_type {
 template<typename T>
   requires requires { typename T::value_type; } || requires { typename T::element_type; }
 struct wrapped_type {
-  using type = MP_UNITS_TYPENAME
+  using type =  
     conditional<requires { typename T::value_type; }, detail::get_value_type<T>, detail::get_element_type<T>>::type;
 };
 
 template<typename T>
   requires requires { typename T::value_type; } || requires { typename T::element_type; }
-using wrapped_type_t = MP_UNITS_TYPENAME wrapped_type<T>::type;
+using wrapped_type_t =   wrapped_type<T>::type;
 
 template<typename T>
 struct value_type {
@@ -128,11 +128,11 @@ struct value_type {
 template<typename T>
   requires requires { typename wrapped_type_t<T>; }
 struct value_type<T> {
-  using type = MP_UNITS_TYPENAME wrapped_type_t<T>;
+  using type =   wrapped_type_t<T>;
 };
 
 template<typename T>
-using value_type_t = MP_UNITS_TYPENAME value_type<T>::type;
+using value_type_t =   value_type<T>::type;
 
 template<typename T, typename... Ts>
 concept one_of = (false || ... || std::same_as<T, Ts>);
diff --git a/src/core/include/mp-units/framework/expression_template.h b/src/core/include/mp-units/framework/expression_template.h
index 72a2db0e..2b607130 100644
--- a/src/core/include/mp-units/framework/expression_template.h
+++ b/src/core/include/mp-units/framework/expression_template.h
@@ -122,7 +122,7 @@ struct expr_type_impl<power<T, Ints...>> : std::type_identity<T> {};
 }  // namespace detail
 
 template<typename T>
-using expr_type = MP_UNITS_TYPENAME detail::expr_type_impl<T>::type;
+using expr_type =   detail::expr_type_impl<T>::type;
 
 namespace detail {
 
@@ -182,25 +182,25 @@ struct expr_consolidate_impl<type_list<T, Rest...>> {
 template<typename T, typename... Rest>
   requires(!is_specialization_of_power<T>)
 struct expr_consolidate_impl<type_list<T, T, Rest...>> {
-  using type = MP_UNITS_TYPENAME expr_consolidate_impl<type_list<power<T, 2>, Rest...>>::type;
+  using type =   expr_consolidate_impl<type_list<power<T, 2>, Rest...>>::type;
 };
 
 // replaces the instance of a type and a power of it with one with incremented power
 template<typename T, int... Ints, typename... Rest>
 struct expr_consolidate_impl<type_list<T, power<T, Ints...>, Rest...>> {
   using type =
-    MP_UNITS_TYPENAME expr_consolidate_impl<type_list<power_or_T<T, power<T, Ints...>::exponent + 1>, Rest...>>::type;
+      expr_consolidate_impl<type_list<power_or_T<T, power<T, Ints...>::exponent + 1>, Rest...>>::type;
 };
 
 // accumulates the powers of instances of the same type (removes the element in case the accumulation result is `0`)
 template<typename T, int... Ints1, int... Ints2, typename... Rest>
 struct expr_consolidate_impl<type_list<power<T, Ints1...>, power<T, Ints2...>, Rest...>> {
   static constexpr ratio r = power<T, Ints1...>::exponent + power<T, Ints2...>::exponent;
-  using type = MP_UNITS_TYPENAME expr_consolidate_impl<type_list<power_or_T<T, r>, Rest...>>::type;
+  using type =   expr_consolidate_impl<type_list<power_or_T<T, r>, Rest...>>::type;
 };
 
 template<typename List>
-using expr_consolidate = MP_UNITS_TYPENAME expr_consolidate_impl<List>::type;
+using expr_consolidate =   expr_consolidate_impl<List>::type;
 
 
 /**
diff --git a/src/core/include/mp-units/random.h b/src/core/include/mp-units/random.h
index a470c3b0..05251f3f 100644
--- a/src/core/include/mp-units/random.h
+++ b/src/core/include/mp-units/random.h
@@ -61,7 +61,7 @@ std::vector<typename Q::rep> bl_qty_to_rep(std::initializer_list<Q>& bl)
 template<Quantity Q, typename UnaryOperation>
 std::vector<typename Q::rep> fw_bl_pwc(std::initializer_list<Q>& bl, UnaryOperation fw)
 {
-  using rep = MP_UNITS_TYPENAME Q::rep;
+  using rep =   Q::rep;
   std::vector<rep> w_bl;
   w_bl.reserve(bl.size());
   for (const Q& qty : bl) {
@@ -93,8 +93,8 @@ MP_UNITS_EXPORT_BEGIN
 template<Quantity Q>
   requires std::integral<typename Q::rep>
 struct uniform_int_distribution : public std::uniform_int_distribution<typename Q::rep> {
-  using rep = MP_UNITS_TYPENAME Q::rep;
-  using base = MP_UNITS_TYPENAME std::uniform_int_distribution<rep>;
+  using rep =   Q::rep;
+  using base =   std::uniform_int_distribution<rep>;
 
   uniform_int_distribution() : base() {}
   uniform_int_distribution(const Q& a, const Q& b) :
@@ -118,8 +118,8 @@ struct uniform_int_distribution : public std::uniform_int_distribution<typename
 template<Quantity Q>
   requires std::floating_point<typename Q::rep>
 struct uniform_real_distribution : public std::uniform_real_distribution<typename Q::rep> {
-  using rep = MP_UNITS_TYPENAME Q::rep;
-  using base = MP_UNITS_TYPENAME std::uniform_real_distribution<rep>;
+  using rep =   Q::rep;
+  using base =   std::uniform_real_distribution<rep>;
 
   uniform_real_distribution() : base() {}
   uniform_real_distribution(const Q& a, const Q& b) :
@@ -143,8 +143,8 @@ struct uniform_real_distribution : public std::uniform_real_distribution<typenam
 template<Quantity Q>
   requires std::integral<typename Q::rep>
 struct binomial_distribution : public std::binomial_distribution<typename Q::rep> {
-  using rep = MP_UNITS_TYPENAME Q::rep;
-  using base = MP_UNITS_TYPENAME std::binomial_distribution<rep>;
+  using rep =   Q::rep;
+  using base =   std::binomial_distribution<rep>;
 
   binomial_distribution() : base() {}
   binomial_distribution(const Q& t, double p) : base(t.numerical_value_ref_in(Q::unit), p) {}
@@ -164,8 +164,8 @@ struct binomial_distribution : public std::binomial_distribution<typename Q::rep
 template<Quantity Q>
   requires std::integral<typename Q::rep>
 struct negative_binomial_distribution : public std::negative_binomial_distribution<typename Q::rep> {
-  using rep = MP_UNITS_TYPENAME Q::rep;
-  using base = MP_UNITS_TYPENAME std::negative_binomial_distribution<rep>;
+  using rep =   Q::rep;
+  using base =   std::negative_binomial_distribution<rep>;
 
   negative_binomial_distribution() : base() {}
   negative_binomial_distribution(const Q& k, double p) : base(k.numerical_value_ref_in(Q::unit), p) {}
@@ -185,8 +185,8 @@ struct negative_binomial_distribution : public std::negative_binomial_distributi
 template<Quantity Q>
   requires std::integral<typename Q::rep>
 struct geometric_distribution : public std::geometric_distribution<typename Q::rep> {
-  using rep = MP_UNITS_TYPENAME Q::rep;
-  using base = MP_UNITS_TYPENAME std::geometric_distribution<rep>;
+  using rep =   Q::rep;
+  using base =   std::geometric_distribution<rep>;
 
   geometric_distribution() : base() {}
   explicit geometric_distribution(double p) : base(p) {}
@@ -204,8 +204,8 @@ struct geometric_distribution : public std::geometric_distribution<typename Q::r
 template<Quantity Q>
   requires std::integral<typename Q::rep>
 struct poisson_distribution : public std::poisson_distribution<typename Q::rep> {
-  using rep = MP_UNITS_TYPENAME Q::rep;
-  using base = MP_UNITS_TYPENAME std::poisson_distribution<rep>;
+  using rep =   Q::rep;
+  using base =   std::poisson_distribution<rep>;
 
   poisson_distribution() : base() {}
   explicit poisson_distribution(double p) : base(p) {}
@@ -223,8 +223,8 @@ struct poisson_distribution : public std::poisson_distribution<typename Q::rep>
 template<Quantity Q>
   requires std::floating_point<typename Q::rep>
 struct exponential_distribution : public std::exponential_distribution<typename Q::rep> {
-  using rep = MP_UNITS_TYPENAME Q::rep;
-  using base = MP_UNITS_TYPENAME std::exponential_distribution<rep>;
+  using rep =   Q::rep;
+  using base =   std::exponential_distribution<rep>;
 
   exponential_distribution() : base() {}
   explicit exponential_distribution(const rep& lambda) : base(lambda) {}
@@ -242,8 +242,8 @@ struct exponential_distribution : public std::exponential_distribution<typename
 template<Quantity Q>
   requires std::floating_point<typename Q::rep>
 struct gamma_distribution : public std::gamma_distribution<typename Q::rep> {
-  using rep = MP_UNITS_TYPENAME Q::rep;
-  using base = MP_UNITS_TYPENAME std::gamma_distribution<rep>;
+  using rep =   Q::rep;
+  using base =   std::gamma_distribution<rep>;
 
   gamma_distribution() : base() {}
   gamma_distribution(const rep& alpha, const rep& beta) : base(alpha, beta) {}
@@ -261,8 +261,8 @@ struct gamma_distribution : public std::gamma_distribution<typename Q::rep> {
 template<Quantity Q>
   requires std::floating_point<typename Q::rep>
 struct weibull_distribution : public std::weibull_distribution<typename Q::rep> {
-  using rep = MP_UNITS_TYPENAME Q::rep;
-  using base = MP_UNITS_TYPENAME std::weibull_distribution<rep>;
+  using rep =   Q::rep;
+  using base =   std::weibull_distribution<rep>;
 
   weibull_distribution() : base() {}
   weibull_distribution(const rep& a, const rep& b) : base(a, b) {}
@@ -280,8 +280,8 @@ struct weibull_distribution : public std::weibull_distribution<typename Q::rep>
 template<Quantity Q>
   requires std::floating_point<typename Q::rep>
 struct extreme_value_distribution : public std::extreme_value_distribution<typename Q::rep> {
-  using rep = MP_UNITS_TYPENAME Q::rep;
-  using base = MP_UNITS_TYPENAME std::extreme_value_distribution<rep>;
+  using rep =   Q::rep;
+  using base =   std::extreme_value_distribution<rep>;
 
   extreme_value_distribution() : base() {}
   extreme_value_distribution(const Q& a, const rep& b) : base(a.numerical_value_ref_in(Q::unit), b) {}
@@ -301,8 +301,8 @@ struct extreme_value_distribution : public std::extreme_value_distribution<typen
 template<Quantity Q>
   requires std::floating_point<typename Q::rep>
 struct normal_distribution : public std::normal_distribution<typename Q::rep> {
-  using rep = MP_UNITS_TYPENAME Q::rep;
-  using base = MP_UNITS_TYPENAME std::normal_distribution<rep>;
+  using rep =   Q::rep;
+  using base =   std::normal_distribution<rep>;
 
   normal_distribution() : base() {}
   normal_distribution(const Q& mean, const Q& stddev) :
@@ -326,8 +326,8 @@ struct normal_distribution : public std::normal_distribution<typename Q::rep> {
 template<Quantity Q>
   requires std::floating_point<typename Q::rep>
 struct lognormal_distribution : public std::lognormal_distribution<typename Q::rep> {
-  using rep = MP_UNITS_TYPENAME Q::rep;
-  using base = MP_UNITS_TYPENAME std::lognormal_distribution<rep>;
+  using rep =   Q::rep;
+  using base =   std::lognormal_distribution<rep>;
 
   lognormal_distribution() : base() {}
   lognormal_distribution(const Q& m, const Q& s) :
@@ -351,8 +351,8 @@ struct lognormal_distribution : public std::lognormal_distribution<typename Q::r
 template<Quantity Q>
   requires std::floating_point<typename Q::rep>
 struct chi_squared_distribution : public std::chi_squared_distribution<typename Q::rep> {
-  using rep = MP_UNITS_TYPENAME Q::rep;
-  using base = MP_UNITS_TYPENAME std::chi_squared_distribution<rep>;
+  using rep =   Q::rep;
+  using base =   std::chi_squared_distribution<rep>;
 
   chi_squared_distribution() : base() {}
   explicit chi_squared_distribution(const rep& n) : base(n) {}
@@ -370,8 +370,8 @@ struct chi_squared_distribution : public std::chi_squared_distribution<typename
 template<Quantity Q>
   requires std::floating_point<typename Q::rep>
 struct cauchy_distribution : public std::cauchy_distribution<typename Q::rep> {
-  using rep = MP_UNITS_TYPENAME Q::rep;
-  using base = MP_UNITS_TYPENAME std::cauchy_distribution<rep>;
+  using rep =   Q::rep;
+  using base =   std::cauchy_distribution<rep>;
 
   cauchy_distribution() : base() {}
   cauchy_distribution(const Q& a, const Q& b) :
@@ -395,8 +395,8 @@ struct cauchy_distribution : public std::cauchy_distribution<typename Q::rep> {
 template<Quantity Q>
   requires std::floating_point<typename Q::rep>
 struct fisher_f_distribution : public std::fisher_f_distribution<typename Q::rep> {
-  using rep = MP_UNITS_TYPENAME Q::rep;
-  using base = MP_UNITS_TYPENAME std::fisher_f_distribution<rep>;
+  using rep =   Q::rep;
+  using base =   std::fisher_f_distribution<rep>;
 
   fisher_f_distribution() : base() {}
   fisher_f_distribution(const rep& m, const rep& n) : base(m, n) {}
@@ -414,8 +414,8 @@ struct fisher_f_distribution : public std::fisher_f_distribution<typename Q::rep
 template<Quantity Q>
   requires std::floating_point<typename Q::rep>
 struct student_t_distribution : public std::student_t_distribution<typename Q::rep> {
-  using rep = MP_UNITS_TYPENAME Q::rep;
-  using base = MP_UNITS_TYPENAME std::student_t_distribution<rep>;
+  using rep =   Q::rep;
+  using base =   std::student_t_distribution<rep>;
 
   student_t_distribution() : base() {}
   explicit student_t_distribution(const rep& n) : base(n) {}
@@ -433,8 +433,8 @@ struct student_t_distribution : public std::student_t_distribution<typename Q::r
 template<Quantity Q>
   requires std::integral<typename Q::rep>
 struct discrete_distribution : public std::discrete_distribution<typename Q::rep> {
-  using rep = MP_UNITS_TYPENAME Q::rep;
-  using base = MP_UNITS_TYPENAME std::discrete_distribution<rep>;
+  using rep =   Q::rep;
+  using base =   std::discrete_distribution<rep>;
 
   discrete_distribution() : base() {}
 
@@ -464,8 +464,8 @@ struct discrete_distribution : public std::discrete_distribution<typename Q::rep
 template<Quantity Q>
   requires std::floating_point<typename Q::rep>
 class piecewise_constant_distribution : public std::piecewise_constant_distribution<typename Q::rep> {
-  using rep = MP_UNITS_TYPENAME Q::rep;
-  using base = MP_UNITS_TYPENAME std::piecewise_constant_distribution<rep>;
+  using rep =   Q::rep;
+  using base =   std::piecewise_constant_distribution<rep>;
 
   template<typename InputIt>
   piecewise_constant_distribution(const std::vector<rep>& i, InputIt first_w) : base(i.cbegin(), i.cend(), first_w)
@@ -523,8 +523,8 @@ public:
 template<Quantity Q>
   requires std::floating_point<typename Q::rep>
 class piecewise_linear_distribution : public std::piecewise_linear_distribution<typename Q::rep> {
-  using rep = MP_UNITS_TYPENAME Q::rep;
-  using base = MP_UNITS_TYPENAME std::piecewise_linear_distribution<rep>;
+  using rep =   Q::rep;
+  using base =   std::piecewise_linear_distribution<rep>;
 
   template<typename InputIt>
   piecewise_linear_distribution(const std::vector<rep>& i, InputIt first_w) : base(i.cbegin(), i.cend(), first_w)
diff --git a/src/systems/include/mp-units/systems/si/chrono.h b/src/systems/include/mp-units/systems/si/chrono.h
index c018e8d1..5dfbb7fc 100644
--- a/src/systems/include/mp-units/systems/si/chrono.h
+++ b/src/systems/include/mp-units/systems/si/chrono.h
@@ -137,8 +137,8 @@ template<QuantityPointOf<MP_UNITS_IS_VALUE(isq::time)> QP>
   requires is_specialization_of<std::remove_const_t<decltype(QP::absolute_point_origin)>, chrono_point_origin_>
 [[nodiscard]] constexpr auto to_chrono_time_point(const QP& qp)
 {
-  using clock = MP_UNITS_TYPENAME decltype(QP::absolute_point_origin)::clock;
-  using rep = MP_UNITS_TYPENAME QP::rep;
+  using clock =   decltype(QP::absolute_point_origin)::clock;
+  using rep =   QP::rep;
   using ret_type =
     std::chrono::time_point<clock,
                             std::chrono::duration<rep, decltype(detail::as_ratio(get_canonical_unit(QP::unit).mag))>>;