fix continuations with lvalue callables

Author: beekld

libs/internal/include/launchdarkly/async/promise.hpp

@@ -43,7 +43,7 @@ class Continuation<R(Args...)> {
     template <typename F>
     struct Impl : Base {
         F f;
-        Impl(F&& f) : f(std::move(f)) {}
+        Impl(F f) : f(std::move(f)) {}
         R call(Args... args) override { return f(std::forward<Args>(args)...); }
     };
 
@@ -56,7 +56,7 @@ class Continuation<R(Args...)> {
     // then moves it into Impl<F> so Continuation itself owns the callable.
     template <typename F>
     Continuation(F&& f)
-        : impl_(std::make_unique<Impl<F>>(std::forward<F>(f))) {}
+        : impl_(std::make_unique<Impl<std::decay_t<F>>>(std::forward<F>(f))) {}
     Continuation(Continuation&&) = default;
     Continuation& operator=(Continuation&&) = default;
 

libs/internal/tests/promise_test.cpp

@@ -307,6 +307,14 @@ TEST(Promise, ExpectedFailure) {
     EXPECT_EQ(result->error(), "timed out");
 }
 
+// Verifies that a Continuation can be constructed from an lvalue callable
+// (named lambda), not just from a temporary.
+TEST(Promise, LvalueLambdaContinuation) {
+    auto fn = [](int x) { return x * 2; };
+    Continuation<int(int)> c(fn);
+    EXPECT_EQ(c(21), 42);
+}
+
 TEST(WhenAll, NoFutures) {
     Future<std::monostate> result = WhenAll();
     EXPECT_TRUE(result.IsFinished());