C# lambda递归

这个不是我发明的，只是拿来人脑运行一下，有点烧脑。

　　public class Recursive
    {
        delegate T SelfApplicable<T>(SelfApplicable<T> self);

        public static void Run()
        {
            // The Y combinator
            SelfApplicable<Func<Func<Func<int, int>, Func<int, int>>, Func<int, int>>> Y =
                y =>
                    f =>
                        x => f(y(y)(f))(x);
            
            // The fixed point generator
            Func<Func<Func<int, int>, Func<int, int>>, Func<int, int>> Fix = Y(Y);

            // The higher order function describing factorial
            Func<Func<int, int>, Func<int, int>> F =
                fac =>
                    x =>
                        x == 0 ?
                            1 :
                            x * fac(x - 1);

            // The factorial function itself
            Func<int, int> factorial = Fix(F);

            Console.WriteLine(factorial(10));

        }

    }

F == fac => x => x == 0 ? 1 : x * fac(x-1)
Y == y=>f=>x=>f(y(y)(f))(x)
Y(Y) == f=>x=>f(Y(Y)(f))(x)
Y(Y)(F) == x=>F(Y(Y)(F))(x)
Y(Y)(F)(10) == F(Y(Y)(F))(10) 　　　　　　　　A：递归开始的地方
　　　　　　== F((f=>x=>f(Y(Y)(f))(x))(F))(10)
　　　　　　== F(x=>F(Y(Y)(F))(x))(10)
　　　　　　== (fac=>x=>x==0?1:x*fac(x-1))(x=>F(Y(Y)(F))(x))(10)
　　　　　　== (x=>x==0?1:x*(x=>F(Y(Y)(F))(x))(x-1))(10)
　　　　　　== 10==0?1:10*(x=>F(Y(Y)(F))(x))(10-1)
　　　　　　== 10*(x=>F(Y(Y)(F))(x))(9)
　　　　　　== 10*F(Y(Y)(F))(9)　　　　　　　　B: 就像A，又一次开始
　　　　　　== .......
　　　　　　..........
　　　　　　== 10*9*8*7*6*5*4*3*2*1*F(Y(Y)(F))(0)
　　　　　　== 10*9*8*7*6*5*4*3*2*1*F((f=>x=>f(Y(Y)(f))(x))(F))(0)
　　　　　　== 10*9*8*7*6*5*4*3*2*1*F(x=>F(Y(Y)(F))(x))(0)
　　　　　　== 10*9*8*7*6*5*4*3*2*1*(fac=>x=>x==0?1:x*fac(x-1))(x=>F(Y(Y)(F))(x))(0)
　　　　　　== 10*9*8*7*6*5*4*3*2*1*(x=>x==0?1:x*(x=>F(Y(Y)(F))(x))(x-1))(0)
　　　　　　== 10*9*8*7*6*5*4*3*2*1*(0==0?1:0*(x=>F(Y(Y)(F))(x))(0-1))
　　　　　　== 10*9*8*7*6*5*4*3*2*1*1

好美......

So beautiful......

终极感受：

　　

new Func<int, int>(i =>
                new Func<Func<int, int>, Func<int, int>>(fac => x => x == 0 ? 1 : x * fac(x - 1))(
                    new SelfApplicable<Func<Func<Func<int, int>, Func<int, int>>, Func<int, int>>>(
                        y => f => x => f(y(y)(f))(x)
                    )(
                        y => f => x => f(y(y)(f))(x)
                    )(
                        fac => x => x == 0 ? 1 : x * fac(x - 1))
                    )(i))(10)

No function Name,No trouble.