zoukankan      html  css  js  c++  java
  • 拿 C# 搞函数式编程

    前言

    今天和某个人聊天聊到了 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 是不是。。。

    jpg

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

    然后我们实现我们的 JustNothing

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

    此时,函数 kint -> 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 特性加上了,我们再继续。

  • 相关阅读:
    10. Regular Expression Matching
    9. Palindrome Number (考虑负数的情况)
    8. String to Integer (整数的溢出)
    7. Reverse Integer (整数的溢出)
    LeetCode Minimum Size Subarray Sum
    LeetCode Course Schedule II
    Linux 文件缓存 (一)
    LeetCode Tries Prefix Tree
    Linux : lsof 命令
    LeetCode Binary Tree Right Side View
  • 原文地址:https://www.cnblogs.com/hez2010/p/12590389.html
Copyright © 2011-2022 走看看