拿 C# 搞函数式编程 - 3

概述LINQ + SelectMany = Monad! 前言

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

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

@H_301_10@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 List1from d in List2select 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 10nothing

完美！上面的 liNQ 被编译成了：

var u = x.SelectMany(_ => y,(x0,y0) => x0 + y0);var v = x.SelectMany(_ => z,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,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 3nothing

有内味了（逃

后记

该系列的后续文章将按揭编写，如果 C# 争气一点，把 discriminated Unions、Higher Kinded Generics 和 Type Classes 特性加上了，我们再继续。

总结

以上是内存溢出为你收集整理的拿 C# 搞函数式编程 - 3全部内容，希望文章能够帮你解决拿 C# 搞函数式编程 - 3所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。