From 2fddb494d31692fa4d515afb82509871b27e95c4 Mon Sep 17 00:00:00 2001
From: Mateusz Pusz <mateusz.pusz@gmail.com>
Date: Fri, 4 Oct 2019 16:22:49 +0200
Subject: [PATCH] `_t` postfix removed from the interface (resolves #9)

---
 doc/DESIGN.md                        |   8 +-
 src/include/units/dimension.h        | 173 ++++++++++++++-------------
 src/include/units/math.h             |   4 +-
 src/include/units/quantity.h         |  50 ++++----
 test/unit_test/test_custom_units.cpp |   4 +-
 test/unit_test/test_dimension.cpp    |  62 +++++-----
 test/unit_test/test_quantity.cpp     |   6 +-
 test/unit_test/test_type_list.cpp    |   8 +-
 8 files changed, 167 insertions(+), 148 deletions(-)

diff --git a/doc/DESIGN.md b/doc/DESIGN.md
index feb52651..6efcc799 100644
--- a/doc/DESIGN.md
+++ b/doc/DESIGN.md
@@ -221,7 +221,7 @@ struct dimension_multiply<dimension<E1...>, dimension<E2...>> {
 };
 
 template<Dimension D1, Dimension D2>
-using dimension_multiply_t = dimension_multiply<typename D1::base_type, typename D2::base_type>::type;
+using dimension_multiply = dimension_multiply<typename D1::base_type, typename D2::base_type>::type;
 ```
 
 
@@ -343,12 +343,12 @@ public:
   [[nodiscard]] static constexpr quantity one() noexcept { return quantity(quantity_values<Rep>::one()); }
 
   template<Unit U1, Scalar Rep1, Unit U2, Scalar Rep2>
-      requires std::same_as<typename U1::dimension, dim_invert_t<typename U2::dimension>>
+      requires std::same_as<typename U1::dimension, dim_invert<typename U2::dimension>>
   [[nodiscard]] constexpr Scalar operator*(const quantity<U1, Rep1>& lhs,
                                            const quantity<U2, Rep2>& rhs);
 
   template<Unit U1, Scalar Rep1, Unit U2, Scalar Rep2>
-      requires (!std::same_as<typename U1::dimension, dim_invert_t<typename U2::dimension>>) &&
+      requires (!std::same_as<typename U1::dimension, dim_invert<typename U2::dimension>>) &&
                (treat_as_floating_point<decltype(lhs.count() * rhs.count())> ||
                 (std::ratio_multiply<typename U1::ratio, typename U2::ratio>::den == 1))
   [[nodiscard]] constexpr Quantity operator*(const quantity<U1, Rep1>& lhs,
@@ -579,7 +579,7 @@ for a given specialization in a base type.
 For example to determine a downcasted type of a quantity multiply operation the following can be done:
 
 ```cpp
-using dim = dimension_multiply_t<typename U1::dimension, typename U2::dimension>;
+using dim = dimension_multiply<typename U1::dimension, typename U2::dimension>;
 using common_rep = decltype(lhs.count() * rhs.count());
 using ret = quantity<downcast_target<unit<dim, ratio_multiply<typename U1::ratio, typename U2::ratio>>>, common_rep>;
 ```
diff --git a/src/include/units/dimension.h b/src/include/units/dimension.h
index 55b9e286..3421028b 100644
--- a/src/include/units/dimension.h
+++ b/src/include/units/dimension.h
@@ -90,7 +90,6 @@ namespace units {
       detail::is_dimension<downcast_base_t<T>>;
 
   // exp
-
   template<typename Dim, int Num, int Den = 1>
     requires BaseDimension<Dim> || Dimension<Dim>
   struct exp {
@@ -108,68 +107,70 @@ namespace units {
   }  // namespace detail
 
   // exp_less
-
   template<Exponent E1, Exponent E2>
   struct exp_less : base_dimension_less<typename E1::dimension, typename E2::dimension> {
   };
 
   // exp_invert
+  namespace detail {
+
+    template<Exponent E>
+    struct exp_invert_impl;
+
+    template<typename Dim, int Num, int Den>
+    struct exp_invert_impl<exp<Dim, Num, Den>> {
+      using type = exp<Dim, -Num, Den>;
+    };
+
+  }
 
   template<Exponent E>
-  struct exp_invert;
-
-  template<typename Dim, int Num, int Den>
-  struct exp_invert<exp<Dim, Num, Den>> {
-    using type = exp<Dim, -Num, Den>;
-  };
-
-  template<Exponent E>
-  using exp_invert_t = exp_invert<E>::type;
+  using exp_invert = detail::exp_invert_impl<E>::type;
 
   // exp_multiply
+  namespace detail {
+
+    template<Exponent E, int Num, int Den>
+    struct exp_multiply_impl {
+      using r1 = ratio<E::num, E::den>;
+      using r2 = ratio<Num, Den>;
+      using r = ratio_multiply<r1, r2>;
+      using type = exp<typename E::dimension, r::num, r::den>;
+    };
+
+  }
 
   template<Exponent E, int Num, int Den>
-  struct exp_multiply {
-    using r1 = ratio<E::num, E::den>;
-    using r2 = ratio<Num, Den>;
-    using r = ratio_multiply<r1, r2>;
-    using type = exp<typename E::dimension, r::num, r::den>;
-  };
-
-  template<Exponent E, int Num, int Den>
-  using exp_multiply_t = exp_multiply<E, Num, Den>::type;
+  using exp_multiply = detail::exp_multiply_impl<E, Num, Den>::type;
 
   // dimension
-
   template<Exponent... Es>
   struct dimension : downcast_base<dimension<Es...>> {};
 
   // same_dim
-
   template<Dimension D1, Dimension D2>
   inline constexpr bool same_dim = std::is_same_v<typename D1::base_type, typename D2::base_type>;
 
   // dim_invert
+  namespace detail {
 
-  template<Dimension E>
-  struct dim_invert;
+    template<Dimension E>
+    struct dim_invert_impl;
 
-  template<typename... Es>
-  struct dim_invert<dimension<Es...>> : std::type_identity<downcast_target<dimension<exp_invert_t<Es>...>>> {};
+    template<typename... Es>
+    struct dim_invert_impl<dimension<Es...>> : std::type_identity<downcast_target<dimension<exp_invert<Es>...>>> {};
+
+  }
 
   template<Dimension D>
-  using dim_invert_t = dim_invert<downcast_base_t<D>>::type;
+  using dim_invert = detail::dim_invert_impl<downcast_base_t<D>>::type;
 
   // make_dimension
-
   namespace detail {
 
     template<Dimension D>
     struct dim_consolidate;
 
-    template<Dimension D>
-    using dim_consolidate_t = dim_consolidate<D>::type;
-
     template<>
     struct dim_consolidate<dimension<>> {
       using type = dimension<>;
@@ -182,7 +183,7 @@ namespace units {
 
     template<typename E1, typename... ERest>
     struct dim_consolidate<dimension<E1, ERest...>> {
-      using type = type_list_push_front<dim_consolidate_t<dimension<ERest...>>, E1>;
+      using type = type_list_push_front<typename dim_consolidate<dimension<ERest...>>::type, E1>;
     };
 
     template<BaseDimension D, int Num1, int Den1, int Num2, int Den2, typename... ERest>
@@ -191,16 +192,13 @@ namespace units {
       using r1 = std::ratio<Num1, Den1>;
       using r2 = std::ratio<Num2, Den2>;
       using r = std::ratio_add<r1, r2>;
-      using type = conditional<r::num == 0, dim_consolidate_t<dimension<ERest...>>,
-                               dim_consolidate_t<dimension<exp<D, r::num, r::den>, ERest...>>>;
+      using type = conditional<r::num == 0, typename dim_consolidate<dimension<ERest...>>::type,
+                               typename dim_consolidate<dimension<exp<D, r::num, r::den>, ERest...>>::type>;
     };
 
     template<Exponent... Es>
     struct extract;
 
-    template<Exponent... Es>
-    using extract_t = extract<Es...>::type;
-
     template<>
     struct extract<> {
       using type = dimension<>;
@@ -208,88 +206,99 @@ namespace units {
 
     template<BaseDimension Dim, int Num, int Den, Exponent... ERest>
     struct extract<exp<Dim, Num, Den>, ERest...> {
-      using type = type_list_push_front<extract_t<ERest...>, exp<Dim, Num, Den>>;
+      using type = type_list_push_front<typename extract<ERest...>::type, exp<Dim, Num, Den>>;
     };
 
     template<Exponent... Es, int Num, int Den, Exponent... ERest>
     struct extract<exp<dimension<Es...>, Num, Den>, ERest...> {
-      using type = type_list_push_front<extract_t<ERest...>, exp_multiply_t<Es, Num, Den>...>;
+      using type = type_list_push_front<typename extract<ERest...>::type, exp_multiply<Es, Num, Den>...>;
     };
 
     template<Dimension Dim, int Num, int Den, Exponent... ERest>
     struct extract<exp<Dim, Num, Den>, ERest...> {
-      using type = extract_t<exp<downcast_base_t<Dim>, Num, Den>, ERest...>;
+      using type = extract<exp<downcast_base_t<Dim>, Num, Den>, ERest...>::type;
     };
 
     template<Exponent... Es>
     struct make_dimension {
-      using type = detail::dim_consolidate_t<type_list_sort<detail::extract_t<Es...>, exp_less>>;
+      using type = detail::dim_consolidate<type_list_sort<typename detail::extract<Es...>::type, exp_less>>::type;
     };
 
-    template<Exponent... Es>
-    using make_dimension_t = make_dimension<Es...>::type;
-
   }  // namespace detail
 
   // derived_dimension
-
   template<typename Child, Exponent... Es>
-  struct derived_dimension : downcast_helper<Child, detail::make_dimension_t<Es...>> {};
+  struct derived_dimension : downcast_helper<Child, typename detail::make_dimension<Es...>::type> {};
 
   // merge_dimension
+  namespace detail {
+
+    template<Dimension D1, Dimension D2>
+    struct merge_dimension_impl {
+      using type = detail::dim_consolidate<type_list_merge_sorted<D1, D2, exp_less>>::type;
+    };
+
+  }
 
   template<Dimension D1, Dimension D2>
-  struct merge_dimension {
-    using type = detail::dim_consolidate_t<type_list_merge_sorted<D1, D2, exp_less>>;
-  };
-
-  template<Dimension D1, Dimension D2>
-  using merge_dimension_t = merge_dimension<D1, D2>::type;
+  using merge_dimension = detail::merge_dimension_impl<D1, D2>::type;
 
   // dimension_multiply
+  namespace detail {
+
+    template<Dimension D1, Dimension D2>
+    struct dimension_multiply_impl;
+
+    template<typename... E1, typename... E2>
+    struct dimension_multiply_impl<dimension<E1...>, dimension<E2...>> : std::type_identity<downcast_target<merge_dimension<dimension<E1...>, dimension<E2...>>>> {};
+
+  }
 
   template<Dimension D1, Dimension D2>
-  struct dimension_multiply;
-
-  template<typename... E1, typename... E2>
-  struct dimension_multiply<dimension<E1...>, dimension<E2...>> : std::type_identity<downcast_target<merge_dimension_t<dimension<E1...>, dimension<E2...>>>> {};
-
-  template<Dimension D1, Dimension D2>
-  using dimension_multiply_t = dimension_multiply<typename D1::base_type, typename D2::base_type>::type;
+  using dimension_multiply = detail::dimension_multiply_impl<typename D1::base_type, typename D2::base_type>::type;
 
   // dimension_divide
+  namespace detail {
+
+    template<Dimension D1, Dimension D2>
+    struct dimension_divide_impl;
+
+    template<typename... E1, typename... E2>
+    struct dimension_divide_impl<dimension<E1...>, dimension<E2...>>
+        : dimension_multiply_impl<dimension<E1...>, dimension<exp_invert<E2>...>> {
+    };
+
+  }
 
   template<Dimension D1, Dimension D2>
-  struct dimension_divide;
-
-  template<typename... E1, typename... E2>
-  struct dimension_divide<dimension<E1...>, dimension<E2...>>
-      : dimension_multiply<dimension<E1...>, dimension<exp_invert_t<E2>...>> {
-  };
-
-  template<Dimension D1, Dimension D2>
-  using dimension_divide_t = dimension_divide<typename D1::base_type, typename D2::base_type>::type;
+  using dimension_divide = detail::dimension_divide_impl<typename D1::base_type, typename D2::base_type>::type;
 
   // dimension_sqrt
+  namespace detail {
+
+    template<Dimension D>
+    struct dimension_sqrt_impl;
+
+    template<typename... Es>
+    struct dimension_sqrt_impl<dimension<Es...>> : std::type_identity<downcast_target<dimension<exp_multiply<Es, 1, 2>...>>> {};
+  
+  }
 
   template<Dimension D>
-  struct dimension_sqrt;
-
-  template<typename... Es>
-  struct dimension_sqrt<dimension<Es...>> : std::type_identity<downcast_target<dimension<exp_multiply_t<Es, 1, 2>...>>> {};
-
-  template<Dimension D>
-  using dimension_sqrt_t = dimension_sqrt<typename D::base_type>::type;
+  using dimension_sqrt = detail::dimension_sqrt_impl<typename D::base_type>::type;
 
   // dimension_pow
+  namespace detail {
+
+    template<Dimension D, std::size_t N>
+    struct dimension_pow_impl;
+
+    template<typename... Es, std::size_t N>
+    struct dimension_pow_impl<dimension<Es...>, N> : std::type_identity<downcast_target<dimension<exp_multiply<Es, N, 1>...>>> {};
+
+  }
 
   template<Dimension D, std::size_t N>
-  struct dimension_pow;
-
-  template<typename... Es, std::size_t N>
-  struct dimension_pow<dimension<Es...>, N> : std::type_identity<downcast_target<dimension<exp_multiply_t<Es, N, 1>...>>> {};
-
-  template<Dimension D, std::size_t N>
-  using dimension_pow_t = dimension_pow<typename D::base_type, N>::type;
+  using dimension_pow = detail::dimension_pow_impl<typename D::base_type, N>::type;
 
 }  // namespace units
diff --git a/src/include/units/math.h b/src/include/units/math.h
index d13aa4c5..46628653 100644
--- a/src/include/units/math.h
+++ b/src/include/units/math.h
@@ -30,7 +30,7 @@ namespace units {
   template<std::size_t N, typename U, typename Rep>
   inline Quantity pow(const quantity<U, Rep>& q) noexcept
   {
-    using dim = dimension_pow_t<typename U::dimension, N>;
+    using dim = dimension_pow<typename U::dimension, N>;
     using r = ratio_pow<typename U::ratio, N>;
     return quantity<downcast_target<unit<dim, r>>, Rep>(static_cast<Rep>(std::pow(q.count(), N)));
   }
@@ -38,7 +38,7 @@ namespace units {
   template<typename U, typename Rep>
   inline Quantity sqrt(const quantity<U, Rep>& q) noexcept
   {
-    using dim = dimension_sqrt_t<typename U::dimension>;
+    using dim = dimension_sqrt<typename U::dimension>;
     using r = ratio_sqrt<typename U::ratio>;
     return quantity<downcast_target<unit<dim, r>>, Rep>(static_cast<Rep>(std::sqrt(q.count())));
   }
diff --git a/src/include/units/quantity.h b/src/include/units/quantity.h
index 4819bae9..13f7665c 100644
--- a/src/include/units/quantity.h
+++ b/src/include/units/quantity.h
@@ -60,22 +60,26 @@ namespace units {
   }  // namespace detail
 
   // common_quantity
-  template<Quantity Q1, Quantity Q2, Scalar Rep>
-  struct common_quantity;
+  namespace detail {
 
-  template<typename U, typename Rep1, typename Rep2, typename Rep>
-  struct common_quantity<quantity<U, Rep1>, quantity<U, Rep2>, Rep> {
-    using type = quantity<U, Rep>;
-  };
+    template<Quantity Q1, Quantity Q2, Scalar Rep>
+    struct common_quantity_impl;
 
-  template<typename U1, typename Rep1, typename U2, typename Rep2, typename Rep>
-    requires same_dim<typename U1::dimension, typename U2::dimension>
-  struct common_quantity<quantity<U1, Rep1>, quantity<U2, Rep2>, Rep> {
-    using type = quantity<downcast_target<unit<typename U1::dimension, common_ratio<typename U1::ratio, typename U2::ratio>>>, Rep>;
-  };
+    template<typename U, typename Rep1, typename Rep2, typename Rep>
+    struct common_quantity_impl<quantity<U, Rep1>, quantity<U, Rep2>, Rep> {
+      using type = quantity<U, Rep>;
+    };
+
+    template<typename U1, typename Rep1, typename U2, typename Rep2, typename Rep>
+      requires same_dim<typename U1::dimension, typename U2::dimension>
+    struct common_quantity_impl<quantity<U1, Rep1>, quantity<U2, Rep2>, Rep> {
+      using type = quantity<downcast_target<unit<typename U1::dimension, common_ratio<typename U1::ratio, typename U2::ratio>>>, Rep>;
+    };
+
+  }
 
   template<Quantity Q1, Quantity Q2, Scalar Rep = std::common_type_t<typename Q1::rep, typename Q2::rep>>
-  using common_quantity_t = common_quantity<Q1, Q2, Rep>::type;
+  using common_quantity = detail::common_quantity_impl<Q1, Q2, Rep>::type;
 
   // treat_as_floating_point
 
@@ -280,7 +284,7 @@ namespace units {
     requires same_dim<typename U1::dimension, typename U2::dimension>
   {
     using common_rep = decltype(lhs.count() + rhs.count());
-    using ret = common_quantity_t<quantity<U1, Rep1>, quantity<U2, Rep2>, common_rep>;
+    using ret = common_quantity<quantity<U1, Rep1>, quantity<U2, Rep2>, common_rep>;
     return ret(ret(lhs).count() + ret(rhs).count());
   }
 
@@ -290,7 +294,7 @@ namespace units {
     requires same_dim<typename U1::dimension, typename U2::dimension>
   {
     using common_rep = decltype(lhs.count() - rhs.count());
-    using ret = common_quantity_t<quantity<U1, Rep1>, quantity<U2, Rep2>, common_rep>;
+    using ret = common_quantity<quantity<U1, Rep1>, quantity<U2, Rep2>, common_rep>;
     return ret(ret(lhs).count() - ret(rhs).count());
   }
 
@@ -317,7 +321,7 @@ namespace units {
   template<typename U1, typename Rep1, typename U2, typename Rep2>
   [[nodiscard]] constexpr Scalar operator*(const quantity<U1, Rep1>& lhs,
                                            const quantity<U2, Rep2>& rhs)
-      requires same_dim<typename U1::dimension, dim_invert_t<typename U2::dimension>>
+      requires same_dim<typename U1::dimension, dim_invert<typename U2::dimension>>
   {
     using common_rep = decltype(lhs.count() * rhs.count());
     using ratio = ratio_multiply<typename U1::ratio, typename U2::ratio>;
@@ -327,11 +331,11 @@ namespace units {
   template<typename U1, typename Rep1, typename U2, typename Rep2>
   [[nodiscard]] constexpr Quantity operator*(const quantity<U1, Rep1>& lhs,
                                              const quantity<U2, Rep2>& rhs)
-      requires (!same_dim<typename U1::dimension, dim_invert_t<typename U2::dimension>>) &&
+      requires (!same_dim<typename U1::dimension, dim_invert<typename U2::dimension>>) &&
                (treat_as_floating_point<decltype(lhs.count() * rhs.count())> ||
                 (std::ratio_multiply<typename U1::ratio, typename U2::ratio>::den == 1))
   {
-    using dim = dimension_multiply_t<typename U1::dimension, typename U2::dimension>;
+    using dim = dimension_multiply<typename U1::dimension, typename U2::dimension>;
     using common_rep = decltype(lhs.count() * rhs.count());
     using ret = quantity<downcast_target<unit<dim, ratio_multiply<typename U1::ratio, typename U2::ratio>>>, common_rep>;
     return ret(lhs.count() * rhs.count());
@@ -345,7 +349,7 @@ namespace units {
   {
     Expects(q != std::remove_cvref_t<decltype(q)>(0));
 
-    using dim = dim_invert_t<typename U::dimension>;
+    using dim = dim_invert<typename U::dimension>;
     using common_rep = decltype(v / q.count());
     using ret = quantity<downcast_target<unit<dim, ratio<U::ratio::den, U::ratio::num>>>, common_rep>;
     using den = quantity<U, common_rep>;
@@ -373,7 +377,7 @@ namespace units {
     Expects(rhs != std::remove_cvref_t<decltype(rhs)>(0));
 
     using common_rep = decltype(lhs.count() / rhs.count());
-    using cq = common_quantity_t<quantity<U1, Rep1>, quantity<U2, Rep2>, common_rep>;
+    using cq = common_quantity<quantity<U1, Rep1>, quantity<U2, Rep2>, common_rep>;
     return cq(lhs).count() / cq(rhs).count();
   }
 
@@ -387,7 +391,7 @@ namespace units {
     Expects(rhs != std::remove_cvref_t<decltype(rhs)>(0));
 
     using common_rep = decltype(lhs.count() / rhs.count());
-    using dim = dimension_divide_t<typename U1::dimension, typename U2::dimension>;
+    using dim = dimension_divide<typename U1::dimension, typename U2::dimension>;
     using ret = quantity<downcast_target<unit<dim, ratio_divide<typename U1::ratio, typename U2::ratio>>>, common_rep>;
     return ret(lhs.count() / rhs.count());
   }
@@ -406,7 +410,7 @@ namespace units {
                                              const quantity<U2, Rep2>& rhs)
   {
     using common_rep = decltype(lhs.count() % rhs.count());
-    using ret = common_quantity_t<quantity<U1, Rep1>, quantity<U2, Rep2>, common_rep>;
+    using ret = common_quantity<quantity<U1, Rep1>, quantity<U2, Rep2>, common_rep>;
     return ret(ret(lhs).count() % ret(rhs).count());
   }
 
@@ -416,7 +420,7 @@ namespace units {
   [[nodiscard]] constexpr bool operator==(const quantity<U1, Rep1>& lhs, const quantity<U2, Rep2>& rhs)
     requires same_dim<typename U1::dimension, typename U2::dimension>
   {
-    using ct = common_quantity_t<quantity<U1, Rep1>, quantity<U2, Rep2>>;
+    using ct = common_quantity<quantity<U1, Rep1>, quantity<U2, Rep2>>;
     return ct(lhs).count() == ct(rhs).count();
   }
 
@@ -431,7 +435,7 @@ namespace units {
   [[nodiscard]] constexpr bool operator<(const quantity<U1, Rep1>& lhs, const quantity<U2, Rep2>& rhs)
     requires same_dim<typename U1::dimension, typename U2::dimension>
   {
-    using ct = common_quantity_t<quantity<U1, Rep1>, quantity<U2, Rep2>>;
+    using ct = common_quantity<quantity<U1, Rep1>, quantity<U2, Rep2>>;
     return ct(lhs).count() < ct(rhs).count();
   }
 
diff --git a/test/unit_test/test_custom_units.cpp b/test/unit_test/test_custom_units.cpp
index 000a04e3..f2ac51fd 100644
--- a/test/unit_test/test_custom_units.cpp
+++ b/test/unit_test/test_custom_units.cpp
@@ -72,8 +72,8 @@ namespace {
 
 namespace {
 
-  static_assert(std::is_same_v<dimension_sqrt_t<power_spectral_density>, amplitude_spectral_density>);
-  static_assert(std::is_same_v<dimension_pow_t<amplitude_spectral_density, 2>, power_spectral_density>);
+  static_assert(std::is_same_v<dimension_sqrt<power_spectral_density>, amplitude_spectral_density>);
+  static_assert(std::is_same_v<dimension_pow<amplitude_spectral_density, 2>, power_spectral_density>);
 
   static_assert(std::is_same_v<decltype(pow<2>(quantity<volt_per_sqrt_hertz>(4))), decltype(quantity<sq_volt_per_hertz>(16))>);
   static_assert(std::is_same_v<decltype(sqrt(quantity<sq_volt_per_hertz>(16))), decltype(quantity<volt_per_sqrt_hertz>(4))>);
diff --git a/test/unit_test/test_dimension.cpp b/test/unit_test/test_dimension.cpp
index c117d5a9..78d92dba 100644
--- a/test/unit_test/test_dimension.cpp
+++ b/test/unit_test/test_dimension.cpp
@@ -34,59 +34,65 @@ namespace {
 
   // exp_invert
 
-  static_assert(std::is_same_v<exp_invert_t<exp<d0, 1>>, exp<d0, -1>>);
-  static_assert(std::is_same_v<exp_invert_t<exp<d1, -1>>, exp<d1, 1>>);
+  static_assert(std::is_same_v<exp_invert<exp<d0, 1>>, exp<d0, -1>>);
+  static_assert(std::is_same_v<exp_invert<exp<d1, -1>>, exp<d1, 1>>);
 
   // extract
 
   template<typename T>
   struct typeinfo;
 
-  static_assert(std::is_same_v<detail::extract_t<>, dimension<>>);
-  static_assert(std::is_same_v<detail::extract_t<exp<d0, 1>>, dimension<exp<d0, 1>>>);
-  static_assert(std::is_same_v<detail::extract_t<exp<d0, 1>, exp<d1, 2>>, dimension<exp<d0, 1>, exp<d1, 2>>>);
+  template<typename... Ts>
+  using extract = detail::extract<Ts...>::type;
+
+  static_assert(std::is_same_v<extract<>, dimension<>>);
+  static_assert(std::is_same_v<extract<exp<d0, 1>>, dimension<exp<d0, 1>>>);
+  static_assert(std::is_same_v<extract<exp<d0, 1>, exp<d1, 2>>, dimension<exp<d0, 1>, exp<d1, 2>>>);
   using dim0 = dimension<>;
   using dim1 = dimension<exp<d0, 1>>;
   using dim2 = dimension<exp<d0, 1>, exp<d1, 2>>;
-  static_assert(std::is_same_v<detail::extract_t<exp<dim0, 2>, exp<d0, 1>>, dimension<exp<d0, 1>>>);
-  static_assert(std::is_same_v<detail::extract_t<exp<dim1, 2>, exp<d0, 1>>, dimension<exp<d0, 2>, exp<d0, 1>>>);
-  static_assert(std::is_same_v<detail::extract_t<exp<dim2, -2>, exp<d0, 1>, exp<d1, 2>>, dimension<exp<d0, -2>, exp<d1, -4>, exp<d0, 1>, exp<d1, 2>>>);
+  static_assert(std::is_same_v<extract<exp<dim0, 2>, exp<d0, 1>>, dimension<exp<d0, 1>>>);
+  static_assert(std::is_same_v<extract<exp<dim1, 2>, exp<d0, 1>>, dimension<exp<d0, 2>, exp<d0, 1>>>);
+  static_assert(std::is_same_v<extract<exp<dim2, -2>, exp<d0, 1>, exp<d1, 2>>, dimension<exp<d0, -2>, exp<d1, -4>, exp<d0, 1>, exp<d1, 2>>>);
 
   // make_dimension
 
-  static_assert(std::is_same_v<detail::make_dimension_t<exp<d0, 1>>, dimension<exp<d0, 1>>>);
-  static_assert(std::is_same_v<detail::make_dimension_t<exp<d0, 1>, exp<d1, 1>>, dimension<exp<d0, 1>, exp<d1, 1>>>);
-  static_assert(std::is_same_v<detail::make_dimension_t<exp<d1, 1>, exp<d0, 1>>, dimension<exp<d0, 1>, exp<d1, 1>>>);
-  static_assert(std::is_same_v<detail::make_dimension_t<exp<d1, 1>, exp<d1, 1>>, dimension<exp<d1, 2>>>);
-  static_assert(std::is_same_v<detail::make_dimension_t<exp<d1, 1>, exp<d1, -1>>, dimension<>>);
-  static_assert(std::is_same_v<detail::make_dimension_t<exp<d1, 1>, exp<d1, 1, 2>>, dimension<exp<d1, 3, 2>>>);
-  static_assert(std::is_same_v<detail::make_dimension_t<exp<d1, 1, 2>, exp<d1, 1, 2>>, dimension<exp<d1, 1>>>);
-  static_assert(std::is_same_v<detail::make_dimension_t<exp<d1, 2>, exp<d1, 1, 2>>, dimension<exp<d1, 5, 2>>>);
+  template<typename... Ts>
+  using make_dimension = detail::make_dimension<Ts...>::type;
 
-  static_assert(std::is_same_v<detail::make_dimension_t<exp<d0, 1>, exp<d1, 1>, exp<d0, 1>, exp<d1, 1>>, dimension<exp<d0, 2>, exp<d1, 2>>>);
+  static_assert(std::is_same_v<make_dimension<exp<d0, 1>>, dimension<exp<d0, 1>>>);
+  static_assert(std::is_same_v<make_dimension<exp<d0, 1>, exp<d1, 1>>, dimension<exp<d0, 1>, exp<d1, 1>>>);
+  static_assert(std::is_same_v<make_dimension<exp<d1, 1>, exp<d0, 1>>, dimension<exp<d0, 1>, exp<d1, 1>>>);
+  static_assert(std::is_same_v<make_dimension<exp<d1, 1>, exp<d1, 1>>, dimension<exp<d1, 2>>>);
+  static_assert(std::is_same_v<make_dimension<exp<d1, 1>, exp<d1, -1>>, dimension<>>);
+  static_assert(std::is_same_v<make_dimension<exp<d1, 1>, exp<d1, 1, 2>>, dimension<exp<d1, 3, 2>>>);
+  static_assert(std::is_same_v<make_dimension<exp<d1, 1, 2>, exp<d1, 1, 2>>, dimension<exp<d1, 1>>>);
+  static_assert(std::is_same_v<make_dimension<exp<d1, 2>, exp<d1, 1, 2>>, dimension<exp<d1, 5, 2>>>);
+
+  static_assert(std::is_same_v<make_dimension<exp<d0, 1>, exp<d1, 1>, exp<d0, 1>, exp<d1, 1>>, dimension<exp<d0, 2>, exp<d1, 2>>>);
   static_assert(
-      std::is_same_v<detail::make_dimension_t<exp<d0, -1>, exp<d1, -1>, exp<d0, -1>, exp<d1, -1>>, dimension<exp<d0, -2>, exp<d1, -2>>>);
+      std::is_same_v<make_dimension<exp<d0, -1>, exp<d1, -1>, exp<d0, -1>, exp<d1, -1>>, dimension<exp<d0, -2>, exp<d1, -2>>>);
 
-  static_assert(std::is_same_v<detail::make_dimension_t<exp<d0, 1>, exp<d1, 1>, exp<d1, -1>>, dimension<exp<d0, 1>>>);
-  static_assert(std::is_same_v<detail::make_dimension_t<exp<d0, 1>, exp<d0, -1>, exp<d1, 1>>, dimension<exp<d1, 1>>>);
-  static_assert(std::is_same_v<detail::make_dimension_t<exp<d0, 1>, exp<d1, 1>, exp<d0, -1>>, dimension<exp<d1, 1>>>);
-  static_assert(std::is_same_v<detail::make_dimension_t<exp<d0, 1>, exp<d1, 1>, exp<d0, -1>, exp<d1, -1>>, dimension<>>);
+  static_assert(std::is_same_v<make_dimension<exp<d0, 1>, exp<d1, 1>, exp<d1, -1>>, dimension<exp<d0, 1>>>);
+  static_assert(std::is_same_v<make_dimension<exp<d0, 1>, exp<d0, -1>, exp<d1, 1>>, dimension<exp<d1, 1>>>);
+  static_assert(std::is_same_v<make_dimension<exp<d0, 1>, exp<d1, 1>, exp<d0, -1>>, dimension<exp<d1, 1>>>);
+  static_assert(std::is_same_v<make_dimension<exp<d0, 1>, exp<d1, 1>, exp<d0, -1>, exp<d1, -1>>, dimension<>>);
 
   // dimension_multiply
 
   static_assert(
-      std::is_same_v<dimension_multiply_t<dimension<exp<d0, 1>>, dimension<exp<d1, 1>>>, dimension<exp<d0, 1>, exp<d1, 1>>>);
-  static_assert(std::is_same_v<dimension_multiply_t<dimension<exp<d0, 1>, exp<d1, 1>, exp<d2, 1>>, dimension<exp<d3, 1>>>,
+      std::is_same_v<dimension_multiply<dimension<exp<d0, 1>>, dimension<exp<d1, 1>>>, dimension<exp<d0, 1>, exp<d1, 1>>>);
+  static_assert(std::is_same_v<dimension_multiply<dimension<exp<d0, 1>, exp<d1, 1>, exp<d2, 1>>, dimension<exp<d3, 1>>>,
                                dimension<exp<d0, 1>, exp<d1, 1>, exp<d2, 1>, exp<d3, 1>>>);
-  static_assert(std::is_same_v<dimension_multiply_t<dimension<exp<d0, 1>, exp<d1, 1>, exp<d2, 1>>, dimension<exp<d1, 1>>>,
+  static_assert(std::is_same_v<dimension_multiply<dimension<exp<d0, 1>, exp<d1, 1>, exp<d2, 1>>, dimension<exp<d1, 1>>>,
                                dimension<exp<d0, 1>, exp<d1, 2>, exp<d2, 1>>>);
-  static_assert(std::is_same_v<dimension_multiply_t<dimension<exp<d0, 1>, exp<d1, 1>, exp<d2, 1>>, dimension<exp<d1, -1>>>,
+  static_assert(std::is_same_v<dimension_multiply<dimension<exp<d0, 1>, exp<d1, 1>, exp<d2, 1>>, dimension<exp<d1, -1>>>,
                                dimension<exp<d0, 1>, exp<d2, 1>>>);
 
   // dimension_divide
 
   static_assert(
-      std::is_same_v<dimension_divide_t<dimension<exp<d0, 1>>, dimension<exp<d1, 1>>>, dimension<exp<d0, 1>, exp<d1, -1>>>);
-  static_assert(std::is_same_v<dimension_divide_t<dimension<exp<d0, 1>>, dimension<exp<d0, 1>>>, dimension<>>);
+      std::is_same_v<dimension_divide<dimension<exp<d0, 1>>, dimension<exp<d1, 1>>>, dimension<exp<d0, 1>, exp<d1, -1>>>);
+  static_assert(std::is_same_v<dimension_divide<dimension<exp<d0, 1>>, dimension<exp<d0, 1>>>, dimension<>>);
 
 }  // namespace
diff --git a/test/unit_test/test_quantity.cpp b/test/unit_test/test_quantity.cpp
index 8d580c80..2e789793 100644
--- a/test/unit_test/test_quantity.cpp
+++ b/test/unit_test/test_quantity.cpp
@@ -263,9 +263,9 @@ namespace {
 
   // common_quantity
 
-  static_assert(std::is_same_v<common_quantity_t<quantity<metre, int>, quantity<kilometre, int>>, quantity<metre, int>>);
-  static_assert(std::is_same_v<common_quantity_t<quantity<kilometre, long long>, quantity<metre, int>>, quantity<metre, long long>>);
-  static_assert(std::is_same_v<common_quantity_t<quantity<kilometre, long long>, quantity<millimetre, double>>, quantity<millimetre, double>>);
+  static_assert(std::is_same_v<common_quantity<quantity<metre, int>, quantity<kilometre, int>>, quantity<metre, int>>);
+  static_assert(std::is_same_v<common_quantity<quantity<kilometre, long long>, quantity<metre, int>>, quantity<metre, long long>>);
+  static_assert(std::is_same_v<common_quantity<quantity<kilometre, long long>, quantity<millimetre, double>>, quantity<millimetre, double>>);
 
   // quantity_cast
 
diff --git a/test/unit_test/test_type_list.cpp b/test/unit_test/test_type_list.cpp
index dd89b836..e47df4e6 100644
--- a/test/unit_test/test_type_list.cpp
+++ b/test/unit_test/test_type_list.cpp
@@ -93,10 +93,10 @@ namespace {
   // type_list_sort
 
   template<TypeList List>
-  using exp_sort_t = type_list_sort<List, exp_less>;
+  using exp_sort = type_list_sort<List, exp_less>;
 
-  static_assert(std::is_same_v<exp_sort_t<dimension<exp<d0, 1>>>, dimension<exp<d0, 1>>>);
-  static_assert(std::is_same_v<exp_sort_t<dimension<exp<d0, 1>, exp<d1, -1>>>, dimension<exp<d0, 1>, exp<d1, -1>>>);
-  static_assert(std::is_same_v<exp_sort_t<dimension<exp<d1, 1>, exp<d0, -1>>>, dimension<exp<d0, -1>, exp<d1, 1>>>);
+  static_assert(std::is_same_v<exp_sort<dimension<exp<d0, 1>>>, dimension<exp<d0, 1>>>);
+  static_assert(std::is_same_v<exp_sort<dimension<exp<d0, 1>, exp<d1, -1>>>, dimension<exp<d0, 1>, exp<d1, -1>>>);
+  static_assert(std::is_same_v<exp_sort<dimension<exp<d1, 1>, exp<d0, -1>>>, dimension<exp<d0, -1>, exp<d1, 1>>>);
 
 }  // namespace