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