[lmi-commits] [lmi] odd/move_semantics cc46b95a 4/5: Use 'concept' syntax

[Greg Chicares]

branch: odd/move_semantics
commit cc46b95a138b7b3380cb95b9eace7c3a55456312
Author: Gregory W. Chicares <gchicares@sbcglobal.net>
Commit: Gregory W. Chicares <gchicares@sbcglobal.net>

    Use 'concept' syntax
---
 sandbox_test.cpp | 96 +++++++++++++++++++++++++++-----------------------------
 1 file changed, 46 insertions(+), 50 deletions(-)

diff --git a/sandbox_test.cpp b/sandbox_test.cpp
index 326ed83e..77e3d9b1 100644
--- a/sandbox_test.cpp
+++ b/sandbox_test.cpp
@@ -56,15 +56,11 @@ struct ambiguator
 // were considered, but they looked too much like
 //   a Sable, c Bible
 
-template<typename T> constexpr bool equiplausible_construct()
-{
-    return !std::is_constructible_v<T,ambiguator<T>>;
-}
+template<typename T> concept equiplausibly_constructible =
+    !std::is_constructible_v<T,ambiguator<T>>;
 
-template<typename T> constexpr bool equiplausible_assign()
-{
-    return !std::is_assignable_v<T,ambiguator<T>>;
-}
+template<typename T> concept equiplausibly_assignable =
+    !std::is_assignable_v<T,ambiguator<T>>;
 
 // This thing is mercifully unnecessary: unnecessary because nothing
 // in this file depends upon it, and mercifully so because there are
@@ -79,15 +75,15 @@ template<typename T> constexpr bool copyable()
     return std::is_copy_constructible_v<T>;
 }
 
-template<typename T> constexpr bool a_moveable() // assign-moveable
-{
-    return std::is_move_assignable_v<T> && equiplausible_assign<T>();
-}
+template<typename T> concept well_move_assignable =
+       std::is_move_assignable_v<T>
+    && equiplausibly_assignable<T>
+    ;
 
-template<typename T> constexpr bool c_moveable() // copy-moveable
-{
-    return std::is_move_constructible_v<T> && equiplausible_construct<T>();
-}
+template<typename T> concept well_move_constructible =
+       std::is_move_constructible_v<T>
+    && equiplausibly_constructible<T>
+    ;
 
 struct can_move
 {
@@ -213,9 +209,9 @@ void test_classes()
 // 0000 0101 0202 0303 0404 0505 3030
 //   +    +    +    +    +    +    -   p: is_copy_constructible
 //   +    +    -    -    +    +    +   q: is_move_constructible
-//   +    -    +    +    -    +    +   r: equiplausible_construct
+//   +    -    +    +    -    +    +   r: equiplausibly_constructible
 //   +    +    -    -    +    -    +   s: is_move_assignable
-//   +    -    +    +    -    +    +   t: equiplausible_assign
+//   +    -    +    +    -    +    +   t: equiplausibly_assignable
 //   +    -    -    -    -    +    +   x: move construct has move semantics
 //   +    -    -    -    -    -    +   y: move assign has move semantics
 //   +    +    -    -    +    +    +   z: move compiles without error
@@ -224,8 +220,8 @@ void test_classes()
     static_assert( std::is_move_constructible_v<A0000>);
     static_assert(!std::is_constructible_v<A0000,ambiguator<A0000>>);
     static_assert( copyable<A0000>());
-    static_assert( c_moveable<A0000>());
-    static_assert( a_moveable<A0000>());
+    static_assert( well_move_constructible<A0000>);
+    static_assert( well_move_assignable<A0000>);
 
     static_assert( std::is_copy_constructible_v<A0000>);
     static_assert( std::is_copy_constructible_v<A0101>);
@@ -259,21 +255,21 @@ void test_classes()
     static_assert(!std::is_constructible_v<A0505,ambiguator<A0505>>);
     static_assert(!std::is_constructible_v<A3030,ambiguator<A3030>>);
 
-    static_assert( equiplausible_construct<A0000>());
-    static_assert(!equiplausible_construct<A0101>());
-    static_assert( equiplausible_construct<A0202>());
-    static_assert( equiplausible_construct<A0303>());
-    static_assert(!equiplausible_construct<A0404>());
-    static_assert( equiplausible_construct<A0505>());
-    static_assert( equiplausible_construct<A3030>());
-
-    static_assert( equiplausible_assign<A0000>());
-    static_assert(!equiplausible_assign<A0101>());
-    static_assert( equiplausible_assign<A0202>());
-    static_assert( equiplausible_assign<A0303>());
-    static_assert(!equiplausible_assign<A0404>());
-    static_assert( equiplausible_assign<A0505>());
-    static_assert( equiplausible_assign<A3030>());
+    static_assert( equiplausibly_constructible<A0000>);
+    static_assert(!equiplausibly_constructible<A0101>);
+    static_assert( equiplausibly_constructible<A0202>);
+    static_assert( equiplausibly_constructible<A0303>);
+    static_assert(!equiplausibly_constructible<A0404>);
+    static_assert( equiplausibly_constructible<A0505>);
+    static_assert( equiplausibly_constructible<A3030>);
+
+    static_assert( equiplausibly_assignable<A0000>);
+    static_assert(!equiplausibly_assignable<A0101>);
+    static_assert( equiplausibly_assignable<A0202>);
+    static_assert( equiplausibly_assignable<A0303>);
+    static_assert(!equiplausibly_assignable<A0404>);
+    static_assert( equiplausibly_assignable<A0505>);
+    static_assert( equiplausibly_assignable<A3030>);
 
     static_assert( copyable<A0000>());
     static_assert( copyable<A0101>());
@@ -283,21 +279,21 @@ void test_classes()
     static_assert( copyable<A0505>());
     static_assert(!copyable<A3030>());
 
-    static_assert( c_moveable<A0000>());
-    static_assert(!c_moveable<A0101>());
-    static_assert(!c_moveable<A0202>());
-    static_assert(!c_moveable<A0303>());
-    static_assert(!c_moveable<A0404>());
-    static_assert( c_moveable<A0505>()); // move-constructible; not 
move-assignable
-    static_assert( c_moveable<A3030>());
-
-    static_assert( a_moveable<A0000>());
-    static_assert(!a_moveable<A0101>());
-    static_assert(!a_moveable<A0202>());
-    static_assert(!a_moveable<A0303>());
-    static_assert(!a_moveable<A0404>());
-    static_assert(!a_moveable<A0505>()); // move-constructible; not 
move-assignable
-    static_assert( a_moveable<A3030>());
+    static_assert( well_move_constructible<A0000>);
+    static_assert(!well_move_constructible<A0101>);
+    static_assert(!well_move_constructible<A0202>);
+    static_assert(!well_move_constructible<A0303>);
+    static_assert(!well_move_constructible<A0404>);
+    static_assert( well_move_constructible<A0505>); // but not move-assignable
+    static_assert( well_move_constructible<A3030>);
+
+    static_assert( well_move_assignable<A0000>);
+    static_assert(!well_move_assignable<A0101>);
+    static_assert(!well_move_assignable<A0202>);
+    static_assert(!well_move_assignable<A0303>);
+    static_assert(!well_move_assignable<A0404>);
+    static_assert(!well_move_assignable<A0505>); // move-constructible, however
+    static_assert( well_move_assignable<A3030>);
 
     A0000 a0000 {};
     A0101 a0101 {};