replace some lambdas with less-parameterized function objects

fbshipit-source-id: 78678cd0f18440a8ece264e83e303c568354bdaa

folly/experimental/pushmi/examples/include/bulk.h

@@ -7,35 +7,31 @@
 
 #include <pushmi/single_deferred.h>
 
-#if __cpp_deduction_guides >= 201703
-#define MAKE(x) x MAKE_
-#define MAKE_(...) {__VA_ARGS__}
-#else
-#define MAKE(x) make_ ## x
-#endif
-
 namespace pushmi {
 
 namespace operators {
 
-template<class F, class ShapeBegin, class ShapeEnd, class Target, class IF, class RS>
-auto bulk(
+PUSHMI_INLINE_VAR constexpr struct bulk_fn {
+  template<class F, class ShapeBegin, class ShapeEnd, class Target, class IF, class RS>
+  auto operator()(
       F&& func,
       ShapeBegin sb,
       ShapeEnd se,
       Target&& driver,
       IF&& initFunc,
-    RS&& selector) {
+      RS&& selector) const {
     return [func, sb, se, driver, initFunc, selector](auto in){
-          return MAKE(single_deferred)([in, func, sb, se, driver, initFunc, selector](auto out) mutable {
-              submit(in, MAKE(single)(std::move(out),
-                  [func, sb, se, driver, initFunc, selector](auto& out, auto input){
+      return make_single_deferred(
+        [in, func, sb, se, driver, initFunc, selector](auto out) mutable {
+          submit(in, make_single(std::move(out),
+              [func, sb, se, driver, initFunc, selector](auto& out, auto input) {
                 driver(initFunc, selector, std::move(input), func, sb, se, std::move(out));
               }
           ));
         });
     };
   }
+} bulk {};
 
 } // namespace operators
 

folly/experimental/pushmi/examples/include/for_each.h

@@ -11,22 +11,41 @@
 
 namespace pushmi {
 
-template<class ExecutionPolicy, class RandomAccessIterator, class Function>
-void for_each(
+PUSHMI_INLINE_VAR constexpr struct for_each_fn {
+private:
+  template <class Function>
+  struct fn {
+    Function f_;
+    template <class Cursor>
+    void operator()(detail::any, Cursor cursor) const {
+      f_(*cursor);
+    }
+  };
+  struct identity {
+    template <class T>
+    auto operator()(T&& t) const { return (T&&) t; }
+  };
+  struct zero {
+    int operator()(detail::any) const noexcept { return 0; }
+  };
+public:
+  template<class ExecutionPolicy, class RandomAccessIterator, class Function>
+  void operator()(
       ExecutionPolicy&& policy,
       RandomAccessIterator begin,
       RandomAccessIterator end,
-  Function f)
-{
+      Function f) const {
     operators::just(0) |
       operators::bulk(
-      [f](auto& acc, auto cursor){ f(*cursor); }, 
+        fn<Function>{f},
         begin,
         end,
         policy,
-      [](auto&& args){ return args; }, 
-      [](auto&& acc){ return 0; }) |
+        identity{},
+        zero{}
+      ) |
       operators::blocking_submit();
-}
+  }
+} for_each {};
 
 } // namespace pushmi

folly/experimental/pushmi/examples/include/no_fail.h

@@ -13,6 +13,11 @@ namespace detail {
 
 struct no_fail_fn {
 private:
+  struct on_error_impl {
+    void operator()(any, any) noexcept {
+      std::abort();
+    }
+  };
   template <class In>
   struct out_impl {
     PUSHMI_TEMPLATE(class Out)
@@ -20,9 +25,7 @@ private:
     auto operator()(Out out) const {
       return ::pushmi::detail::out_from_fn<In>()(
         std::move(out),
-        ::pushmi::on_error([](auto&, auto&&) noexcept {
-          std::abort();
-        })
+        ::pushmi::on_error(on_error_impl{})
       );
     }
   };

folly/experimental/pushmi/examples/include/pool.h

@@ -30,7 +30,7 @@ struct __pool_submit {
   PUSHMI_TEMPLATE(class TP, class Out)
     (requires Regular<TP> && Receiver<Out>)
   void operator()(TP at, Out out) const {
-    e.execute([e = this->e, at = std::move(at), out = std::move(out)]() mutable {
+    e.execute([e = e, at = std::move(at), out = std::move(out)]() mutable {
       auto tr = trampoline();
       ::pushmi::submit(tr, std::move(at), std::move(out));
     });

folly/experimental/pushmi/examples/include/reduce.h

@@ -11,22 +11,41 @@
 
 namespace pushmi {
 
-template<class ExecutionPolicy, class ForwardIt, class T, class BinaryOp>
-T reduce(
+PUSHMI_INLINE_VAR constexpr struct reduce_fn {
+private:
+  template <class BinaryOp>
+  struct fn {
+    BinaryOp binary_op_;
+    template <class Acc, class Cursor>
+    void operator()(Acc& acc, Cursor cursor) const {
+      acc = binary_op_(acc, *cursor);
+    }
+  };
+  struct identity {
+    template <class T>
+    auto operator()(T&& t) const {
+      return (T&&) t;
+    }
+  };
+public:
+  template<class ExecutionPolicy, class ForwardIt, class T, class BinaryOp>
+  T operator()(
     ExecutionPolicy&& policy,
     ForwardIt begin,
     ForwardIt end,
     T init,
-  BinaryOp binary_op){
+    BinaryOp binary_op) const {
       return operators::just(std::move(init)) |
         operators::bulk(
-        [binary_op](auto& acc, auto cursor){ acc = binary_op(acc, *cursor); }, 
+          fn<BinaryOp>{binary_op},
           begin,
           end,
           policy,
-        [](auto&& args){ return args; }, 
-        [](auto&& acc){ return acc; }) |
+          identity{},
+          identity{}
+        ) |
         operators::get<T>;
     }
+} reduce {};
 
 } // namespace pushmi