使用 C++ 中的参数包进行函数式编程

Question

这是对我遇到的另一个问题的简化，但它本身就很好。这个想法是在Scheme中实现类似于map和apply的功能原语。

回顾一下：在Scheme中，给定一个函数f，那么(apply f '(1 2 3))等价于(f 1 2 3)，(map f '(1 2 3))等价于((f 1) (f 2) (f 3))。

实现apply 是一件容易的事，还有很多其他问题说明了这是如何完成的：

template <class Func, class... Args, std::size_t... Ixs>
auto apply_helper(Func&& func, const tuple<Args...>& args,
                  index_sequence<Ixs...>)
    -> decltype(func(get<Ixs>(args)...))
{
  return forward<Func>(func)(get<Ixs>(forward<const tuple<Args...>&>(args))...);
}

template <class Func, class... Args,
          class Ixs = make_index_sequence<sizeof...(Args)>>
auto apply(Func&& func, const tuple<Args...>& args)
    -> decltype(apply_helper(func, args, Ixs()))
{
  return apply_helper(forward<Func>(func),
                      forward<const tuple<Args...>&>(args), Ixs());
}

void print3(int x, const char* s, float f) {
  cout << x << "," << s << "," << f << endl;
}

int main() {
  auto args = make_tuple(2, "Hello", 3.5);
  apply(print3, args);
}

现在实现map，这有点棘手。我们希望这样的东西能够工作，所以这是目标（这里使用mapcar 以避免与std::map 冲突）：

template <class Type>
bool print1(Type&& obj) {
  cout << obj;
  return true;
}

int main() {
  auto args = make_tuple(2, "Hello", 3.5);
  mapcar(print1, args);
}

传递print1 函数的其他替代方法也可以。

所以，如果我们对函数进行硬编码，下面的代码就可以正常工作：

template <class... Args, std::size_t... Ixs>
auto mapcar_helper(const tuple<Args...>& args,
                   index_sequence<Ixs...>)
    -> decltype(make_tuple(print1(get<Ixs>(args))...))
{
  return make_tuple(print1(get<Ixs>(forward<const tuple<Args...>&>(args)))...);
}

template <class... Args,
          class Ixs = make_index_sequence<sizeof...(Args)>>
auto mapcar(const tuple<Args...>& args)
    -> decltype(mapcar_helper(args, Ixs()))
{
  return mapcar_helper(forward<const tuple<Args...>&>(args), Ixs());
}

问题是我们如何推广此代码以接受任意名称作​​为输入并让它解析模板内的名称查找？仅仅添加一个模板参数是行不通的，因为它无法解决此时的函数重载。

我们想让上面的mapcar调用相当于代码：

make_tuple(print1(2), print1("Hello"), print1(3.5));

---

更新：最初的挑战之一是让它与 C++11 编译器一起工作，部分原因是我使用的是 GCC 4.8，但也因为我想研究如何做到这一点。基于 cmets，下面是一个示例，说明如何在没有多态 lambda（需要 C++ 14 编译器支持）的帮助下完成。

这并不像我想的那么简单，C++ 14 的特性会让它变得如此简单，但至少可以在给用户带来一点不便的情况下得到支持。

template <class Func, class... Args, std::size_t... Ixs>
auto mapcar_helper(Func&& func, const tuple<Args...>& args,
                   index_sequence<Ixs...>)
    -> decltype(make_tuple(func(get<Ixs>(args))...))
{
  return make_tuple(func(get<Ixs>(args))...);
}

template <class Func, class... Args,
          class Ixs = make_index_sequence<sizeof...(Args)>>
auto mapcar(Func&& func, const tuple<Args...>& args)
   -> decltype(mapcar_helper(func, args, Ixs())
{
  return mapcar_helper(forward<Func>(func), forward<decltype(args)>(args), Ixs());
}

为了能够传递模板“函数”，我们需要将它包装在一个对象中：

struct print1 {
  template <class Type> const Type& operator()(Type&& obj) {
    std::cout << obj << " ";
    return obj;
  }
};

现在可以将其传递给函数，类型查找将在参数包扩展点完成：

   mapcar(print1(), make_tuple(2, "Hello", 3.5));

Answer 1

template <typename F, class... Args, std::size_t... Ixs>
auto mapcar_helper(F f, const tuple<Args...>& args,
                   index_sequence<Ixs...>)
    -> decltype(make_tuple(f(get<Ixs>(args))...))
{
  return make_tuple(f(get<Ixs>(args))...);
}

template <typename F, class... Args,
          class Ixs = make_index_sequence<sizeof...(Args)>>
auto mapcar(F f, const tuple<Args...>& args)
    -> decltype(mapcar_helper(move(f), args, Ixs()))
{
  return mapcar_helper(move(f), args, Ixs());
}

然后你做：

mapcar([](auto&& obj) { return print1(std::forward<decltype(obj)>(obj)); }, args);

也许我没听懂这个问题。您需要将 print1 包装在 lambda 中，否则它会模棱两可；你想传递print1 的哪个实例化？

---

如果你没有宏观恐惧症，你可以使用宏来让它更优雅：

#define LIFT(F) ([&](auto&&... args) -> decltype(auto) { \
    return F(::std::forward<decltype(args)>(args)...);  \
})

那么你可以使用mapcar(LIFT(print1), args)。

---

这就是我编写自己的map 函数的方式：

template<typename F, class Tuple, std::size_t... Is>
auto map(Tuple&& tuple, F f, std::index_sequence<Is...>)
{
    using std::get;
    return std::tuple<decltype(f(get<Is>(std::forward<Tuple>(tuple))))...>{
        f(get<Is>(std::forward<Tuple>(tuple)))...
    };
}

template<typename F, class Tuple>
auto map(Tuple&& tuple, F f)
{
    using tuple_type = std::remove_reference_t<Tuple>;
    std::make_index_sequence<std::tuple_size<tuple_type>::value> seq;
    return (map)(std::forward<Tuple>(tuple), std::move(f), seq);
}

Answer 2

我错过了什么？

#include <iostream>
#include <string>


template<class F, class...Args>
void map(F&& f, Args&&...args)
{
    using expander = int[];
    (void) expander { 0, ((void) f(args), 0)... };
}

auto main() -> int
{
    using namespace std;

    map([](const auto& x) { cout << x << endl; }, 1, "hello"s, 4.3);

    return 0;
}

预期输出：

1
hello
4.3

请注意，在 c++17 中，map() 函数变得更讨人喜欢：

template<class F, class...Args>
void map(F&& f, Args&&...args)
{
    (f(args), ...);
}

如果您的下一个问题是“为什么要使用括号？”。答案是因为 折叠表达式 仅在表达式的上下文中进行评估。 f(arg1), f(arg2); 是一个声明。

参考：http://en.cppreference.com/w/cpp/language/fold