P1084R2 Today's return-type-requirements Are Insufficient

Library-side changes: replace
  requires { E; requires Concept<decltype((E)), A, B>; }
with
  requires { { E } -> Concept<A, B>; }

Author: CaseyCarter

source/concepts.tex

@@ -479,8 +479,7 @@
     is_lvalue_reference_v<LHS> &&
     CommonReference<const remove_reference_t<LHS>&, const remove_reference_t<RHS>&> &&
     requires(LHS lhs, RHS&& rhs) {
-      lhs = std::forward<RHS>(rhs);
-      requires Same<decltype(lhs = std::forward<RHS>(rhs)), LHS>;
+      { lhs = std::forward<RHS>(rhs) } -> Same<LHS>;
     };
 \end{itemdecl}
 
@@ -757,19 +756,19 @@
     requires(const remove_reference_t<B>& b1,
              const remove_reference_t<B>& b2, const bool a) {
       requires ConvertibleTo<const remove_reference_t<B>&, bool>;
-      !b1;      requires ConvertibleTo<decltype(!b1), bool>;
-      b1 &&  a; requires Same<decltype(b1 &&  a), bool>;
-      b1 ||  a; requires Same<decltype(b1 ||  a), bool>;
-      b1 && b2; requires Same<decltype(b1 && b2), bool>;
-       a && b2; requires Same<decltype( a && b2), bool>;
-      b1 || b2; requires Same<decltype(b1 || b2), bool>;
-       a || b2; requires Same<decltype( a || b2), bool>;
-      b1 == b2; requires ConvertibleTo<decltype(b1 == b2), bool>;
-      b1 ==  a; requires ConvertibleTo<decltype(b1 ==  a), bool>;
-       a == b2; requires ConvertibleTo<decltype( a == b2), bool>;
-      b1 != b2; requires ConvertibleTo<decltype(b1 != b2), bool>;
-      b1 !=  a; requires ConvertibleTo<decltype(b1 !=  a), bool>;
-       a != b2; requires ConvertibleTo<decltype( a != b2), bool>;
+      { !b1 } -> ConvertibleTo<bool>;
+      { b1 &&  a } -> Same<bool>;
+      { b1 ||  a } -> Same<bool>;
+      { b1 && b2 } -> Same<bool>;
+      {  a && b2 } -> Same<bool>;
+      { b1 || b2 } -> Same<bool>;
+      {  a || b2 } -> Same<bool>;
+      { b1 == b2 } -> ConvertibleTo<bool>;
+      { b1 ==  a } -> ConvertibleTo<bool>;
+      {  a == b2 } -> ConvertibleTo<bool>;
+      { b1 != b2 } -> ConvertibleTo<bool>;
+      { b1 !=  a } -> ConvertibleTo<bool>;
+      {  a != b2 } -> ConvertibleTo<bool>;
     };
 \end{itemdecl}
 
@@ -811,10 +810,10 @@
   concept @\placeholder{weakly-equality-comparable-with}@ = // \expos
     requires(const remove_reference_t<T>& t,
              const remove_reference_t<U>& u) {
-      t == u; requires Boolean<decltype(t == u)>;
-      t != u; requires Boolean<decltype(t != u)>;
-      u == t; requires Boolean<decltype(u == t)>;
-      u != t; requires Boolean<decltype(u != t)>;
+      { t == u } -> Boolean;
+      { t != u } -> Boolean;
+      { u == t } -> Boolean;
+      { u != t } -> Boolean;
     };
 \end{itemdecl}
 
@@ -888,10 +887,10 @@
     EqualityComparable<T> &&
     requires(const remove_reference_t<T>& a,
              const remove_reference_t<T>& b) {
-      a <  b; requires Boolean<decltype(a <  b)>;
-      a >  b; requires Boolean<decltype(a >  b)>;
-      a <= b; requires Boolean<decltype(a <= b)>;
-      a >= b; requires Boolean<decltype(a >= b)>;
+      { a <  b } -> Boolean;
+      { a >  b } -> Boolean;
+      { a <= b } -> Boolean;
+      { a >= b } -> Boolean;
     };
 \end{itemdecl}
 
@@ -925,14 +924,14 @@
     EqualityComparableWith<T, U> &&
     requires(const remove_reference_t<T>& t,
              const remove_reference_t<U>& u) {
-      t <  u; requires Boolean<decltype(t <  u)>;
-      t >  u; requires Boolean<decltype(t >  u)>;
-      t <= u; requires Boolean<decltype(t <= u)>;
-      t >= u; requires Boolean<decltype(t >= u)>;
-      u <  t; requires Boolean<decltype(u <  t)>;
-      u >  t; requires Boolean<decltype(u >  t)>;
-      u <= t; requires Boolean<decltype(u <= t)>;
-      u >= t; requires Boolean<decltype(u >= t)>;
+      { t <  u } -> Boolean;
+      { t >  u } -> Boolean;
+      { t <= u } -> Boolean;
+      { t >= u } -> Boolean;
+      { u <  t } -> Boolean;
+      { u >  t } -> Boolean;
+      { u <= t } -> Boolean;
+      { u >= t } -> Boolean;
     };
 \end{itemdecl}