拿 C# 搞函数式编程 - 3

标签：完全   mamicode   条件   linq   cto   enum   gen   abs   否则   

前言

今天和某个人聊天聊到了 C# 的 LINQ，发现我认识的 LINQ 似乎和大多数人认识的 LINQ 不太一样，怎么个不一样法呢？其实 LINQ 也可以用来搞函数式编程。

当然，并不是说写几个 lambda 和用用像 Java 那样的 stream 之类的就算叫做 LINQ 了，LINQ 其实是一个另外的一些东西。

LINQ

在 C# 中，相信大家都见过如下的 LINQ 写法：

IEnumerable EvenNumberFilter(IEnumerable list)
{
    return from c in list where c & 1 == 0 select c;
}

以上代码借助 LINQ 的语法实现了对一个列表中的偶数的筛选。

LINQ 只是一个用于方便对集合进行操作的工具而已，如果我们如果想让我们自己的类型支持 LINQ 语法，那么我们需要让我们的类型实现 IEnumerable，然后就可以这么用了。。。

哦，原来是这样的吗？那我全都懂了。。。。。。

？？？哦，我的老天，当然不是！

其实 LINQ 和 IEnumerable 完全没有关系！LINQ 只是一组扩展方法而已，它主要由以下方法组成：

以上方法对应 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。

Maybe

首先，我们写一个抽象类 Maybe。

首先我们给它加一个 Select 方法用于选择 Maybe 中的数据，如果是 T，那么返回一个 Just，如果是 Nothing，那么返回一个 Nothing。相当于我们的 returns 函数：

public abstract class Maybe
{
    public abstract Maybe Select(Func> f);
}

然后我们实现我们的 Just 和 Nothing：

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 的方法。

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：

var x = new Just(3);
var y = new Just(7);
var z = new Nothing();

然后我们分别利用 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，而函数 s 为(int, int) -> int，是一个加法函数。

函数 k 的参数我们并不关心，它用作一个 selector，我们只需要让它产生一个 Maybe，然后利用函数 s 将两个 int 的值做加法运算，并把结果包装到一个 Just 里面即可。

这个过程中，如果有任何一方产生了 Nothing，则后续运算结果永远都是 Nothing，因为 Nothing.Select(...) 还是 Nothing。

一点扩展

我们再给这个 Maybe 加一个 Where：

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();
}

然后我们就可以玩：

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 特性加上了，我们再继续。

拿 C# 搞函数式编程 - 3

标签：完全   mamicode   条件   linq   cto   enum   gen   abs   否则   

原文地址：https://www.cnblogs.com/hez2010/p/12590389.html