如何寫遞迴的 Lambda 運算式

這個問題貌似很簡單，不是嗎？隨便寫一個：

Func<int, int> factorial = x => x == 0 ? 1 : x * factorial(x - 1);

但是這個通過不了編譯，因為你在用 factorial 定義 factorial，編譯器會提示 factorial 是未被賦值的變數：

不少人提出，以下這樣不就行了嗎？

Func<int, int> factorial = null;factorial = x => x == 0 ? 1 : x * factorial(x - 1);

聰明，問題貌似解決了！不過前提是你不改變 factorial，考慮繼續寫以下代碼：

var f2 = factorial;factorial = i => i;Console.WriteLine(f2(5));

不妨猜猜輸出結果？恭喜你，是 20。原因很簡單，因為 factorial = i => i，所以把 f2 展開後就變成了：

x => x == 0 ? 1 : x * (i => i)(x - 1)

拜閉包所賜，這就不是我們想要的 factorial 函數啦！這方法在很多時候可以用，但要避免改變 factorial。現在我們來找一種沒有這麼容易出錯的方法。

 

函數映射函數（傳說中的高階函數？）

回到第一個式子，我們遭到了未知量。通常呢，我們不知道一樣東西的時候，我們把它設成未知數，然後方程照列，按編程的說法呢，就是把它提成參數，再想辦法讓其他人搞好了傳進來用（傳說中的 IoC ？）：

Func<Func<int, int>, int, int> factorial = ( fac, x ) => x == 0 ? 1 : x * fac(x - 1);

看上去挺不錯的，但是 FP 慣的朋友會認為這樣更好：

Func<Func<int, int>, Func<int, int>> map = fac => x => x == 0 ? 1 : x * fac(x - 1);

這樣，函數兩個參數之間的關係不再是平行的，而是變成了一個函數，它取一個函數作為參數，返回另一個函數，這另一個函數取一個數字，並抓取第一個函數的接收的參數（閉包）做一點了東西。換一句話說，map 這個函數接收的參數和返回的值的類型都是函數，也就是傳說中的高階函數，以我的理解來說就是將一個函數映射到了另一個函數（希望這個敘述還說得過去吧）。

這個主意非常瘋狂的說，現在我們只需讓“人家”告訴我們自己想要什麼，我們拿過來 map 一下，就得到想要的東西了。顯然，現在的問題是，這個“人家”，其實就是我們。

 

這個“人家”就是我們（傳說中函數的固定點？）

高中數學：如果一個函數 f(x) 存在 x = f(x) 這些點，那麼這些點就叫做函數 f(x) 的固定點。當然，定義域和範圍都是實數。但是如果定義域和範圍都是函數的話呢？

來看上面的 map 函數，假設我們找到了它的固定點 Factorial，扔給 map 函數，展開：

map(Factorial) =x => x == 0 ? 1 : x * Factorial(x - 1)

根據固定點的定義，map(Factorial) = Factorial，代入上式，即有

Factorial =x => x == 0 ? 1 : x * Factorial(x - 1)

這不就是我們一開始寫的那條式子嗎？所以結論就是，如果人家（我們）找到 map 函數的固定點，那麼我們拿過來，扔給 map 函數，那麼它返回的函數就是我們要的函數！

下面我們來找 map 函數的固定點。在實數域尋找這些點可以變得很困難（虛心向各位請教怎麼求 f(x) = (1/16)x 的固定點，不是近似啊，感激不盡），但尋找這種定義域和範圍都是函數的函數，卻有偉人的肩膀讓我們踩。如是一個很娛樂的 Fixed point combinator：

有興趣可以試試，但這裡我們用一種實用的方法來找，那就是寫一個方法，接收這個 map 函數，並返回它的固定點：

static Func<T, T> Fix<T>( Func<Func<T, T>, Func<T, T>> map ){    // ...}

那麼，其實 Fix(map) 就是我們要找的固定點了：

static Func<T, T> Fix<T>( Func<Func<T, T>, Func<T, T>> map ){    return Fix(map);}

有沒有搞錯？！這樣我們簡直像是在胡鬧，陷入了死迴圈！

記住，我們是在找固定點，現在卻沒有用上固定點的定義！令 F = Fix(map)，那麼 F = map(F)，也就是像在之前說的那樣，map 一下：

static Func<T, T> Fix<T>( Func<Func<T, T>, Func<T, T>> map ){    return map(Fix(map));}

這樣，我們就將 map 的固定點，也就是目標函數，遞迴地展開了。So far, so good, isn’t it？

其實我們這樣做只是遞迴地展開一個函數的固定點，也就是它本身，這個過程是無限的，這等於在說，現在有人需要一個函數的固定點，得先等無限長時間，我們才不要做這個倒黴的傢伙呢！事實上，只要知道了具體輸入值，而這個函數在這個輸入值下能停止的話，這個展開就可以停止了（當然是這樣了，感覺這句話廢廢的……），那麼我們應該返回一個函數，它知道輸入值後才去展開目標函數：

static Func<T, T> Fix<T>( Func<Func<T, T>, Func<T, T>> map ){    return x => map(Fix(map))(x);}

這個技巧的描述讓我想起了 jQuery Tutorials 的一段話……

 

總結

都說完了，那就上代碼吧……

class Program{    static void Main( string[] args )    {        Func<Func<int, int>, Func<int, int>> map            = fac => x => x == 0 ? 1 : x * fac(x - 1);        var factorial = Fix(map);        Console.WriteLine(factorial(5));        Console.ReadKey();    }    static Func<T, T> Fix<T>( Func<Func<T, T>, Func<T, T>> map )    {        return x => map(Fix(map))(x);    }}

對 factorial 的定義也可以寫成：

var factorial = map(Fix(map));

不過沒必要了……