Merge pull request #99 from FelixPetriconi/Fix18

Remove comment after clarification and add test case for this.

stlab/concurrency/future.hpp

@@ -656,11 +656,6 @@ class future<T, enable_if_copyable<T>> {
         return _p->get_try();
     }
 
-    // Fp Does it make sense to have this? At the moment I don't see a real use case for it.
-    // One can only ask once on an r-value and then the future is gone.
-    // To perform this in an l-value casted to an r-value does not make sense either,
-    // because in this case _p is not unique any more and internally it is forwarded to
-    // the l-value get_try.
     auto get_try() && {
         return _p->get_try_r(_p.unique());
     }

test/future_tests.cpp

@@ -345,4 +345,29 @@ BOOST_AUTO_TEST_CASE(future_swap_tests)
         BOOST_REQUIRE_EQUAL(5, a.second.get_try().value().member());
         BOOST_REQUIRE_EQUAL(4, b.second.get_try().value().member());
     }
-}
+}
+
+BOOST_FIXTURE_TEST_SUITE(future_then_void, test_fixture<int>)
+
+    BOOST_AUTO_TEST_CASE(future_get_try_refref) {
+        BOOST_TEST_MESSAGE("future get_try()&& accessor test");
+
+        auto sut = async(default_executor, [] { return 42; })
+            .then([](int val) {
+                throw test_exception("failure");
+                return 0;
+            })
+            .recover([](auto &&f) {
+                try {
+                    std::forward<decltype(f)>(f).get_try();
+                    return 0;
+                }
+                catch (const test_exception &e) {
+                    return 42;
+                }
+            });
+
+        wait_until_future_completed(sut);
+        BOOST_REQUIRE_EQUAL(42, sut.get_try().value());
+    }
+BOOST_AUTO_TEST_SUITE_END()