diff --git a/src/mongo/db/query/optimizer/algebra/algebra_test.cpp b/src/mongo/db/query/optimizer/algebra/algebra_test.cpp
index 0f4964eacf..fd761ab838 100644
--- a/src/mongo/db/query/optimizer/algebra/algebra_test.cpp
+++ b/src/mongo/db/query/optimizer/algebra/algebra_test.cpp
@@ -30,6 +30,7 @@
 #include "mongo/db/query/optimizer/algebra/operator.h"
 #include "mongo/db/query/optimizer/algebra/polyvalue.h"
 #include "mongo/unittest/unittest.h"
+#include "mongo/util/visit_helper.h"
 
 namespace mongo::optimizer::algebra {
 
@@ -549,5 +550,81 @@ TEST(PolyValueTest, WalkerBasic) {
     ASSERT(walk<false>(tree.cast<BinaryNode>()->get<1>(), walker));
 }
 
+TEST(PolyValueTest, LambdaIsLeaf) {
+    auto tree = Tree::make<BinaryNode>(Tree::make<Leaf>(1.0), Tree::make<Leaf>(2.0));
+
+    ASSERT(
+        !walk<false>(tree,
+                     visit_helper::Overloaded{
+                         [](AtLeastBinaryNode&, std::vector<Tree>&, Tree&, Tree&) { return false; },
+                         [](Leaf&) { return true; },
+                         [](BinaryNode&, Tree&, Tree&) { return false; },
+                         [](NaryNode&, std::vector<Tree>&) { return false; }}));
+    ASSERT(
+        walk<false>(tree.cast<BinaryNode>()->get<0>(),
+                    visit_helper::Overloaded{
+                        [](AtLeastBinaryNode&, std::vector<Tree>&, Tree&, Tree&) { return false; },
+                        [](Leaf&) { return true; },
+                        [](BinaryNode&, Tree&, Tree&) { return false; },
+                        [](NaryNode&, std::vector<Tree>&) { return false; }}));
+}
+
+TEST(PolyValueTest, LambdaWithDefault) {
+    auto tree = Tree::make<Leaf>(42);
+    ASSERT_EQ(42,
+              walk<false>(tree,
+                          visit_helper::Overloaded{
+                              [](auto&& node, ...) { return 42; },
+                          }));
+    ASSERT_EQ(42.0,
+              walk<false>(tree,
+                          visit_helper::Overloaded{
+                              [](Leaf& node) { return node.x; },
+                              [](auto&& node, ...) { return 43.0; },
+                          }));
+}
+
+TEST(PolyValueTest, LambdaCountLeafs) {
+    auto tree = Tree::make<BinaryNode>(Tree::make<Leaf>(1.0), Tree::make<Leaf>(2.0));
+
+    auto count = 0;
+    transport<false>(tree, visit_helper::Overloaded{[&](Leaf&) { count++; }, [](auto&&, ...) {}});
+    ASSERT_EQ(2, count);
+
+    // Now include the initial reference to the tree itself.
+    count = 0;
+    transport<true>(tree,
+                    visit_helper::Overloaded{[&](Tree&, Leaf&) { count++; }, [](auto&&, ...) {}});
+    ASSERT_EQ(2, count);
+}
+
+TEST(PolyValueTest, LambdaWithReturnType) {
+    auto tree = Tree::make<BinaryNode>(Tree::make<Leaf>(1.0), Tree::make<Leaf>(2.0));
+
+    double res = transport<false>(
+        tree,
+        visit_helper::Overloaded{
+            [](Leaf& node) { return node.x; },
+            [](BinaryNode& node, double child0, double child1) { return child0 + child1; },
+            [](auto&&, ...) { return 0.0; }});
+    ASSERT_EQ(3.0, res);
+}
+
+TEST(PolyValueTest, LambdaWithExtraArg) {
+    auto tree = Tree::make<BinaryNode>(Tree::make<Leaf>(1.0), Tree::make<Leaf>(2.0));
+
+    double multArg = 2.0;
+    double res =
+        transport<false>(tree,
+                         visit_helper::Overloaded{
+                             [](Leaf& node, double multiplier) { return node.x * multiplier; },
+                             [](BinaryNode& node, double multiplier, double child0, double child1) {
+                                 return (child0 + child1) * multiplier;
+                             },
+                             [](auto&&, ...) { return 0.0; }},
+                         multArg);
+    ASSERT_EQ((1.0 * multArg + 2.0 * multArg) * multArg, res);
+}
+
 }  // namespace
 }  // namespace mongo::optimizer::algebra
diff --git a/src/mongo/db/query/optimizer/algebra/operator.h b/src/mongo/db/query/optimizer/algebra/operator.h
index e09c00580c..39b7ba562e 100644
--- a/src/mongo/db/query/optimizer/algebra/operator.h
+++ b/src/mongo/db/query/optimizer/algebra/operator.h
@@ -29,9 +29,11 @@
 
 #pragma once
 
+#include <iostream>
 #include <vector>
 
 #include "mongo/db/query/optimizer/algebra/polyvalue.h"
+#include "mongo/util/concepts.h"
 
 namespace mongo::optimizer {
 namespace algebra {
@@ -67,17 +69,18 @@ class OpSpecificArity : public OpNodeStorage<Slot, Arity> {
     using Base = OpNodeStorage<Slot, Arity>;
 
 public:
-    template <typename... Ts>
-    OpSpecificArity(Ts&&... vals) : Base({std::forward<Ts>(vals)...}) {
-        static_assert(sizeof...(Ts) == Arity, "constructor paramaters do not match");
-    }
+    TEMPLATE(typename... Ts)
+    REQUIRES(sizeof...(Ts) == Arity)
+    OpSpecificArity(Ts&&... vals) : Base({std::forward<Ts>(vals)...}) {}
 
-    template <int I, std::enable_if_t<(I >= 0 && I < Arity), int> = 0>
+    TEMPLATE(int I)
+    REQUIRES(I >= 0 && I < Arity)
     auto& get() noexcept {
         return this->_nodes[I];
     }
 
-    template <int I, std::enable_if_t<(I >= 0 && I < Arity), int> = 0>
+    TEMPLATE(int I)
+    REQUIRES(I >= 0 && I < Arity)
     const auto& get() const noexcept {
         return this->_nodes[I];
     }
@@ -151,28 +154,61 @@ template <typename T>
 using OpConcreteType = typename std::remove_reference_t<T>::template get_t<0>;
 }  // namespace detail
 
+MONGO_MAKE_BOOL_TRAIT(IsCallable,
+                      (typename Func, typename... Args),
+                      (Func, Args...),
+                      (Func & fn, Args&&... args),
+                      //
+                      fn(std::forward<Args>(args)...));
+
 template <typename D, bool withSlot>
 class OpTransporter {
-    D& _domain;
+    D _domain;
 
-    template <typename T, bool B, typename... Args>
+    template <typename N, typename T, bool B, bool callable, typename... Args>
     struct Deducer {};
-    template <typename T, typename... Args>
-    struct Deducer<T, true, Args...> {
+
+    template <typename N, typename T, typename... Args>
+    struct Deducer<N, T, true, false, Args...> {
         using type =
-            decltype(std::declval<D>().transport(std::declval<T>(),
-                                                 std::declval<detail::OpConcreteType<T>&>(),
+            decltype(std::declval<D>().transport(std::declval<N>(),
+                                                 std::declval<detail::OpConcreteType<N>&>(),
                                                  std::declval<Args>()...));
     };
-    template <typename T, typename... Args>
-    struct Deducer<T, false, Args...> {
+
+    template <typename N, typename T, typename... Args>
+    struct Deducer<N, T, false, false, Args...> {
         using type = decltype(std::declval<D>().transport(
-            std::declval<detail::OpConcreteType<T>&>(), std::declval<Args>()...));
+            std::declval<detail::OpConcreteType<N>&>(), std::declval<Args>()...));
+    };
+
+    template <typename N, typename T, typename... Args>
+    struct Deducer<N, T, true, true, Args...> {
+        using type = decltype(std::declval<D>()(std::declval<N>(),
+                                                std::declval<detail::OpConcreteType<N>&>(),
+                                                std::declval<Args>()...));
+    };
+
+    template <typename N, typename T, typename... Args>
+    struct Deducer<N, T, false, true, Args...> {
+        using type = decltype(
+            std::declval<D>()(std::declval<detail::OpConcreteType<N>&>(), std::declval<Args>()...));
     };
-    template <typename T, typename... Args>
-    using deduced_t = typename Deducer<T, withSlot, Args...>::type;
+    template <typename N, typename T, typename... Args>
+    using deduced_t = typename Deducer<N, T, withSlot, IsCallable<D, T, Args...>, Args...>::type;
+
+    TEMPLATE(typename N, typename T, typename... Ts)
+    REQUIRES(IsCallable<D, T, Ts...>)
+    auto transformStep(N&& slot, T&& op, Ts&&... args) {
+        if constexpr (withSlot) {
+            return _domain(std::forward<N>(slot), std::forward<T>(op), std::forward<Ts>(args)...);
+        } else {
+            return _domain(std::forward<T>(op), std::forward<Ts>(args)...);
+        }
+    }
 
-    template <typename N, typename T, typename... Ts>
+    TEMPLATE(typename N, typename T, typename... Ts)
+    REQUIRES(!IsCallable<D, T, Ts...>)
     auto transformStep(N&& slot, T&& op, Ts&&... args) {
         if constexpr (withSlot) {
             return _domain.transport(
@@ -223,9 +259,9 @@ class OpTransporter {
     }
 
 public:
-    OpTransporter(D& domain) : _domain(domain) {}
+    OpTransporter(D&& domain) : _domain(std::forward<D>(domain)) {}
 
-    template <typename N, typename T, typename... Args, typename R = deduced_t<N, Args...>>
+    template <typename N, typename T, typename... Args, typename R = deduced_t<N, T, Args...>>
     R operator()(N&& slot, T&& op, Args&&... args) {
         // N is either `PolyValue<Ts...>&` or `const PolyValue<Ts...>&` i.e. reference
         // T is either `A&` or `const A&` where A is one of Ts
@@ -273,9 +309,20 @@ public:
 
 template <typename D, bool withSlot>
 class OpWalker {
-    D& _domain;
+    D _domain;
+
+    TEMPLATE(typename N, typename T, typename... Ts)
+    REQUIRES(std::is_invocable_v<D, T, Ts...>)
+    auto walkStep(N&& slot, T&& op, Ts&&... args) {
+        if constexpr (withSlot) {
+            return _domain(std::forward<N>(slot), std::forward<T>(op), std::forward<Ts>(args)...);
+        } else {
+            return _domain(std::forward<T>(op), std::forward<Ts>(args)...);
+        }
+    }
 
-    template <typename N, typename T, typename... Ts>
+    TEMPLATE(typename N, typename T, typename... Ts)
+    REQUIRES(!std::is_invocable_v<D, T, Ts...>)
     auto walkStep(N&& slot, T&& op, Ts&&... args) {
         if constexpr (withSlot) {
             return _domain.walk(
@@ -302,7 +349,7 @@ class OpWalker {
     }
 
 public:
-    OpWalker(D& domain) : _domain(domain) {}
+    OpWalker(D&& domain) : _domain(std::forward<D>(domain)) {}
 
     template <typename N, typename T, typename... Args>
     auto operator()(N&& slot, T&& op, Args&&... args) {
@@ -328,13 +375,14 @@ public:
 };
 
 template <bool withSlot = false, typename D, typename N, typename... Args>
-auto transport(N&& node, D& domain, Args&&... args) {
-    return node.visit(OpTransporter<D, withSlot>{domain}, std::forward<Args>(args)...);
+auto transport(N&& node, D&& domain, Args&&... args) {
+    return node.visit(OpTransporter<D, withSlot>{std::forward<D>(domain)},
+                      std::forward<Args>(args)...);
 }
 
 template <bool withSlot = false, typename D, typename N, typename... Args>
-auto walk(N&& node, D& domain, Args&&... args) {
-    return node.visit(OpWalker<D, withSlot>{domain}, std::forward<Args>(args)...);
+auto walk(N&& node, D&& domain, Args&&... args) {
+    return node.visit(OpWalker<D, withSlot>{std::forward<D>(domain)}, std::forward<Args>(args)...);
 }
 
 }  // namespace algebra