SERVER-36359 Introduce SemiFuture<T> and ExecutorFuture<T>

1 files changed, 132 insertions, 168 deletions

diff --git a/src/mongo/util/future_test_future_move_only.cpp b/src/mongo/util/future_test_future_move_only.cpp
index dedf4ece469..6419915d003 100644
--- a/src/mongo/util/future_test_future_move_only.cpp
+++ b/src/mongo/util/future_test_future_move_only.cpp
@@ -76,52 +76,59 @@ std::ostream& operator<<(std::ostream& stream, const Widget& widget) {
 
 TEST(Future_MoveOnly, Success_getLvalue) {
     FUTURE_SUCCESS_TEST([] { return Widget(1); },
-                        [](Future<Widget>&& fut) { ASSERT_EQ(fut.get(), 1); });
+                        [](/*Future<Widget>*/ auto&& fut) { ASSERT_EQ(fut.get(), 1); });
 }
 
 TEST(Future_MoveOnly, Success_getConstLvalue) {
     FUTURE_SUCCESS_TEST([] { return Widget(1); },
-                        [](const Future<Widget>& fut) { ASSERT_EQ(fut.get(), 1); });
+                        [](const /*Future<Widget>*/ auto& fut) { ASSERT_EQ(fut.get(), 1); });
 }
 
 TEST(Future_MoveOnly, Success_getRvalue) {
     FUTURE_SUCCESS_TEST([] { return Widget(1); },
-                        [](Future<Widget>&& fut) { ASSERT_EQ(std::move(fut).get(), 1); });
+                        [](/*Future<Widget>*/ auto&& fut) { ASSERT_EQ(std::move(fut).get(), 1); });
+}
+
+TEST(Future_MoveOnly, Success_semi_get) {
+    FUTURE_SUCCESS_TEST(
+        [] { return Widget(1); },
+        [](/*Future<Widget>*/ auto&& fut) { ASSERT_EQ(std::move(fut).semi().get(), 1); });
 }
 
 TEST(Future_MoveOnly, Success_shared_get) {
-    FUTURE_SUCCESS_TEST([] { return Widget(1); },
-                        [](Future<Widget>&& fut) { ASSERT_EQ(std::move(fut).share().get(), 1); });
+    FUTURE_SUCCESS_TEST(
+        [] { return Widget(1); },
+        [](/*Future<Widget>*/ auto&& fut) { ASSERT_EQ(std::move(fut).share().get(), 1); });
 }
 
 #if 0  // Needs copy
 TEST(Future_MoveOnly, Success_getNothrowLvalue) {
     FUTURE_SUCCESS_TEST([] { return Widget(1); },
-                        [](Future<Widget>&& fut) { ASSERT_EQ(fut.getNoThrow(), 1); });
+                        [](/*Future<Widget>*/ auto&& fut) { ASSERT_EQ(fut.getNoThrow(), 1); });
 }
 
 TEST(Future_MoveOnly, Success_getNothrowConstLvalue) {
     FUTURE_SUCCESS_TEST([] { return Widget(1); },
-                        [](const Future<Widget>& fut) { ASSERT_EQ(fut.getNoThrow(), 1); });
+                        [](const /*Future<Widget>*/ auto& fut) { ASSERT_EQ(fut.getNoThrow(), 1); });
 }
 
 TEST(Future_MoveOnly, Success_shared_getNothrow) {
     FUTURE_SUCCESS_TEST(
         [] { return Widget(1); },
-        [](Future<Widget>&& fut) { ASSERT_EQ(std::move(fut).share().getNoThrow(), 1); });
+        [](/*Future<Widget>*/ auto&& fut) { ASSERT_EQ(std::move(fut).share().getNoThrow(), 1); });
 }
 #endif
 
 TEST(Future_MoveOnly, Success_getNothrowRvalue) {
     FUTURE_SUCCESS_TEST([] { return Widget(1); },
-                        [](Future<Widget>&& fut) {
+                        [](/*Future<Widget>*/ auto&& fut) {
                             ASSERT_EQ(uassertStatusOK(std::move(fut).getNoThrow()).val, 1);
                         });
 }
 
 TEST(Future_MoveOnly, Success_getAsync) {
     FUTURE_SUCCESS_TEST([] { return Widget(1); },
-                        [](Future<Widget>&& fut) {
+                        [](/*Future<Widget>*/ auto&& fut) {
                             auto pf = makePromiseFuture<Widget>();
                             std::move(fut).getAsync([outside = std::move(pf.promise)](
                                 StatusWith<Widget> sw) mutable {
@@ -133,49 +140,57 @@ TEST(Future_MoveOnly, Success_getAsync) {
 }
 
 TEST(Future_MoveOnly, Fail_getLvalue) {
-    FUTURE_FAIL_TEST<Widget>([](Future<Widget>&& fut) { ASSERT_THROWS_failStatus(fut.get()); });
+    FUTURE_FAIL_TEST<Widget>(
+        [](/*Future<Widget>*/ auto&& fut) { ASSERT_THROWS_failStatus(fut.get()); });
 }
 
 TEST(Future_MoveOnly, Fail_getConstLvalue) {
     FUTURE_FAIL_TEST<Widget>(
-        [](const Future<Widget>& fut) { ASSERT_THROWS_failStatus(fut.get()); });
+        [](const /*Future<Widget>*/ auto& fut) { ASSERT_THROWS_failStatus(fut.get()); });
 }
 
 TEST(Future_MoveOnly, Fail_getRvalue) {
     FUTURE_FAIL_TEST<Widget>(
-        [](Future<Widget>&& fut) { ASSERT_THROWS_failStatus(std::move(fut).get()); });
+        [](/*Future<Widget>*/ auto&& fut) { ASSERT_THROWS_failStatus(std::move(fut).get()); });
+}
+
+TEST(Future_MoveOnly, Fail_semi_get) {
+    FUTURE_FAIL_TEST<Widget>([](/*Future<Widget>*/ auto&& fut) {
+        ASSERT_THROWS_failStatus(std::move(fut).semi().get());
+    });
 }
 
 TEST(Future_MoveOnly, Fail_shared_get) {
-    FUTURE_FAIL_TEST<Widget>(
-        [](Future<Widget>&& fut) { ASSERT_THROWS_failStatus(std::move(fut).share().get()); });
+    FUTURE_FAIL_TEST<Widget>([](/*Future<Widget>*/ auto&& fut) {
+        ASSERT_THROWS_failStatus(std::move(fut).share().get());
+    });
 }
 
 #if 0  // Needs copy
 TEST(Future_MoveOnly, Fail_getNothrowLvalue) {
-    FUTURE_FAIL_TEST<Widget>([](Future<Widget>&& fut) { ASSERT_EQ(fut.getNoThrow(), failStatus); });
+    FUTURE_FAIL_TEST<Widget>([](/*Future<Widget>*/ auto&& fut) { ASSERT_EQ(fut.getNoThrow(), failStatus); });
 }
 
 TEST(Future_MoveOnly, Fail_getNothrowConstLvalue) {
     FUTURE_FAIL_TEST<Widget>(
-        [](const Future<Widget>& fut) { ASSERT_EQ(fut.getNoThrow(), failStatus); });
+        [](const /*Future<Widget>*/ auto& fut) { ASSERT_EQ(fut.getNoThrow(), failStatus); });
 }
 
 TEST(Future_MoveOnly, Fail_shared_getNothrow) {
-    FUTURE_FAIL_TEST<Widget>([](Future<Widget>&& fut) {
+    FUTURE_FAIL_TEST<Widget>([](/*Future<Widget>*/ auto&& fut) {
         ASSERT_EQ(std::move(fut).share().getNoThrow().getStatus(), failStatus());
     });
 }
 #endif
 
 TEST(Future_MoveOnly, Fail_getNothrowRvalue) {
-    FUTURE_FAIL_TEST<Widget>([](Future<Widget>&& fut) {
+    FUTURE_FAIL_TEST<Widget>([](/*Future<Widget>*/ auto&& fut) {
         ASSERT_EQ(std::move(fut).getNoThrow().getStatus(), failStatus());
     });
 }
 
 TEST(Future_MoveOnly, Fail_getAsync) {
-    FUTURE_FAIL_TEST<Widget>([](Future<Widget>&& fut) {
+    FUTURE_FAIL_TEST<Widget>([](/*Future<Widget>*/ auto&& fut) {
         auto pf = makePromiseFuture<Widget>();
         std::move(fut).getAsync([outside = std::move(pf.promise)](StatusWith<Widget> sw) mutable {
             ASSERT(!sw.isOK());
@@ -187,21 +202,21 @@ TEST(Future_MoveOnly, Fail_getAsync) {
 
 TEST(Future_MoveOnly, Success_thenSimple) {
     FUTURE_SUCCESS_TEST([] { return Widget(1); },
-                        [](Future<Widget>&& fut) {
+                        [](/*Future<Widget>*/ auto&& fut) {
                             ASSERT_EQ(std::move(fut).then([](Widget i) { return i + 2; }).get(), 3);
                         });
 }
 
 TEST(Future_MoveOnly, Success_thenSimpleAuto) {
     FUTURE_SUCCESS_TEST([] { return Widget(1); },
-                        [](Future<Widget>&& fut) {
+                        [](/*Future<Widget>*/ auto&& fut) {
                             ASSERT_EQ(std::move(fut).then([](auto&& i) { return i + 2; }).get(), 3);
                         });
 }
 
 TEST(Future_MoveOnly, Success_thenVoid) {
     FUTURE_SUCCESS_TEST([] { return Widget(1); },
-                        [](Future<Widget>&& fut) {
+                        [](/*Future<Widget>*/ auto&& fut) {
                             ASSERT_EQ(std::move(fut)
                                           .then([](Widget i) { ASSERT_EQ(i, 1); })
                                           .then([] { return Widget(3); })
@@ -212,7 +227,7 @@ TEST(Future_MoveOnly, Success_thenVoid) {
 
 TEST(Future_MoveOnly, Success_thenStatus) {
     FUTURE_SUCCESS_TEST([] { return Widget(1); },
-                        [](Future<Widget>&& fut) {
+                        [](/*Future<Widget>*/ auto&& fut) {
                             ASSERT_EQ(std::move(fut)
                                           .then([](Widget i) {
                                               ASSERT_EQ(i, 1);
@@ -226,10 +241,12 @@ TEST(Future_MoveOnly, Success_thenStatus) {
 
 TEST(Future_MoveOnly, Success_thenError_Status) {
     FUTURE_SUCCESS_TEST([] { return Widget(1); },
-                        [](Future<Widget>&& fut) {
+                        [](/*Future<Widget>*/ auto&& fut) {
                             auto fut2 = std::move(fut).then(
                                 [](Widget i) { return Status(ErrorCodes::BadValue, "oh no!"); });
-                            MONGO_STATIC_ASSERT(std::is_same<decltype(fut2), Future<void>>::value);
+                            static_assert(future_details::isFutureLike<decltype(fut2)>);
+                            static_assert(
+                                std::is_same_v<typename decltype(fut2)::value_type, void>);
                             ASSERT_EQ(fut2.getNoThrow(), ErrorCodes::BadValue);
                         });
 }
@@ -237,10 +254,11 @@ TEST(Future_MoveOnly, Success_thenError_Status) {
 TEST(Future_MoveOnly, Success_thenError_StatusWith) {
     FUTURE_SUCCESS_TEST(
         [] { return Widget(1); },
-        [](Future<Widget>&& fut) {
+        [](/*Future<Widget>*/ auto&& fut) {
             auto fut2 = std::move(fut).then(
                 [](Widget i) { return StatusWith<double>(ErrorCodes::BadValue, "oh no!"); });
-            MONGO_STATIC_ASSERT(std::is_same<decltype(fut2), Future<double>>::value);
+            static_assert(future_details::isFutureLike<decltype(fut2)>);
+            static_assert(std::is_same_v<typename decltype(fut2)::value_type, double>);
             ASSERT_EQ(fut2.getNoThrow(), ErrorCodes::BadValue);
         });
 }
@@ -248,7 +266,7 @@ TEST(Future_MoveOnly, Success_thenError_StatusWith) {
 TEST(Future_MoveOnly, Success_thenFutureImmediate) {
     FUTURE_SUCCESS_TEST(
         [] { return Widget(1); },
-        [](Future<Widget>&& fut) {
+        [](/*Future<Widget>*/ auto&& fut) {
             ASSERT_EQ(std::move(fut)
                           .then([](Widget i) { return Future<Widget>::makeReady(Widget(i + 2)); })
                           .get(),
@@ -258,7 +276,7 @@ TEST(Future_MoveOnly, Success_thenFutureImmediate) {
 
 TEST(Future_MoveOnly, Success_thenFutureReady) {
     FUTURE_SUCCESS_TEST([] { return Widget(1); },
-                        [](Future<Widget>&& fut) {
+                        [](/*Future<Widget>*/ auto&& fut) {
                             ASSERT_EQ(std::move(fut)
                                           .then([](Widget i) {
                                               auto pf = makePromiseFuture<Widget>();
@@ -272,7 +290,7 @@ TEST(Future_MoveOnly, Success_thenFutureReady) {
 
 TEST(Future_MoveOnly, Success_thenFutureAsync) {
     FUTURE_SUCCESS_TEST([] { return Widget(1); },
-                        [](Future<Widget>&& fut) {
+                        [](/*Future<Widget>*/ auto&& fut) {
                             ASSERT_EQ(std::move(fut)
                                           .then([&](Widget i) {
                                               return async([i = i.val] { return Widget(i + 2); });
@@ -282,9 +300,22 @@ TEST(Future_MoveOnly, Success_thenFutureAsync) {
                         });
 }
 
+TEST(Future_MoveOnly, Success_thenSemiFutureAsync) {
+    FUTURE_SUCCESS_TEST([] { return Widget(1); },
+                        [](/*Future<Widget>*/ auto&& fut) {
+                            ASSERT_EQ(
+                                std::move(fut)
+                                    .then([&](Widget i) {
+                                        return async([i = i.val] { return Widget(i + 2); }).semi();
+                                    })
+                                    .get(),
+                                3);
+                        });
+}
+
 TEST(Future_MoveOnly, Success_thenFutureAsyncThrow) {
     FUTURE_SUCCESS_TEST([] { return Widget(1); },
-                        [](Future<Widget>&& fut) {
+                        [](/*Future<Widget>*/ auto&& fut) {
                             ASSERT_EQ(std::move(fut)
                                           .then([](Widget i) {
                                               uasserted(ErrorCodes::BadValue, "oh no!");
@@ -296,7 +327,7 @@ TEST(Future_MoveOnly, Success_thenFutureAsyncThrow) {
 }
 
 TEST(Future_MoveOnly, Fail_thenSimple) {
-    FUTURE_FAIL_TEST<Widget>([](Future<Widget>&& fut) {
+    FUTURE_FAIL_TEST<Widget>([](/*Future<Widget>*/ auto&& fut) {
         ASSERT_EQ(std::move(fut)
                       .then([](Widget i) {
                           FAIL("then() callback was called");
@@ -308,7 +339,7 @@ TEST(Future_MoveOnly, Fail_thenSimple) {
 }
 
 TEST(Future_MoveOnly, Fail_thenFutureAsync) {
-    FUTURE_FAIL_TEST<Widget>([](Future<Widget>&& fut) {
+    FUTURE_FAIL_TEST<Widget>([](/*Future<Widget>*/ auto&& fut) {
         ASSERT_EQ(std::move(fut)
                       .then([](Widget i) {
                           FAIL("then() callback was called");
@@ -321,7 +352,7 @@ TEST(Future_MoveOnly, Fail_thenFutureAsync) {
 
 TEST(Future_MoveOnly, Success_onErrorSimple) {
     FUTURE_SUCCESS_TEST([] { return Widget(1); },
-                        [](Future<Widget>&& fut) {
+                        [](/*Future<Widget>*/ auto&& fut) {
                             ASSERT_EQ(std::move(fut)
                                           .onError([](Status) {
                                               FAIL("onError() callback was called");
@@ -335,7 +366,7 @@ TEST(Future_MoveOnly, Success_onErrorSimple) {
 
 TEST(Future_MoveOnly, Success_onErrorFutureAsync) {
     FUTURE_SUCCESS_TEST([] { return Widget(1); },
-                        [](Future<Widget>&& fut) {
+                        [](/*Future<Widget>*/ auto&& fut) {
                             ASSERT_EQ(std::move(fut)
                                           .onError([](Status) {
                                               FAIL("onError() callback was called");
@@ -348,7 +379,7 @@ TEST(Future_MoveOnly, Success_onErrorFutureAsync) {
 }
 
 TEST(Future_MoveOnly, Fail_onErrorSimple) {
-    FUTURE_FAIL_TEST<Widget>([](Future<Widget>&& fut) {
+    FUTURE_FAIL_TEST<Widget>([](/*Future<Widget>*/ auto&& fut) {
         ASSERT_EQ(uassertStatusOK(std::move(fut)
                                       .onError([](Status s) {
                                           ASSERT_EQ(s, failStatus());
@@ -359,7 +390,7 @@ TEST(Future_MoveOnly, Fail_onErrorSimple) {
     });
 }
 TEST(Future_MoveOnly, Fail_onErrorError_throw) {
-    FUTURE_FAIL_TEST<Widget>([](Future<Widget>&& fut) {
+    FUTURE_FAIL_TEST<Widget>([](/*Future<Widget>*/ auto&& fut) {
         auto fut2 = std::move(fut).onError([](Status s) -> Widget {
             ASSERT_EQ(s, failStatus());
             uasserted(ErrorCodes::BadValue, "oh no!");
@@ -369,7 +400,7 @@ TEST(Future_MoveOnly, Fail_onErrorError_throw) {
 }
 
 TEST(Future_MoveOnly, Fail_onErrorError_StatusWith) {
-    FUTURE_FAIL_TEST<Widget>([](Future<Widget>&& fut) {
+    FUTURE_FAIL_TEST<Widget>([](/*Future<Widget>*/ auto&& fut) {
         auto fut2 = std::move(fut).onError([](Status s) {
             ASSERT_EQ(s, failStatus());
             return StatusWith<Widget>(ErrorCodes::BadValue, "oh no!");
@@ -379,7 +410,7 @@ TEST(Future_MoveOnly, Fail_onErrorError_StatusWith) {
 }
 
 TEST(Future_MoveOnly, Fail_onErrorFutureImmediate) {
-    FUTURE_FAIL_TEST<Widget>([](Future<Widget>&& fut) {
+    FUTURE_FAIL_TEST<Widget>([](/*Future<Widget>*/ auto&& fut) {
         ASSERT_EQ(std::move(fut)
                       .onError([](Status s) {
                           ASSERT_EQ(s, failStatus());
@@ -391,7 +422,7 @@ TEST(Future_MoveOnly, Fail_onErrorFutureImmediate) {
 }
 
 TEST(Future_MoveOnly, Fail_onErrorFutureReady) {
-    FUTURE_FAIL_TEST<Widget>([](Future<Widget>&& fut) {
+    FUTURE_FAIL_TEST<Widget>([](/*Future<Widget>*/ auto&& fut) {
         ASSERT_EQ(std::move(fut)
                       .onError([](Status s) {
                           ASSERT_EQ(s, failStatus());
@@ -405,7 +436,7 @@ TEST(Future_MoveOnly, Fail_onErrorFutureReady) {
 }
 
 TEST(Future_MoveOnly, Fail_onErrorFutureAsync) {
-    FUTURE_FAIL_TEST<Widget>([](Future<Widget>&& fut) {
+    FUTURE_FAIL_TEST<Widget>([](/*Future<Widget>*/ auto&& fut) {
         ASSERT_EQ(std::move(fut)
                       .onError([&](Status s) {
                           ASSERT_EQ(s, failStatus());
@@ -417,25 +448,26 @@ TEST(Future_MoveOnly, Fail_onErrorFutureAsync) {
 }
 
 TEST(Future_MoveOnly, Success_tap) {
-    FUTURE_SUCCESS_TEST([] { return Widget(1); },
-                        [](Future<Widget>&& fut) {
-                            bool tapCalled = false;
-                            ASSERT_EQ(std::move(fut)
-                                          .tap([&tapCalled](const Widget& i) {
-                                              ASSERT_EQ(i, 1);
-                                              tapCalled = true;
-                                          })
-                                          .then([](Widget i) { return i + 2; })
-                                          .get(),
-                                      3);
-                            ASSERT(tapCalled);
-                        });
+    FUTURE_SUCCESS_TEST<kNoExecutorFuture_needsTap>(
+        [] { return Widget(1); },
+        [](/*Future<Widget>*/ auto&& fut) {
+            bool tapCalled = false;
+            ASSERT_EQ(std::move(fut)
+                          .tap([&tapCalled](const Widget& i) {
+                              ASSERT_EQ(i, 1);
+                              tapCalled = true;
+                          })
+                          .then([](Widget i) { return i + 2; })
+                          .get(),
+                      3);
+            ASSERT(tapCalled);
+        });
 }
 
 TEST(Future_MoveOnly, Success_tapError) {
-    FUTURE_SUCCESS_TEST(
+    FUTURE_SUCCESS_TEST<kNoExecutorFuture_needsTap>(
         [] { return Widget(1); },
-        [](Future<Widget>&& fut) {
+        [](/*Future<Widget>*/ auto&& fut) {
             ASSERT_EQ(std::move(fut)
                           .tapError([](Status s) { FAIL("tapError() callback was called"); })
                           .then([](Widget i) { return i + 2; })
@@ -446,47 +478,25 @@ TEST(Future_MoveOnly, Success_tapError) {
 
 #if 0  // Needs copy
 TEST(Future_MoveOnly, Success_tapAll_StatusWith) {
-    FUTURE_SUCCESS_TEST([]{return Widget(1);}, [](Future<Widget>&& fut) {
-        bool tapCalled = false;
-        ASSERT_EQ(std::move(fut)
-                      .tapAll([&tapCalled](StatusWith<Widget> sw) {
-                          ASSERT_EQ(uassertStatusOK(sw).val, 1);
-                          tapCalled = true;
-                      })
-                      .then([](Widget i) { return i + 2; })
-                      .get(),
-                  3);
-        ASSERT(tapCalled);
-    });
+    FUTURE_SUCCESS_TEST<kNoExecutorFuture_needsTap>(
+        [] { return Widget(1); },
+        [](/*Future<Widget>*/ auto&& fut) {
+            bool tapCalled = false;
+            ASSERT_EQ(std::move(fut)
+                          .tapAll([&tapCalled](StatusWith<Widget> sw) {
+                              ASSERT_EQ(uassertStatusOK(sw).val, 1);
+                              tapCalled = true;
+                          })
+                          .then([](Widget i) { return i + 2; })
+                          .get(),
+                      3);
+            ASSERT(tapCalled);
+        });
 }
 #endif
 
-TEST(Future_MoveOnly, Success_tapAll_Overloaded) {
-    FUTURE_SUCCESS_TEST([] { return Widget(1); },
-                        [](Future<Widget>&& fut) {
-                            struct Callback {
-                                void operator()(const Widget& i) {
-                                    ASSERT_EQ(i, 1);
-                                    called = true;
-                                }
-                                void operator()(Status status) {
-                                    FAIL("Status overload called with ") << status;
-                                }
-                                bool called = false;
-                            };
-                            Callback callback;
-
-                            ASSERT_EQ(std::move(fut)
-                                          .tapAll(std::ref(callback))
-                                          .then([](Widget i) { return i + 2; })
-                                          .get(),
-                                      3);
-                            ASSERT(callback.called);
-                        });
-}
-
 TEST(Future_MoveOnly, Fail_tap) {
-    FUTURE_FAIL_TEST<Widget>([](Future<Widget>&& fut) {
+    FUTURE_FAIL_TEST<Widget, kNoExecutorFuture_needsTap>([](/*Future<Widget>*/ auto&& fut) {
         ASSERT_EQ(std::move(fut)
                       .tap([](const Widget& i) { FAIL("tap() callback was called"); })
                       .onError([](Status s) {
@@ -499,7 +509,7 @@ TEST(Future_MoveOnly, Fail_tap) {
 }
 
 TEST(Future_MoveOnly, Fail_tapError) {
-    FUTURE_FAIL_TEST<Widget>([](Future<Widget>&& fut) {
+    FUTURE_FAIL_TEST<Widget, kNoExecutorFuture_needsTap>([](/*Future<Widget>*/ auto&& fut) {
         bool tapCalled = false;
         ASSERT_EQ(std::move(fut)
                       .tapError([&tapCalled](Status s) {
@@ -518,7 +528,7 @@ TEST(Future_MoveOnly, Fail_tapError) {
 
 #if 0  // Needs copy
 TEST(Future_MoveOnly, Fail_tapAll_StatusWith) {
-    FUTURE_FAIL_TEST<Widget>( [](Future<Widget>&& fut) {
+    FUTURE_FAIL_TEST<Widget, kNoExecutorFuture_needsTap>( [](/*Future<Widget>*/ auto&& fut) {
         bool tapCalled = false;
         ASSERT_EQ(std::move(fut)
                       .tapAll([&tapCalled](StatusWith<Widget> sw) {
@@ -536,37 +546,10 @@ TEST(Future_MoveOnly, Fail_tapAll_StatusWith) {
 }
 #endif
 
-TEST(Future_MoveOnly, Fail_tapAll_Overloaded) {
-    FUTURE_FAIL_TEST<Widget>([](Future<Widget>&& fut) {
-        struct Callback {
-            void operator()(const Widget& i) {
-                FAIL("Widget overload called with ") << i;
-            }
-            void operator()(Status status) {
-                ASSERT_EQ(status, failStatus());
-                called = true;
-            }
-            bool called = false;
-        };
-        Callback callback;
-
-        ASSERT_EQ(std::move(fut)
-                      .tapAll(std::ref(callback))
-                      .onError([](Status s) {
-                          ASSERT_EQ(s, failStatus());
-                          return Widget(3);
-                      })
-                      .get(),
-                  3);
-
-        ASSERT(callback.called);
-    });
-}
-
 TEST(Future_MoveOnly, Success_onCompletionSimple) {
     FUTURE_SUCCESS_TEST(
         [] { return Widget(1); },
-        [](Future<Widget>&& fut) {
+        [](/*Future<Widget>*/ auto&& fut) {
             ASSERT_EQ(std::move(fut)
                           .onCompletion([](StatusWith<Widget> i) { return i.getValue() + 2; })
                           .get(),
@@ -574,31 +557,10 @@ TEST(Future_MoveOnly, Success_onCompletionSimple) {
         });
 }
 
-TEST(Future_MoveOnly, Success_onCompletionMultiOverload) {
-    FUTURE_SUCCESS_TEST([] { return Widget(1); },
-                        [](Future<Widget>&& fut) {
-                            struct Callback {
-                                Widget operator()(const Widget& i) {
-                                    called = true;
-                                    return i + 2;
-                                }
-                                Widget operator()(Status status) {
-                                    MONGO_UNREACHABLE;
-                                }
-                                bool called = false;
-                            };
-                            Callback callback;
-
-                            ASSERT_EQ(std::move(fut).onCompletion(std::ref(callback)).get(), 3);
-
-                            ASSERT(callback.called);
-                        });
-}
-
 TEST(Future_MoveOnly, Success_onCompletionVoid) {
     FUTURE_SUCCESS_TEST(
         [] { return Widget(1); },
-        [](Future<Widget>&& fut) {
+        [](/*Future<Widget>*/ auto&& fut) {
             ASSERT_EQ(std::move(fut)
                           .onCompletion([](StatusWith<Widget> i) { ASSERT_EQ(i.getValue(), 1); })
                           .onCompletion([](Status s) {
@@ -612,7 +574,7 @@ TEST(Future_MoveOnly, Success_onCompletionVoid) {
 
 TEST(Future_MoveOnly, Success_onCompletionStatus) {
     FUTURE_SUCCESS_TEST([] { return Widget(1); },
-                        [](Future<Widget>&& fut) {
+                        [](/*Future<Widget>*/ auto&& fut) {
                             ASSERT_EQ(std::move(fut)
                                           .onCompletion([](StatusWith<Widget> i) {
                                               ASSERT_EQ(i.getValue(), 1);
@@ -628,31 +590,33 @@ TEST(Future_MoveOnly, Success_onCompletionStatus) {
 }
 
 TEST(Future_MoveOnly, Success_onCompletionError_Status) {
-    FUTURE_SUCCESS_TEST([] { return Widget(1); },
-                        [](Future<Widget>&& fut) {
-                            auto fut2 = std::move(fut).onCompletion([](StatusWith<Widget> i) {
-                                return Status(ErrorCodes::BadValue, "oh no!");
-                            });
-                            MONGO_STATIC_ASSERT(std::is_same<decltype(fut2), Future<void>>::value);
-                            ASSERT_EQ(fut2.getNoThrow(), ErrorCodes::BadValue);
-                        });
+    FUTURE_SUCCESS_TEST(
+        [] { return Widget(1); },
+        [](/*Future<Widget>*/ auto&& fut) {
+            auto fut2 = std::move(fut).onCompletion(
+                [](StatusWith<Widget> i) { return Status(ErrorCodes::BadValue, "oh no!"); });
+            static_assert(future_details::isFutureLike<decltype(fut2)>);
+            static_assert(std::is_same_v<typename decltype(fut2)::value_type, void>);
+            ASSERT_EQ(fut2.getNoThrow(), ErrorCodes::BadValue);
+        });
 }
 
 TEST(Future_MoveOnly, Success_onCompletionError_StatusWith) {
     FUTURE_SUCCESS_TEST([] { return Widget(1); },
-                        [](Future<Widget>&& fut) {
+                        [](/*Future<Widget>*/ auto&& fut) {
                             auto fut2 = std::move(fut).onCompletion([](StatusWith<Widget> i) {
                                 return StatusWith<double>(ErrorCodes::BadValue, "oh no!");
                             });
-                            MONGO_STATIC_ASSERT(
-                                std::is_same<decltype(fut2), Future<double>>::value);
+                            static_assert(future_details::isFutureLike<decltype(fut2)>);
+                            static_assert(
+                                std::is_same_v<typename decltype(fut2)::value_type, double>);
                             ASSERT_EQ(fut2.getNoThrow(), ErrorCodes::BadValue);
                         });
 }
 
 TEST(Future_MoveOnly, Success_onCompletionFutureImmediate) {
     FUTURE_SUCCESS_TEST([] { return Widget(1); },
-                        [](Future<Widget>&& fut) {
+                        [](/*Future<Widget>*/ auto&& fut) {
                             ASSERT_EQ(std::move(fut)
                                           .onCompletion([](StatusWith<Widget> i) {
                                               return Future<Widget>::makeReady(
@@ -665,7 +629,7 @@ TEST(Future_MoveOnly, Success_onCompletionFutureImmediate) {
 
 TEST(Future_MoveOnly, Success_onCompletionFutureReady) {
     FUTURE_SUCCESS_TEST([] { return Widget(1); },
-                        [](Future<Widget>&& fut) {
+                        [](/*Future<Widget>*/ auto&& fut) {
                             ASSERT_EQ(std::move(fut)
                                           .onCompletion([](StatusWith<Widget> i) {
                                               auto pf = makePromiseFuture<Widget>();
@@ -679,7 +643,7 @@ TEST(Future_MoveOnly, Success_onCompletionFutureReady) {
 
 TEST(Future_MoveOnly, Success_onCompletionFutureAsync) {
     FUTURE_SUCCESS_TEST([] { return Widget(1); },
-                        [](Future<Widget>&& fut) {
+                        [](/*Future<Widget>*/ auto&& fut) {
                             ASSERT_EQ(std::move(fut)
                                           .onCompletion([&](StatusWith<Widget> i) {
                                               return async(
@@ -692,7 +656,7 @@ TEST(Future_MoveOnly, Success_onCompletionFutureAsync) {
 
 TEST(Future_MoveOnly, Success_onCompletionFutureAsyncThrow) {
     FUTURE_SUCCESS_TEST([] { return Widget(1); },
-                        [](Future<Widget>&& fut) {
+                        [](/*Future<Widget>*/ auto&& fut) {
                             ASSERT_EQ(std::move(fut)
                                           .onCompletion([](StatusWith<Widget> i) {
                                               uasserted(ErrorCodes::BadValue, "oh no!");
@@ -704,7 +668,7 @@ TEST(Future_MoveOnly, Success_onCompletionFutureAsyncThrow) {
 }
 
 TEST(Future_MoveOnly, Fail_onCompletionSimple) {
-    FUTURE_FAIL_TEST<Widget>([](Future<Widget>&& fut) {
+    FUTURE_FAIL_TEST<Widget>([](/*Future<Widget>*/ auto&& fut) {
         ASSERT_EQ(std::move(fut)
                       .onCompletion([](StatusWith<Widget> i) {
                           ASSERT_NOT_OK(i);
@@ -716,7 +680,7 @@ TEST(Future_MoveOnly, Fail_onCompletionSimple) {
 }
 
 TEST(Future_MoveOnly, Fail_onCompletionFutureAsync) {
-    FUTURE_FAIL_TEST<Widget>([](Future<Widget>&& fut) {
+    FUTURE_FAIL_TEST<Widget>([](/*Future<Widget>*/ auto&& fut) {
         ASSERT_EQ(std::move(fut)
                       .onCompletion([](StatusWith<Widget> i) {
                           ASSERT_NOT_OK(i);
@@ -728,7 +692,7 @@ TEST(Future_MoveOnly, Fail_onCompletionFutureAsync) {
 }
 
 TEST(Future_MoveOnly, Fail_onCompletionError_throw) {
-    FUTURE_FAIL_TEST<Widget>([](Future<Widget>&& fut) {
+    FUTURE_FAIL_TEST<Widget>([](/*Future<Widget>*/ auto&& fut) {
         auto fut2 = std::move(fut).onCompletion([](StatusWith<Widget> s) -> Widget {
             ASSERT_EQ(s.getStatus(), failStatus());
             uasserted(ErrorCodes::BadValue, "oh no!");
@@ -738,7 +702,7 @@ TEST(Future_MoveOnly, Fail_onCompletionError_throw) {
 }
 
 TEST(Future_MoveOnly, Fail_onCompletionError_StatusWith) {
-    FUTURE_FAIL_TEST<Widget>([](Future<Widget>&& fut) {
+    FUTURE_FAIL_TEST<Widget>([](/*Future<Widget>*/ auto&& fut) {
         auto fut2 = std::move(fut).onCompletion([](StatusWith<Widget> s) {
             ASSERT_EQ(s.getStatus(), failStatus());
             return StatusWith<Widget>(ErrorCodes::BadValue, "oh no!");
@@ -748,7 +712,7 @@ TEST(Future_MoveOnly, Fail_onCompletionError_StatusWith) {
 }
 
 TEST(Future_MoveOnly, Fail_onCompletionFutureImmediate) {
-    FUTURE_FAIL_TEST<Widget>([](Future<Widget>&& fut) {
+    FUTURE_FAIL_TEST<Widget>([](/*Future<Widget>*/ auto&& fut) {
         ASSERT_EQ(std::move(fut)
                       .onCompletion([](StatusWith<Widget> s) {
                           ASSERT_EQ(s.getStatus(), failStatus());
@@ -760,7 +724,7 @@ TEST(Future_MoveOnly, Fail_onCompletionFutureImmediate) {
 }
 
 TEST(Future_MoveOnly, Fail_onCompletionFutureReady) {
-    FUTURE_FAIL_TEST<Widget>([](Future<Widget>&& fut) {
+    FUTURE_FAIL_TEST<Widget>([](/*Future<Widget>*/ auto&& fut) {
         ASSERT_EQ(std::move(fut)
                       .onCompletion([](StatusWith<Widget> s) {
                           ASSERT_EQ(s.getStatus(), failStatus());