From b55156bed4a56b2e9af46e0d17adc092ac16342e Mon Sep 17 00:00:00 2001
From: Felix Morgner <felix.morgner@gmail.com>
Date: Thu, 8 Jun 2023 17:55:22 +0200
Subject: concepts: replace relational traits

---
 source/lib/include/newtype/concepts.hpp            |  60 +++++++
 .../newtype/impl/type_traits_extensions.hpp        | 113 ------------
 source/lib/include/newtype/newtype.hpp             |  20 +--
 source/tests/src/relational_operators.cpp          | 198 ++++++++-------------
 4 files changed, 141 insertions(+), 250 deletions(-)

diff --git a/source/lib/include/newtype/concepts.hpp b/source/lib/include/newtype/concepts.hpp
index 8f94a42..a50b2b3 100644
--- a/source/lib/include/newtype/concepts.hpp
+++ b/source/lib/include/newtype/concepts.hpp
@@ -42,6 +42,66 @@ namespace nt::concepts
       } noexcept;
     };
 
+    template<typename SubjectType>
+    concept less_than_comparable = requires(SubjectType lhs, SubjectType rhs) {
+      {
+        lhs < rhs
+      } -> std::convertible_to<bool>;
+    };
+
+    template<typename SubjectType>
+    concept nothrow_less_than_comparable = requires(SubjectType lhs, SubjectType rhs) {
+      requires less_than_comparable<SubjectType>;
+      {
+        lhs < rhs
+      } noexcept;
+    };
+
+    template<typename SubjectType>
+    concept less_than_equal_comparable = requires(SubjectType lhs, SubjectType rhs) {
+      {
+        lhs <= rhs
+      } -> std::convertible_to<bool>;
+    };
+
+    template<typename SubjectType>
+    concept nothrow_less_than_equal_comparable = requires(SubjectType lhs, SubjectType rhs) {
+      requires less_than_equal_comparable<SubjectType>;
+      {
+        lhs <= rhs
+      } noexcept;
+    };
+
+    template<typename SubjectType>
+    concept greater_than_comparable = requires(SubjectType lhs, SubjectType rhs) {
+      {
+        lhs > rhs
+      } -> std::convertible_to<bool>;
+    };
+
+    template<typename SubjectType>
+    concept nothrow_greater_than_comparable = requires(SubjectType lhs, SubjectType rhs) {
+      requires greater_than_comparable<SubjectType>;
+      {
+        lhs > rhs
+      } noexcept;
+    };
+
+    template<typename SubjectType>
+    concept greater_than_equal_comparable = requires(SubjectType lhs, SubjectType rhs) {
+      {
+        lhs >= rhs
+      } -> std::convertible_to<bool>;
+    };
+
+    template<typename SubjectType>
+    concept nothrow_greater_than_equal_comparable = requires(SubjectType lhs, SubjectType rhs) {
+      requires greater_than_equal_comparable<SubjectType>;
+      {
+        lhs >= rhs
+      } noexcept;
+    };
+
   }  // namespace comparability
 
   inline namespace iostreamable
diff --git a/source/lib/include/newtype/impl/type_traits_extensions.hpp b/source/lib/include/newtype/impl/type_traits_extensions.hpp
index 22834f2..c2caf51 100644
--- a/source/lib/include/newtype/impl/type_traits_extensions.hpp
+++ b/source/lib/include/newtype/impl/type_traits_extensions.hpp
@@ -11,119 +11,6 @@
 namespace nt::impl
 {
 
-  inline namespace relationally_comparable
-  {
-
-    template<typename T, typename = void>
-    struct is_less_than_comparable : std::false_type
-    {
-    };
-
-    template<typename T>
-    struct is_less_than_comparable<T, std::void_t<decltype(std::declval<T const &>() < std::declval<T const &>())>> : std::true_type
-    {
-    };
-
-    template<typename T>
-    auto constexpr is_less_than_comparable_v = is_less_than_comparable<T>::value;
-
-    template<typename T, typename = void>
-    struct is_nothrow_less_than_comparable : std::false_type
-    {
-    };
-
-    template<typename T>
-    struct is_nothrow_less_than_comparable<T, std::void_t<decltype(std::declval<T const &>() < std::declval<T const &>())>>
-        : std::bool_constant<noexcept(std::declval<T const &>() < std::declval<T const &>())>
-    {
-    };
-
-    template<typename T>
-    auto constexpr is_nothrow_less_than_comparable_v = is_nothrow_less_than_comparable<T>::value;
-
-    template<typename T, typename = void>
-    struct is_greater_than_comparable : std::false_type
-    {
-    };
-
-    template<typename T>
-    struct is_greater_than_comparable<T, std::void_t<decltype(std::declval<T const &>() > std::declval<T const &>())>> : std::true_type
-    {
-    };
-
-    template<typename T>
-    auto constexpr is_greater_than_comparable_v = is_greater_than_comparable<T>::value;
-
-    template<typename T, typename = void>
-    struct is_nothrow_greater_than_comparable : std::false_type
-    {
-    };
-
-    template<typename T>
-    struct is_nothrow_greater_than_comparable<T, std::void_t<decltype(std::declval<T const &>() > std::declval<T const &>())>>
-        : std::bool_constant<noexcept(std::declval<T const &>() > std::declval<T const &>())>
-    {
-    };
-
-    template<typename T>
-    auto constexpr is_nothrow_greater_than_comparable_v = is_nothrow_greater_than_comparable<T>::value;
-
-    template<typename T, typename = void>
-    struct is_less_than_equal_to_comparable : std::false_type
-    {
-    };
-
-    template<typename T>
-    struct is_less_than_equal_to_comparable<T, std::void_t<decltype(std::declval<T const &>() <= std::declval<T const &>())>> : std::true_type
-    {
-    };
-
-    template<typename T>
-    auto constexpr is_less_than_equal_to_comparable_v = is_less_than_equal_to_comparable<T>::value;
-
-    template<typename T, typename = void>
-    struct is_nothrow_less_than_equal_to_comparable : std::false_type
-    {
-    };
-
-    template<typename T>
-    struct is_nothrow_less_than_equal_to_comparable<T, std::void_t<decltype(std::declval<T const &>() <= std::declval<T const &>())>>
-        : std::bool_constant<noexcept(std::declval<T const &>() <= std::declval<T const &>())>
-    {
-    };
-
-    template<typename T>
-    auto constexpr is_nothrow_less_than_equal_to_comparable_v = is_nothrow_less_than_equal_to_comparable<T>::value;
-
-    template<typename T, typename = void>
-    struct is_greater_than_equal_to_comparable : std::false_type
-    {
-    };
-
-    template<typename T>
-    struct is_greater_than_equal_to_comparable<T, std::void_t<decltype(std::declval<T const &>() >= std::declval<T const &>())>>
-        : std::true_type
-    {
-    };
-
-    template<typename T>
-    auto constexpr is_greater_than_equal_to_comparable_v = is_greater_than_equal_to_comparable<T>::value;
-
-    template<typename T, typename = void>
-    struct is_nothrow_greater_than_equal_to_comparable : std::false_type
-    {
-    };
-
-    template<typename T>
-    struct is_nothrow_greater_than_equal_to_comparable<T, std::void_t<decltype(std::declval<T const &>() >= std::declval<T const &>())>>
-        : std::bool_constant<noexcept(std::declval<T const &>() >= std::declval<T const &>())>
-    {
-    };
-
-    template<typename T>
-    auto constexpr is_nothrow_greater_than_equal_to_comparable_v = is_nothrow_greater_than_equal_to_comparable<T>::value;
-  }  // namespace relationally_comparable
-
   inline namespace arithmetic
   {
 
diff --git a/source/lib/include/newtype/newtype.hpp b/source/lib/include/newtype/newtype.hpp
index e40097d..44bd1b8 100644
--- a/source/lib/include/newtype/newtype.hpp
+++ b/source/lib/include/newtype/newtype.hpp
@@ -299,38 +299,34 @@ namespace nt
     return lhs != rhs.decay();
   }
 
-  template<typename BaseType, typename TagType, auto DerivationClause>
+  template<nt::concepts::less_than_comparable BaseType, typename TagType, nt::contains<nt::Relational> auto DerivationClause>
   auto constexpr
   operator<(new_type<BaseType, TagType, DerivationClause> const & lhs,
-            new_type<BaseType, TagType, DerivationClause> const & rhs) noexcept(impl::is_nothrow_less_than_comparable_v<BaseType>)
-      -> std::enable_if_t<DerivationClause(nt::Relational) && impl::is_less_than_comparable_v<BaseType>, bool>
+            new_type<BaseType, TagType, DerivationClause> const & rhs) noexcept(nt::concepts::nothrow_less_than_comparable<BaseType>)
   {
     return lhs.decay() < rhs.decay();
   }
 
-  template<typename BaseType, typename TagType, auto DerivationClause>
+  template<nt::concepts::greater_than_comparable BaseType, typename TagType, nt::contains<nt::Relational> auto DerivationClause>
   auto constexpr
   operator>(new_type<BaseType, TagType, DerivationClause> const & lhs,
-            new_type<BaseType, TagType, DerivationClause> const & rhs) noexcept(impl::is_nothrow_greater_than_comparable_v<BaseType>)
-      -> std::enable_if_t<DerivationClause(nt::Relational) && impl::is_greater_than_comparable_v<BaseType>, bool>
+            new_type<BaseType, TagType, DerivationClause> const & rhs) noexcept(nt::concepts::nothrow_greater_than_comparable<BaseType>)
   {
     return lhs.decay() > rhs.decay();
   }
 
-  template<typename BaseType, typename TagType, auto DerivationClause>
+  template<nt::concepts::less_than_equal_comparable BaseType, typename TagType, nt::contains<nt::Relational> auto DerivationClause>
   auto constexpr
   operator<=(new_type<BaseType, TagType, DerivationClause> const & lhs,
-             new_type<BaseType, TagType, DerivationClause> const & rhs) noexcept(impl::is_nothrow_less_than_equal_to_comparable_v<BaseType>)
-      -> std::enable_if_t<DerivationClause(nt::Relational) && impl::is_less_than_equal_to_comparable_v<BaseType>, bool>
+             new_type<BaseType, TagType, DerivationClause> const & rhs) noexcept(nt::concepts::nothrow_less_than_equal_comparable<BaseType>)
   {
     return lhs.decay() <= rhs.decay();
   }
 
-  template<typename BaseType, typename TagType, auto DerivationClause>
+  template<nt::concepts::greater_than_equal_comparable BaseType, typename TagType, nt::contains<nt::Relational> auto DerivationClause>
   auto constexpr
   operator>=(new_type<BaseType, TagType, DerivationClause> const & lhs,
-             new_type<BaseType, TagType, DerivationClause> const & rhs) noexcept(impl::is_nothrow_greater_than_equal_to_comparable_v<BaseType>)
-      -> std::enable_if_t<DerivationClause(nt::Relational) && impl::is_greater_than_equal_to_comparable_v<BaseType>, bool>
+             new_type<BaseType, TagType, DerivationClause> const & rhs) noexcept(nt::concepts::nothrow_greater_than_equal_comparable<BaseType>)
   {
     return lhs.decay() >= rhs.decay();
   }
diff --git a/source/tests/src/relational_operators.cpp b/source/tests/src/relational_operators.cpp
index 95e1bd4..de6f7f3 100644
--- a/source/tests/src/relational_operators.cpp
+++ b/source/tests/src/relational_operators.cpp
@@ -9,190 +9,121 @@
 #include <type_traits>
 #include <utility>
 
-inline namespace traits_extensions
-{
-
-  template<typename T, typename = void>
-  struct has_less_than : std::false_type
-  {
-  };
-
-  template<typename T>
-  struct has_less_than<T, std::void_t<decltype(std::declval<T const &>() < std::declval<T const &>())>> : std::true_type
-  {
-  };
-
-  template<typename T>
-  auto constexpr has_less_than_v = has_less_than<T>::value;
-
-  template<typename T>
-  auto constexpr has_nothrow_less_than_v = has_less_than_v<T> && noexcept(std::declval<T const &>() < std::declval<T const &>());
-
-  template<typename T, typename = void>
-  struct has_greater_than : std::false_type
-  {
-  };
-
-  template<typename T>
-  struct has_greater_than<T, std::void_t<decltype(std::declval<T const &>() > std::declval<T const &>())>> : std::true_type
-  {
-  };
-
-  template<typename T>
-  auto constexpr has_greater_than_v = has_greater_than<T>::value;
-
-  template<typename T>
-  auto constexpr has_nothrow_greater_than_v = has_less_than_v<T> && noexcept(std::declval<T const &>() < std::declval<T const &>());
-
-  template<typename T, typename = void>
-  struct has_less_than_equal_to : std::false_type
-  {
-  };
-
-  template<typename T>
-  struct has_less_than_equal_to<T, std::void_t<decltype(std::declval<T const &>() <= std::declval<T const &>())>> : std::true_type
-  {
-  };
-
-  template<typename T>
-  auto constexpr has_less_than_equal_to_v = has_less_than_equal_to<T>::value;
-
-  template<typename T>
-  auto constexpr has_nothrow_less_than_equal_to_v = has_less_than_v<T> && noexcept(std::declval<T const &>() < std::declval<T const &>());
-
-  template<typename T, typename = void>
-  struct has_greater_than_equal_to : std::false_type
-  {
-  };
-
-  template<typename T>
-  struct has_greater_than_equal_to<T, std::void_t<decltype(std::declval<T const &>() >= std::declval<T const &>())>> : std::true_type
-  {
-  };
-
-  template<typename T>
-  auto constexpr has_greater_than_equal_to_v = has_greater_than_equal_to<T>::value;
-
-  template<typename T>
-  auto constexpr has_nothrow_greater_than_equal_to_v = has_less_than_v<T> && noexcept(std::declval<T const &>() < std::declval<T const &>());
-
-}  // namespace traits_extensions
-
 SCENARIO("Relational Operator Availability")
 {
   GIVEN("A new_type over a relationally comparable type not deriving nt::Relational")
   {
     using type_alias = nt::new_type<int, struct tag>;
-    static_assert(has_less_than_v<type_alias::base_type>);
-    static_assert(has_less_than_equal_to_v<type_alias::base_type>);
-    static_assert(has_greater_than_v<type_alias::base_type>);
-    static_assert(has_greater_than_equal_to_v<type_alias::base_type>);
+    static_assert(nt::concepts::less_than_comparable<type_alias::base_type>);
+    static_assert(nt::concepts::less_than_equal_comparable<type_alias::base_type>);
+    static_assert(nt::concepts::greater_than_comparable<type_alias::base_type>);
+    static_assert(nt::concepts::greater_than_equal_comparable<type_alias::base_type>);
 
     THEN("it does not have <")
     {
-      STATIC_REQUIRE_FALSE(has_less_than_v<type_alias>);
+      STATIC_REQUIRE_FALSE(nt::concepts::less_than_comparable<type_alias>);
     }
 
     THEN("it does not have <=")
     {
-      STATIC_REQUIRE_FALSE(has_less_than_equal_to_v<type_alias>);
+      STATIC_REQUIRE_FALSE(nt::concepts::less_than_equal_comparable<type_alias>);
     }
 
     THEN("it does not have >")
     {
-      STATIC_REQUIRE_FALSE(has_greater_than_v<type_alias>);
+      STATIC_REQUIRE_FALSE(nt::concepts::greater_than_comparable<type_alias>);
     }
 
     THEN("it does not have >=")
     {
-      STATIC_REQUIRE_FALSE(has_greater_than_equal_to_v<type_alias>);
+      STATIC_REQUIRE_FALSE(nt::concepts::greater_than_equal_comparable<type_alias>);
     }
   }
 
   GIVEN("A new_type over a relationally comparable type deriving nt::Relational")
   {
     using type_alias = nt::new_type<int, struct tag, deriving(nt::Relational)>;
-    static_assert(has_less_than_v<type_alias::base_type>);
-    static_assert(has_less_than_equal_to_v<type_alias::base_type>);
-    static_assert(has_greater_than_v<type_alias::base_type>);
-    static_assert(has_greater_than_equal_to_v<type_alias::base_type>);
+    static_assert(nt::concepts::less_than_comparable<type_alias::base_type>);
+    static_assert(nt::concepts::less_than_equal_comparable<type_alias::base_type>);
+    static_assert(nt::concepts::greater_than_comparable<type_alias::base_type>);
+    static_assert(nt::concepts::greater_than_equal_comparable<type_alias::base_type>);
 
     THEN("it does have <")
     {
-      STATIC_REQUIRE(has_less_than_v<type_alias>);
+      STATIC_REQUIRE(nt::concepts::less_than_comparable<type_alias>);
     }
 
     THEN("it does have <=")
     {
-      STATIC_REQUIRE(has_less_than_equal_to_v<type_alias>);
+      STATIC_REQUIRE(nt::concepts::less_than_equal_comparable<type_alias>);
     }
 
     THEN("it does have >")
     {
-      STATIC_REQUIRE(has_greater_than_v<type_alias>);
+      STATIC_REQUIRE(nt::concepts::greater_than_comparable<type_alias>);
     }
 
     THEN("it does have >=")
     {
-      STATIC_REQUIRE(has_greater_than_equal_to_v<type_alias>);
+      STATIC_REQUIRE(nt::concepts::greater_than_equal_comparable<type_alias>);
     }
   }
 
   GIVEN("A new_type over a type that is not relationally comparable not deriving nt::Relational")
   {
     using type_alias = nt::new_type<std::istream, struct tag>;
-    static_assert(!has_less_than_v<type_alias::base_type>);
-    static_assert(!has_less_than_equal_to_v<type_alias::base_type>);
-    static_assert(!has_greater_than_v<type_alias::base_type>);
-    static_assert(!has_greater_than_equal_to_v<type_alias::base_type>);
+    static_assert(!nt::concepts::less_than_comparable<type_alias::base_type>);
+    static_assert(!nt::concepts::less_than_equal_comparable<type_alias::base_type>);
+    static_assert(!nt::concepts::greater_than_comparable<type_alias::base_type>);
+    static_assert(!nt::concepts::greater_than_equal_comparable<type_alias::base_type>);
 
     THEN("it does not have <")
     {
-      STATIC_REQUIRE_FALSE(has_less_than_v<type_alias>);
+      STATIC_REQUIRE_FALSE(nt::concepts::less_than_comparable<type_alias>);
     }
 
     THEN("it does not have <=")
     {
-      STATIC_REQUIRE_FALSE(has_less_than_equal_to_v<type_alias>);
+      STATIC_REQUIRE_FALSE(nt::concepts::less_than_equal_comparable<type_alias>);
     }
 
     THEN("it does not have >")
     {
-      STATIC_REQUIRE_FALSE(has_greater_than_v<type_alias>);
+      STATIC_REQUIRE_FALSE(nt::concepts::greater_than_comparable<type_alias>);
     }
 
     THEN("it does not have >=")
     {
-      STATIC_REQUIRE_FALSE(has_greater_than_equal_to_v<type_alias>);
+      STATIC_REQUIRE_FALSE(nt::concepts::greater_than_equal_comparable<type_alias>);
     }
   }
 
   GIVEN("A new_type over a type that is not relationally comparable deriving nt::Relational")
   {
     using type_alias = nt::new_type<std::istream, struct tag, deriving(nt::Relational)>;
-    static_assert(!has_less_than_v<type_alias::base_type>);
-    static_assert(!has_less_than_equal_to_v<type_alias::base_type>);
-    static_assert(!has_greater_than_v<type_alias::base_type>);
-    static_assert(!has_greater_than_equal_to_v<type_alias::base_type>);
+    static_assert(!nt::concepts::less_than_comparable<type_alias::base_type>);
+    static_assert(!nt::concepts::less_than_equal_comparable<type_alias::base_type>);
+    static_assert(!nt::concepts::greater_than_comparable<type_alias::base_type>);
+    static_assert(!nt::concepts::greater_than_equal_comparable<type_alias::base_type>);
 
     THEN("it does not have <")
     {
-      STATIC_REQUIRE_FALSE(has_less_than_v<type_alias>);
+      STATIC_REQUIRE_FALSE(nt::concepts::less_than_comparable<type_alias>);
     }
 
     THEN("it does not have <=")
     {
-      STATIC_REQUIRE_FALSE(has_less_than_equal_to_v<type_alias>);
+      STATIC_REQUIRE_FALSE(nt::concepts::less_than_equal_comparable<type_alias>);
     }
 
     THEN("it does not have >")
     {
-      STATIC_REQUIRE_FALSE(has_greater_than_v<type_alias>);
+      STATIC_REQUIRE_FALSE(nt::concepts::greater_than_comparable<type_alias>);
     }
 
     THEN("it does not have >=")
     {
-      STATIC_REQUIRE_FALSE(has_greater_than_equal_to_v<type_alias>);
+      STATIC_REQUIRE_FALSE(nt::concepts::greater_than_equal_comparable<type_alias>);
     }
   }
 }
@@ -202,10 +133,10 @@ SCENARIO("Relational Comparisons")
   GIVEN("A new_type over a relationally comparable type deriving nt::Relational")
   {
     using type_alias = nt::new_type<int, struct tag, deriving(nt::Relational)>;
-    static_assert(has_less_than_v<type_alias::base_type>);
-    static_assert(has_less_than_equal_to_v<type_alias::base_type>);
-    static_assert(has_greater_than_v<type_alias::base_type>);
-    static_assert(has_greater_than_equal_to_v<type_alias::base_type>);
+    static_assert(nt::concepts::less_than_comparable<type_alias::base_type>);
+    static_assert(nt::concepts::less_than_equal_comparable<type_alias::base_type>);
+    static_assert(nt::concepts::greater_than_comparable<type_alias::base_type>);
+    static_assert(nt::concepts::greater_than_equal_comparable<type_alias::base_type>);
 
     THEN("comparing two instances using < yields the same result as it does for the base type")
     {
@@ -238,29 +169,29 @@ SCENARIO("Nothrow Relational Comparison")
   GIVEN("A new_type over a nothrow relationally comparable type deriving nt::Relational")
   {
     using type_alias = nt::new_type<int, struct tag, deriving(nt::Relational)>;
-    static_assert(has_nothrow_less_than_v<type_alias::base_type>);
-    static_assert(has_nothrow_less_than_equal_to_v<type_alias::base_type>);
-    static_assert(has_nothrow_greater_than_v<type_alias::base_type>);
-    static_assert(has_nothrow_greater_than_equal_to_v<type_alias::base_type>);
+    static_assert(nt::concepts::nothrow_less_than_comparable<type_alias::base_type>);
+    static_assert(nt::concepts::nothrow_less_than_equal_comparable<type_alias::base_type>);
+    static_assert(nt::concepts::nothrow_greater_than_comparable<type_alias::base_type>);
+    static_assert(nt::concepts::nothrow_greater_than_equal_comparable<type_alias::base_type>);
 
     THEN("it is nothrow-comparable using < ")
     {
-      STATIC_REQUIRE(has_nothrow_less_than_v<type_alias>);
+      STATIC_REQUIRE(nt::concepts::nothrow_less_than_comparable<type_alias>);
     }
 
     THEN("it is nothrow-comparable using <= ")
     {
-      STATIC_REQUIRE(has_nothrow_less_than_equal_to_v<type_alias>);
+      STATIC_REQUIRE(nt::concepts::nothrow_less_than_equal_comparable<type_alias>);
     }
 
     THEN("it is nothrow-comparable using > ")
     {
-      STATIC_REQUIRE(has_nothrow_greater_than_v<type_alias>);
+      STATIC_REQUIRE(nt::concepts::nothrow_greater_than_comparable<type_alias>);
     }
 
     THEN("it is nothrow-comparable using >= ")
     {
-      STATIC_REQUIRE(has_nothrow_greater_than_equal_to_v<type_alias>);
+      STATIC_REQUIRE(nt::concepts::nothrow_greater_than_equal_comparable<type_alias>);
     }
   }
 
@@ -268,36 +199,53 @@ SCENARIO("Nothrow Relational Comparison")
   {
     struct strange_type
     {
-      auto constexpr operator<(strange_type const & other) const noexcept(false) -> bool;
-      auto constexpr operator>(strange_type const & other) const noexcept(false) -> bool;
-      auto constexpr operator<=(strange_type const & other) const noexcept(false) -> bool;
-      auto constexpr operator>=(strange_type const & other) const noexcept(false) -> bool;
+      auto constexpr operator<(strange_type const &) const noexcept(false) -> bool
+      {
+        return false;
+      }
+      auto constexpr operator>(strange_type const &) const noexcept(false) -> bool
+      {
+        return false;
+      }
+      auto constexpr operator<=(strange_type const &) const noexcept(false) -> bool
+      {
+        return false;
+      }
+      auto constexpr operator>=(strange_type const &) const noexcept(false) -> bool
+      {
+        return false;
+      }
     };
 
     using type_alias = nt::new_type<strange_type, struct tag, deriving(nt::Relational)>;
-    static_assert(has_less_than_v<type_alias::base_type> && !has_nothrow_less_than_v<type_alias::base_type>);
-    static_assert(has_less_than_equal_to_v<type_alias::base_type> && !has_nothrow_less_than_equal_to_v<type_alias::base_type>);
-    static_assert(has_greater_than_v<type_alias::base_type> && !has_nothrow_greater_than_v<type_alias::base_type>);
-    static_assert(has_greater_than_equal_to_v<type_alias::base_type> && !has_nothrow_greater_than_equal_to_v<type_alias::base_type>);
+    static_assert(nt::concepts::less_than_comparable<type_alias::base_type> &&
+                  !nt::concepts::nothrow_less_than_comparable<type_alias::base_type>);
+    static_assert(nt::concepts::less_than_equal_comparable<type_alias::base_type> &&
+                  !nt::concepts::nothrow_less_than_equal_comparable<type_alias::base_type>);
+    static_assert(nt::concepts::greater_than_comparable<type_alias::base_type> &&
+                  !nt::concepts::nothrow_greater_than_comparable<type_alias::base_type>);
+    static_assert(nt::concepts::greater_than_equal_comparable<type_alias::base_type> &&
+                  !nt::concepts::nothrow_greater_than_equal_comparable<type_alias::base_type>);
 
     THEN("it is not nothrow-comparable using < ")
     {
-      STATIC_REQUIRE(has_less_than_v<type_alias> && !has_nothrow_less_than_v<type_alias>);
+      STATIC_REQUIRE(nt::concepts::less_than_comparable<type_alias> && !nt::concepts::nothrow_less_than_comparable<type_alias>);
     }
 
     THEN("it is not nothrow-comparable using <= ")
     {
-      STATIC_REQUIRE(has_less_than_equal_to_v<type_alias> && !has_nothrow_less_than_equal_to_v<type_alias>);
+      STATIC_REQUIRE(nt::concepts::less_than_equal_comparable<type_alias> && !nt::concepts::nothrow_less_than_equal_comparable<type_alias>);
     }
 
     THEN("it is not nothrow-comparable using > ")
     {
-      STATIC_REQUIRE(has_greater_than_v<type_alias> && !has_nothrow_greater_than_v<type_alias>);
+      STATIC_REQUIRE(nt::concepts::greater_than_comparable<type_alias> && !nt::concepts::nothrow_greater_than_comparable<type_alias>);
     }
 
     THEN("it is not nothrow-comparable using >= ")
     {
-      STATIC_REQUIRE(has_greater_than_equal_to_v<type_alias> && !has_nothrow_greater_than_equal_to_v<type_alias>);
+      STATIC_REQUIRE(nt::concepts::greater_than_equal_comparable<type_alias> &&
+                     !nt::concepts::nothrow_greater_than_equal_comparable<type_alias>);
     }
   }
 }
-- 
cgit v1.2.3