拿 C# 搞函数式编程 - 3
前言
今天和某个人聊天聊到了 c# 的 linq，发现我认识的 linq 似乎和大多数人认识的 linq 不太一样，怎么个不一样法呢？其实 linq 也可以用来搞函数式编程。
当然，并不是说写几个 lambda 和用用像 java 那样的 stream 之类的就算叫做 linq 了，linq 其实是一个另外的一些东西。
linq
在 c# 中，相信大家都见过如下的 linq 写法：
ienumerable<int> evennumberfilter(ienumerable<int> list)
{
return from c in list where c & 1 == 0 select c;
}
以上代码借助 linq 的语法实现了对一个列表中的偶数的筛选。
linq 只是一个用于方便对集合进行操作的工具而已，如果我们如果想让我们自己的类型支持 linq 语法，那么我们需要让我们的类型实现 ienumerable<t>，然后就可以这么用了。。。
哦，原来是这样的吗？那我全都懂了。。。。。。
？？？哦，我的老天，当然不是！
其实 linq 和 ienumerable<t> 完全没有关系！linq 只是一组扩展方法而已，它主要由以下方法组成：
| 方法名称 | 方法说明 |
|---|---|
| where | 数据筛选 |
| select/selectmany | 数据投影 |
| join/groupjoin | 数据联接 |
| orderby/thenby/orderbydescending/thenbydescending | 数据排序 |
| groupby | 数据分组 |
| ...... |
以上方法对应 linq 关键字：where, select, join, orderby, group...
在编译器编译 c# 代码时，会将 linq 语法转换为扩展方法调用的语法，例如：
from c in list where c > 5 select c;
会被编译成：
list.where(c => c > 5).select(c => c);
再例如：
from x1 in list1 join x2 in list2 on x1.k equals x2.k into g select g.u;
会被编译成：
list1.groupjoin(list2, x1 => x1.k, x2 => x2.k, (x1, g) => g.u);
再例如：
from x in list orderby x.k1, x.k2, x.k3;
会被编译成：
list.orderby(x => x.k1).thenby(x => x.k2).thenby(x => x.k3);
再有：
from c in list1 from d in list2 select c + d;
会被编译成：
list1.selectmany(c => list2, (c, d) => c + d);
停停停！
此外，编译器在编译的时候总是会先将 linq 语法翻译为方法调用后再编译，那么，只要有对应名字的方法，不就意味着可以用 linq 语法了（逃
那么你看这个 selectmany 是不是。。。
selectmany is monad
哦我的上帝，你瞧瞧这个可怜的 selectmany，这难道不是 monad 需要的 bind 函数？
事情逐渐变得有趣了起来。
我们继承上一篇的精神，再写一次 maybe<t>。
maybe<t>
首先，我们写一个抽象类 maybe<t>。
首先我们给它加一个 select 方法用于选择 maybe<t> 中的数据，如果是 t，那么返回一个 just<t>，如果是 nothing<t>，那么返回一个 nothing<t>。相当于我们的 returns 函数：
public abstract class maybe<t>
{
public abstract maybe<u> select<u>(func<t, maybe<u>> f);
}
然后我们实现我们的 just 和 nothing：
public class just<t> : maybe<t>
{
private readonly t value;
public just(t value) { this.value = value; }
public override maybe<u> select<u>(func<t, maybe<u>> f) => f(value);
public override string tostring() => $"just {value}";
}
public class nothing<t> : maybe<t>
{
public override maybe<u> select<u>(func<t, maybe<u>> _) => new nothing<u>();
public override string tostring() => "nothing";
}
然后，我们给 maybe 实现 bind —— 即给 maybe 加上一个叫做 selectmany 的方法。
public abstract class maybe<t>
{
public abstract maybe<u> select<u>(func<t, maybe<u>> f);
public maybe<v> selectmany<u, v>(func<t, maybe<u>> k, func<t, u, v> s)
=> select(x => k(x).select(y => new just<v>(s(x, y))));
}
至此，maybe<t> 实现完了！什么，就这？？那么怎么用呢？激动人心的时刻来了！
首先，我们创建几个 maybe<int>：
var x = new just<int>(3); var y = new just<int>(7); var z = new nothing<int>();
然后我们分别利用 linq 计算 x + y, x + z：
var u = from x0 in x from y0 in y select x0 + y0; var v = from x0 in x from z0 in z select x0 + z0; console.writeline(u); console.writeline(v);
输出结果：
just 10 nothing
完美！上面的 linq 被编译成了：
var u = x.selectmany(_ => y, (x0, y0) => x0 + y0); var v = x.selectmany(_ => z, (x0, z0) => x0 + z0);
此时，函数 k 为 int -> maybe<int>，而函数 s 为(int, int) -> int，是一个加法函数。
函数 k 的参数我们并不关心，它用作一个 selector，我们只需要让它产生一个 maybe<int>，然后利用函数 s 将两个 int 的值做加法运算，并把结果包装到一个 just<int> 里面即可。
这个过程中，如果有任何一方产生了 nothing，则后续运算结果永远都是 nothing，因为 nothing.select(...) 还是 nothing。
一点扩展
我们再给这个 maybe<t> 加一个 where：
public abstract class maybe<t>
{
public abstract maybe<u> select<u>(func<t, maybe<u>> f);
public maybe<v> selectmany<u, v>(func<t, maybe<u>> k, func<t, u, v> s)
=> select(x => k(x).select(y => new just<v>(s(x, y))));
public maybe<u> where(func<maybe<t>, bool> f) => f(this) ? this : new nothing<t>();
}
然后我们就可以玩：
var just = from c in x where true select c; var nothing = from c in x where false select c; console.writeline(just); console.writeline(nothing);
当满足条件的时候返回 just，否则返回 nothing。上述代码将输出：
just 3 nothing
有内味了（逃
后记
该系列的后续文章将按揭编写，如果 c# 争气一点，把 discriminated unions、higher kinded generics 和 type classes 特性加上了，我们再继续。