4個程序員的一天

你，一個DotNet程序員，剛剛加入一個新項目組。除了你之外，其他的成員包括：Ceer，一直從事C項目的程序員，他剛剛轉入C#不到一個月； Jally，整天抱着本Design Pattern（沒錯，就是GoF的那本）在啃的前Java程序員；以及Semon，你對他完全不瞭解，只是聽PM介紹說他是搞Scheme的（傳說中的第二古老的語言LISP的方言之一）。不過你也沒在意，畢竟計算機這玩意，老東西是不吃香的。

週一，剛打開電腦，老闆就跑到你們組的辦公座面前：“好吧，夥計們，現在有個function需要你們來搞定。具體是這樣的：用戶輸入2個數，並輸入一個操作符。你根據輸入的情況來得出相應的運算結果。“

Example： Foo(+, 1, 2) = 3; Foo(*, 3, 6) = 18; Foo(/, 2, 4) = 0.5

Ceer最先作出反應：簡單嘛，判斷一下輸入的操作符就好了。說着，他很快在白板上寫出如下代碼：
    public class CStyle_Calculator
    {
        static public double Foo(char op, double x, double y)
        {
            switch(op)
                case '+': return x + y; break;
                case '-': return x - y; break;
                case '*': return x * y; break;
                case '/': return x / y; break;
                default: throw new Exception(”What the Hell you have input?");
        }
    }
   
Jally只看了一遍，就捂着鼻子連連搖頭：好一股的代碼臭味【注1】。還不如看我用OO的方法來解決：
    public interface I操作符 //誰說代碼不能寫中文的？恩恩
    {
        double 運算(double x, double y);
    }
   
    public class OO_Calculator
    {
        private I操作符 m_op;
        public OO_Calculator(I操作符 op)
        {
            this.m_op = op; //依賴注入【注2】
        }
       
        public double Foo(double x, double y)
        {
            return this.m_op.運算(x, y);
        }
    }
   
    public class 加法:I操作符
    {
        public double 運算(double x, double y)
        {
            return x + y;
        }
    }
   
    public class 減法:I操作符
    {
        public double 運算(double x, double y)
        {
            return x - y;
        }
    }
   
    public class 乘法:I操作符
    {
        public double 運算(double x, double y)
        {
            return x * y;
        }
    }
   
    public class 除法:I操作符
    {
        public double 運算(double x, double y)
        {
            return x / y;
        }
    }
   
    public class TheMainClass
    {
        static public void Main()
        {
            I操作符 我的加法 = new 加法();
            OO_Calculator 我的加法器 = new OO_Calculator(我的加法);
            double sum  = 我的加法器.Foo(3, 4);
            System.Console.WriteLine(sum);
            //sum = 7
           
            //其他3個我就不廢話了
        }
    }

你看着Jally把白板寫得密密麻麻之後，聳聳肩，暗歎，你們這些用java的廢柴，就一個運算器還搞出Interface這些東西，煩不煩啊。 讓你們見識見識DotNet的強大吧. 那個運算符我直接用delegate傳進去不就好了麼.
    public delegate double TheOperator(double x, double y);
   
    public class Operators
    {
        static public double Add(double x, double y)
        {
            return x + y;
        }
       
        static public double Sub(double x, double y)
        {
            return x - y;
        }
       
        //乘，除法 我也懶得廢話了
    }
   
    public class DotNet_Calculator
    {
        public double Foo(TheOperator op, double x, double y)
        {
            return op(x, y);
        }
    }
   
    public class TheMainClass
    {
        static public void Main()
        {
            TheOperator myAdd = new TheOperator(Operators.Add);
            TheOperator mySub = new TheOperator(Operators.Sub);
           
            DotNet_Calculator dc = new DotNet_Calculator();
            double sum = dc.Foo(myAdd, 2, 4); //sum = 6
            System.Console.WriteLine(sum);
            double sub = dc.Foo(mySub, 3, 7); //sub = -4
            System.Console.WriteLine(sub);
        }
    }
    //dot net 下面還可以用CodeDom動態構造C＃代碼，然後在內存編譯運行。
    //如果覺得專門寫個Operators很煩的話，可以試試C＃2.0的匿名方法

很好，當你寫完代碼之後，挑釁的看着Jally，Ceer卻開始抱怨起來：”這不就是C裏面的函數指針麼，我也會...“
“然則DotNet下面的Delegate是類型安全滴...”你繼續洋洋得意.
   
而Semon，看了看你們3位華麗的代碼，啥也沒說，只是在鍵盤上敲下了2行代碼

(define (Foo op x y)
    (op x y))

然後就下班了...

【注： scheme的代碼稍微解釋下：(+ 1 2) = 3, (* 3 4) = 12.】
至於Semon的解法：
(define (Foo op x y)
  (op x y))

看明白了麼，上面的代碼只有一個作用：第一行是函數頭，定義了一個叫Foo的函數。該函數接受3個參數op, x, y。
第二行定義了函數的行爲：把第一個參數op當作運算符，計算後面2個參數。
所以：（Foo + 1 2) = 3. (Foo / 12 6) = 2.

好了好了，不編故事了。
我只是想簡單的讓大家在繁忙的工作之餘，也瞅瞅Function Programming（函數編程）世界的美妙。函數編程，最大的特點是它是將函數作爲語言裏1st class的元素來對待的。一個函數可以接受另一個函數作爲參數，也可以把一個函數作爲結果來返回。這樣的函數我們稱爲Higher-order function。

那麼，Function Programming和我們傳統的面向對象有啥區別捏？ 恩，這個嘛，扯得遠可以扯到圖靈機和馮·諾以曼這2種體系的差異...@_@不過那個太學術性，俺就不說了。不過有句話可以較好的概括FP和OO的區別（好吧，這個也是抄“紫皮書”上面的）：

“Pascal是爲了建造金字塔...Lisp是爲了建造有機體...”“作爲Lisp的內在數據結構，表對於這種可用性起着重要的提升作用...”“採用100函數在一個數據結構上操作，遠遠優於採用10個操作在十個數據結構上工作”“金字塔矗立在那裏千年不變，而有機體則必須演化，否則就會消亡”。

而另一個總結得比較好的話是：（同樣是抄來的）

一個對象：一組相同的運算上面，外加不同的數據。（想想你的object，是不是這樣的？）
一個Closure：一組相同的數據，外加不同的操作。（Delegate就是這樣的思想，有興趣的話也可以去看看Ruby）

基本上，恩，沒啥說的了。 如果你感興趣的話，可以去看MIT SICP的課程（有在線版的，MIT也作爲Open Course開設了的）

參考文獻：
Java 語言中的函數編程(偶FP的入門貼。查叔叔，我膜拜您）
http://www.hibernate.org.cn/viewtopic.php?t=7569&postdays=0&postorder=asc&start=0

Lambda Calculus
http://www.mactech.com/articles/mactech/Vol.07/07.05/LambdaCalculus/

Java 語言中的函數編程
http://www-128.ibm.com/developerworks/cn/java/j-fp/

【注1】
見Bob大叔的《ASD》一書

【注2】
Flower的依賴注入模式，Ioc容器啥的是這裏來的