expected: Allow move-only unexpected type

README.md

@@ -402,6 +402,7 @@ expected: Allows to move-assign from expected, error
 expected: Allows to forward-assign from value
 expected: Allows to copy-assign from unexpected
 expected: Allows to move-assign from unexpected
+expected: Allows to move-assign from move-only unexpected
 expected: Allows to emplace value
 expected: Allows to emplace value from initializer_list
 expected: Allows to be swapped

include/nonstd/expected.hpp

@@ -1664,10 +1664,11 @@ class expected
         return *this;
     }
 
-    template< typename G
+    template< typename G = E
         nsel_REQUIRES_T(
-            std::is_copy_constructible<E>::value    // TODO: std::is_nothrow_copy_constructible<E>
-            && std::is_copy_assignable<E>::value
+            std::is_constructible<E, G const&>::value &&
+            std::is_copy_constructible<G>::value    // TODO: std::is_nothrow_copy_constructible<G>
+            && std::is_copy_assignable<G>::value
         )
     >
     expected & operator=( nonstd::unexpected_type<G> const & error )
@@ -1676,10 +1677,11 @@ class expected
         return *this;
     }
 
-    template< typename G
+    template< typename G = E
         nsel_REQUIRES_T(
-            std::is_move_constructible<E>::value    // TODO: std::is_nothrow_move_constructible<E>
-            && std::is_move_assignable<E>::value
+            std::is_constructible<E, G&&>::value &&
+            std::is_move_constructible<G>::value    // TODO: std::is_nothrow_move_constructible<G>
+            && std::is_move_assignable<G>::value
         )
     >
     expected & operator=( nonstd::unexpected_type<G> && error )

test/expected.t.cpp

@@ -29,6 +29,18 @@ using namespace nonstd;
 
 struct Implicit { int x;          Implicit(int v) : x(v) {} };
 struct Explicit { int x; explicit Explicit(int v) : x(v) {} };
+struct MoveOnly {
+    int x;
+    explicit MoveOnly(int x) :x{x} {}
+    MoveOnly(const MoveOnly&) = delete;
+    MoveOnly(MoveOnly&& other) noexcept :x{other.x} {}
+    MoveOnly& operator=(const MoveOnly&) = delete;
+    MoveOnly& operator=(MoveOnly&& other) noexcept {
+        if (&other == this) return *this;
+        x = other.x;
+        return *this;
+    }
+};
 
 bool operator==( Implicit a, Implicit b ) { return a.x == b.x; }
 bool operator==( Explicit a, Explicit b ) { return a.x == b.x; }
@@ -902,6 +914,16 @@ CASE( "expected: Allows to move-assign from unexpected" )
     EXPECT( e.error() == 7 );
 }
 
+CASE( "expected: Allows to move-assign from move-only unexpected" )
+{
+    expected<char, MoveOnly> e;
+    unexpected_type<MoveOnly> u{7};
+
+    e = std::move( u );
+
+    EXPECT( e.error() == 7 );
+}
+
 CASE( "expected: Allows to emplace value" )
 {
     expected<int, char> a;