17 | 函数式编程：一种越来越流行的编程范式

Y-Combinator被你说高深了。递归就是自己调用自己。lamda表达式想递归，困难在于不知道自己的函数名，怎么办？调用不了自己，难道还调用不了别人。所以lamda表达式调用了Y-Combinator去间接调用自己，而Y-Combinator只不过：一，记录lamda表达式；二，转调lamda表达式。这就好比普京受制于连任时间限制，如果想继续连任，则找个代言人Y-Combinator继任。代言人的唯一作用就是到期传位普京。

参考 istream_line_reader 实现的，望老师斧正 template<typename _InIt, typename _Fun> class filter_view { public: class iterator { // 实现 InputIterator public: using iterator_category = input_iterator_tag; using value_type = typename _InIt::value_type; using difference_type = typename _InIt::difference_type; using pointer = typename _InIt::pointer; using reference = value_type&; iterator(_InIt _First, _InIt _Last, _Fun f) :_First(_First), _Last(_Last), _fun(f) { ++(*this); } reference operator*() const noexcept { return *_Cur; } pointer operator->() const noexcept { return &(*_Cur); } iterator& operator++() { while (_First != _Last && !_fun(*_First)) { _First++; } _Cur = _First; if (_First != _Last) { _First++; } return *this; } iterator operator++(int) { iterator temp(*this); ++(*this); return temp; } bool operator==(const iterator& rhs) const noexcept { return _Cur == rhs._Cur; } bool operator!=(const iterator& rhs) const noexcept { return !operator==(rhs); } private: _InIt _First; _InIt _Last; _InIt _Cur; _Fun _fun; }; filter_view(_InIt _First, _InIt _Last, _Fun f) :_First(_First), _Last(_Last), _fun(f) { } iterator begin() const noexcept { return iterator(_First, _Last, _fun); } iterator end() const noexcept { return iterator(_Last, _Last, _fun); } private: _InIt _First; _InIt _Last; _Fun _fun; };

调不了自己, 就调别人 auto factorial = [](int n) { auto F = [](auto f, int n) -> int { if (n == 0) return 1; else return n * f(f,n - 1); }; return F(F, n); };

吴老师，为什么c++不能在返回值优化，支持把rvalue通过move构造给一个lvalue引用。我想实现模板中的协变，函数返回local variable，只能通过声明返回值类型为引用和指针才能协变支持返回值多态。把一个生命周期短的variable自动move给返回值不是应该的吗？这个场景在工厂场景下应该很常见吧。 class Base{ } class Derive : public Base {} class Factory { Bae & create(){ return Base(); } class SubFactory : public Factory{ Base & create (){ return Derive(); } } 这里的返回值类型也有可能是泛型参数，现在看来只能用智能指针包一层，通过move构造返回，这看起来不太方便。 }

请问老师，map和reduce.那是最新的语句吗？还是有第三方库？那个TBB？

课后思考的一种实现，请老师指正一下其中存在的问题。 template <typename T = std::vector<int>> class filter_view { public: filter_view(){} filter_view(typename T::iterator begin, typename T::iterator end, std::function<bool(int)> func):begin_(begin),end_(end),func_(func){} class iterator { public: iterator(typename T::iterator end):end_(end){} iterator(typename T::iterator begin, std::function<bool(int)> func):begin_(begin), func_(func) {} int operator*() { if (!func_(*begin_)) return 0; return *begin_; } int operator->() { if (!func_(*begin_)) return 0; return *begin_; } iterator operator++(int n) { ++begin_; return *this; } iterator operator++() { iterator t = *this; operator++(0); return t; } bool operator==(const iterator& o) const { return begin_ == o.begin_; } bool operator!=(const iterator& o) const { return !(begin_ == o.end_); } private: typename T::iterator begin_; typename T::iterator end_; std::function<bool(int)> func_; }; iterator begin() { if (!func_) { throw std::logic_error("func_ is null"); } return iterator(begin_,func_); } iterator end() { if (!func_) { throw std::logic_error("func_ is null"); } return iterator(end_); } private: typename T::iterator begin_; typename T::iterator end_; std::function<bool(int)> func_; };

请问演示并行读取文件的代码例子中，最后有补充说“并行读取性能一般也不会快于顺序读取”，为什么并行和顺序读取性能差不多呢？

函数式编程在并发场合下的确有优势，但是普通应用，比如递归，实现起来比命令式复杂那么多，可读性更差，意义何在。而且函数式编程的代码简洁性不如直接命令式+注释

我也贴下我的实现，参考了前面一些同学的，望老师指正不足之处： template<typename It, typename Comp> class filter_view { public: class iterator { public: //支持内置指针 using value_type = typename std::iterator_traits<It>::value_type; using difference_type = typename std::iterator_traits<It>::difference_type; using pointer = value_type*; using reference = value_type&; using iterator_category = std::input_iterator_tag; iterator(It it, It e, Comp cmp) : it_(it), e_(e), cmp_(cmp) { skipNoMatch(); } iterator& operator++() { ++it_; skipNoMatch(); return *this; } auto operator*() { return *it_; } bool operator==(const iterator &rhs) const { return it_ == rhs.it_; } bool operator!=(const iterator &rhs) const { return !(*this == rhs); } private: void skipNoMatch() { while (it_ != e_ && !cmp_(*it_)) { ++it_; } } private: It it_; It e_; Comp cmp_; }; filter_view(It b, It e, Comp cmp) : b_(b), e_(e), cmp_(cmp) {} iterator begin() const { return iterator(b_, e_, cmp_); } iterator end() const { return iterator(e_, e_, cmp_); } private: It b_; It e_; Comp cmp_; };

吴老师，我重写了map-reduce逻辑(lazy evaluation)，但是目前的flatten功能输出有点混乱，我暂时没排查出结果。能帮我看下吗？https://github.com/franklucky001/fp-map-reduce/blob/master/main.cpp