下面用一个例子来用函数式方式实现某个需求，看下在函数式的思想下是如何一层层进行抽象的：
/*
* 需求：从给定的无序整数序列中取出所有大于10且小于50的偶数，对其加倍后求和
* 例如：
* 原始序列：[32, 14, 3, 21, 109, 50, 25, 26, 18]
* 操作一：过滤，留下大于10小于50:[32， 14， 21， 25， 26， 18]
* 操作二：过滤，留下偶数：[32, 14, 26, 18]
* 操作三：加倍：[64, 28, 52, 36]
* 操作四：求和：180
*/
面向过程的一般写法：
int f1(const vector<int> &input)
{
int sum = 0;
for(int ele : input) {
if (ele > 10 && ele < 50) {
if (ele % 2 == 0) {
sum += ele * 2;
}
}
}
return sum;
}
这种写法，第一眼看过去是不知道该函数在做什么，需要一点点代码分析。原因就在于缺乏抽象。
我们先来进行最容易想到的第一层抽象：
bool isBetween(int input)
{
return input > 10 && input < 50;
}
bool isEven(int input)
{
return input % 2 == 0;
}
int f2(const vector<int> &input)
{
int sum = 0;
for(int ele : input) {
if (isBetween(ele)) {
if (isEven(ele)) {
sum += ele * 2;
}
}
}
return sum;
}
比之前好一些么？大概也就只强了那么一点点……
下面展示下使用stl算法库的写法，相对来说每个操作的可读性变强了不少：
int f3(const vector<int> &input)
{
vector<int> filtRange;
copy_if(begin(input), end(input), back_inserter(filtRange), isBetween); // 操作一，通过copy_if过滤，条件是isBetween
vector<int> filtEven;
copy_if(begin(filtRange), end(filtRange), back_inserter(filtEven), isEven); // 操作二，通过copy_if过滤，条件是isEven
vector<int> doubleValue;
transform(begin(filtEven), end(filtEven), back_inserter(doubleValue), [](int x) { return x * 2; }); //操作三，通过transform修改每条数据，修改方式是×2
return accumulate(begin(doubleValue), end(doubleValue), 0); // 操作四，从0开始累加
}
使用stl算法库看起来已经很好阅读了，那么对于函数式来说，我们还有什么可以抽象的呢？
抽象一方面是为了增强可读性，另一方面是为了增强普适性，便于复用。
从复用角度来看，之前的isBetween只能判断在10和50之间，不能适用其他范围，因此进一步的抽象可以优化这里：
// 过滤器
using Filter = function<bool(int input)>;
// 生成一种过滤器的函数
Filter isBetween(int left, int right)
{
// 返回值是一个函数
return [=](int input) {
return input > left && input < right;
};
}
这里的isBetween是之前的isBetween的抽象，该函数调用的返回值其实就是原来的isBetween函数。
这样，完整调用流程就变成了这样：
int f4(const vector<int> &input)
{
vector<int> filtRange;
copy_if(begin(input), end(input), back_inserter(filtRange), isBetween(10, 50));
vector<int> filtEven;
copy_if(begin(filtRange), end(filtRange), back_inserter(filtEven), isEven);
vector<int> doubleValue;
transform(begin(filtEven), end(filtEven), back_inserter(doubleValue), [](int x) { return x * 2; });
return accumulate(begin(doubleValue), end(doubleValue), 0);
}
isBetween(10, 50)相比之前的isBetween，明确了判断是在10到50之间，相比之前读起来更直观一些；同时也可以在别的代码处对不同的范围条件复用。
这里其实就用到了函数式的基础——将函数作为返回值。难道所谓的函数式就这？？？
来吧，展示：
如果我们要做进一步抽象，考虑到这里都是对一个数据序列做操作，一共四步操作：前两步操作都是过滤，第三步操作是对每条数据做转换，第四步操作是对所有数据一起做个整合；
我们把“过滤”、“数据转换”、“数据整合”作为一个抽象层级，再利用pipeline方式做形式化处理。对于过滤，我们定义如下形式：
// 输入一个序列和过滤器，输出过滤后的序列
vector<int> operator | (const vector<int> &input, Filter filter)
{
vector<int> output;
copy_if(begin(input), end(input), back_inserter(output), filter);
return output;
}
使用过滤器之后，我们的完整处理流程形式如下：
int f5(const vector<int> &input)
{
auto filt = input | isBetween(10, 50) | isEven; // isBetween(10, 50)和isEven是两个过滤器，对input做过滤后的结果是filt
vector<int> doubleValue;
transform(begin(filt), end(filt), back_inserter(doubleValue), [](int x) { return x * 2; });
return accumulate(begin(doubleValue), end(doubleValue), 0);
}
对于数据转换，我们做如下定义：
// 数据转换器
using Transformer = function<int(int input)>;
// 输入一个序列和转换器，输出转换后的序列
vector<int> operator | (const vector<int> &input, Transformer trans)
{
vector<int> output;
transform(begin(input), end(input), back_inserter(output), trans);
return output;
}
然后我们再对乘2动作再做一次抽象级别的提升，可指定任意倍数扩展：
Transformer multiplyBy(int x)
{
return [x](int input) {
return input * x;
};
}
注意到multiplyBy也是一个高阶函数，它返回了一个转换器函数。
这时候我们的完整处理流程变成了如下形式：
int f6(const vector<int> &input)
{
auto out = input | Filter(isBetween(10, 50)) | Filter(isEven) | Transformer(multiplyBy(2));
return accumulate(begin(out), end(out), 0);
}
至此，我们阅读上面的代码，已经可以“口述”了：
对序列input元素按是否在10到50之间过滤，再按是否偶数过滤，再做乘2转换得到新序列out；返回out序列从0开始的累加结果
直接口述代码，意味着我们不需要再去思考这段代码的意图，阅读代码变得简单。
这就体现出函数式宣称的一大好处：描述做什么，而非怎么做。
我们再来看看数据整合怎么实现：
template<typename T>
using FoldFunc = function<T(const T&, int)>;
template<typename T>
struct Fold {
Fold(FoldFunc<T> f, const T &in) : func(f), init(in) {};
FoldFunc<T> func; // 折叠函数，表示数据整合的方法
T init; // 初值
};
template<typename T>
T operator | (const vector<int> &input, const Fold<T> &fold)
{
T result = fold.init;
for (int i : input) {
result = fold.func(result, i);
}
return result;
}
完成数据整合之后，处理的完整流程如下：
// 对于累加来说，折叠函数就是Add:
int Add(int a, int b)
{
return a + b;
}
int f7(const vector<int> &input)
{
return input | Filter(isBetween(10, 50)) | Filter(isEven) | Transformer(multiplyBy(2)) | Fold<int>(Add, 0);
}
我们可以看到，一行代码就完成了整个功能，且达成了“口述”代码流程：
“过滤input中10到50之间的偶数，再乘2之后从0开始累加”。
对比我们的原始需求描述：
“从给定的无序整数序列中取出所有大于10且小于50的偶数，对其加倍后求和”
不能说完全相同，只能说是一模一样
可能有同学有疑问，accumulate已经很直观了，搞个Fold没看出来有多大好处呀？
其实这东西在函数式中是很基础和常见的。比如我们打印一个vector，可以利用Fold这样实现：
void print(const vector<int> &input)
{
string content = input | Fold<string>([](const string &s, int i) { return s + " " + to_string(i); }, "[");
cout << content << " ]" << endl;
}
可能有的同学会说了，你这个打印只能打印int元素的vector，其他的搞不定！
说起来，我们上面的Fold其实限定了一个条件：每个元素的类型和折叠后的结果类型是一致的。
如果我们放开这个限制，比如如下形式定义，就可以搞定其他情况了：
template<typename T, typename U>
using FoldFunc2 = function<T(const T&, const U&)>;
template<typename T, typename U>
struct Fold2 {
Fold2(FoldFunc2<T, U> f, const T &in) : func(f), init(in) {};
FoldFunc2<T, U> func;
T init;
};
template<typename T, typename U>
T operator | (const vector<U> &input, const Fold2<T, U> &fold)
{
T result = fold.init;
for (const U &i : input) {
result = fold.func(result, i);
}
return result;
}
