Improve parallelism in implementation

Improve the parallelism in t he declarations in the implementation to clarify
that the difference in the overloads is due to the 'Other' parameter for
removing it from consideration for overload since the U parameter is *already*
a reference. Checking for 'const U&' is no longer the right thing to check.

Author: steve-downey

include/beman/optional26/optional.hpp

@@ -283,8 +283,8 @@ class optional {
         requires(!std::is_reference_v<U> && detail::enable_from_other<T, U, const U&>);
 
     template <class U>
-    constexpr explicit(!std::is_convertible_v<U&, T>) optional(const optional<U&>& rhs)
-        requires(detail::enable_from_other<T, U&, U&>);
+    constexpr explicit(!std::is_convertible_v<U, T>) optional(const optional<U>& rhs)
+        requires(std::is_reference_v<U> && detail::enable_from_other<T, U, U>);
 
     template <class U>
     constexpr explicit(!std::is_convertible_v<U, T>) optional(optional<U>&& rhs)
@@ -328,12 +328,12 @@ class optional {
         requires(!std::is_reference_v<U> && detail::enable_assign_from_other<T, U, const U&>);
 
     template <class U>
-    constexpr optional& operator=(optional<U>&& rhs)
-        requires(!std::is_reference_v<U> && detail::enable_assign_from_other<T, U, U>);
+    constexpr optional& operator=(const optional<U>& rhs)
+        requires(std::is_reference_v<U> && detail::enable_assign_from_other<T, U, U>);
 
     template <class U>
-    constexpr optional& operator=(const optional<U&>& rhs)
-        requires(detail::enable_assign_from_other<T, U&, U&>);
+    constexpr optional& operator=(optional<U>&& rhs)
+        requires(!std::is_reference_v<U> && detail::enable_assign_from_other<T, U, U>);
 
     template <class... Args>
     constexpr T& emplace(Args&&... args);
@@ -477,8 +477,8 @@ inline constexpr optional<T>::optional(const optional<U>& rhs)
 /// Converting copy constructor for U&
 template <class T>
 template <class U>
-inline constexpr optional<T>::optional(const optional<U&>& rhs)
-    requires(detail::enable_from_other<T, U&, U&>)
+inline constexpr optional<T>::optional(const optional<U>& rhs)
+    requires(std::is_reference_v<U> && detail::enable_from_other<T, U, U>)
 {
     if (rhs.has_value()) {
         construct(*rhs);
@@ -585,8 +585,8 @@ inline constexpr optional<T>& optional<T>::operator=(const optional<U>& rhs)
 
 template <class T>
 template <class U>
-inline constexpr optional<T>& optional<T>::operator=(const optional<U&>& rhs)
-    requires(detail::enable_assign_from_other<T, U&, U&>)
+inline constexpr optional<T>& optional<T>::operator=(const optional<U>& rhs)
+    requires(std::is_reference_v<U> && detail::enable_assign_from_other<T, U, U>)
 {
     if (has_value()) {
         if (rhs.has_value()) {
@@ -627,7 +627,6 @@ inline constexpr optional<T>& optional<T>::operator=(optional<U>&& rhs)
     return *this;
 }
 
-
 /// Constructs the value in-place, destroying the current one if there is
 /// one.
 template <class T>