探索匿名遞迴函式
匿名遞迴
在 C# 裡遞迴可以這麼定義嗎？
Func<int, int> fac = (x) => (x <= 1) ? 1 : x * fac(x - 1);
目前不行。因為 C# 只認識下面這種寫法：
Func<int, int> fac = null;
fac = (x) => (x <= 1) ? 1 : x * fac(x - 1);
但這實際上並未使該函式匿名化，而是把變數fac的引用繫結到了匿名函式的上下文中。這在變數fac被修改後存在失效的風險。
將自己傳給自己
為了使匿名遞迴可行，必須將自身作為引數傳給自己。
這麼寫可行嗎？
var fac = (f, x) => (x <= 1) ? 1 : f(f, x - 1);
fac(fac, 5);
在 C# 裡不行。因為 fac 的型別簽名無法被自動推斷，需要人工提供。
delegate int SelfFactorial(SelfFactorial f, int x);
寫成泛型，提高通用性：
delegate TResult SelfApplicable<T, TResult>(SelfApplicable<T, TResult> self, T arg);
SelfApplicable<int, int> fac = (f, x) => (x <= 1) ? 1 : f(f, x - 1);
fac(fac, 5);
更進一步，為 fac 構建函式閉包，得到我們想要的函式形式：
Func<int, int> Fac = (x) => fac(fac, x);
綜合以上過程，給出一個通用形式的幫助函式，簡化型別推斷：
static Func<T, TR> Make<T, TR>(SelfApplicable<T, TR> self)
{
return (x) => self(self, x);
}
var fac = Make<int, int>((f, x) => (x <= 1) ? 1 : x * f(f, x - 1));
推廣到兩個引數的情形：
delegate TR SelfApplicable<T1, T2, TR>(SelfApplicable<T1, T2, TR> self, T1 arg1, T2 arg2);
static Func<T1, T2, TR> Make<T1, T2, TR>(SelfApplicable<T1, T2, TR> self)
{
return (x, y) => self(self, x, y);
}
var gcd = Make<int, int, int>((f, x, y) => (y == 0) ? x : f(f, y, x % y));
但型別推斷並不是什麼大問題，下文如因型別推斷而無法寫出，大可手動補上。
柯里化
柯里化即將多引數的函式轉化為多個單引數函式的巢狀。
你可能會想到這種寫法：
var fac = Make2<int, int>((f) => (x) => (x <= 1) ? 1 : x * f(x - 1));
這需要配套怎樣的Make2呢？
static Func<T, TR> Make2<T, TR>(Func<Func<T, TR>, Func<T, TR>> g)
{
// 建立一個新的上下文，在裡面用上 g 就能把 g 儲存起來。
var wrapped_k = (x) => {
// 先跳過這行分析下面的，因為 h 是為了傳給 g 做引數的。
// 這個操作必須在子函式體內，不然就死迴圈了。
var h = Make2(g);
// k 才是想要的那個功能函式，但獲得這個 k 之前沒法傳給 g 做其引數 f，陷入了雞生蛋蛋生雞的矛盾。
// g 的引數 f 無法是 k，但 Make2 能構造 k 的轉發函式，且轉發函式使用時才會計算，不會死迴圈。
var k = g(h);
k(x);
};
// 這是一個 k 的轉發函式，用起來就跟 k 沒什麼區別。而且它的上下文裡有 g 的引用。
return wrapped_k;
}
這是一個不動點組合子（將在下文中解釋其含義），讓我們先將其重新命名為Fix。
static Func<T, TR> Fix<T, TR>(Func<Func<T, TR>, Func<T, TR>> g)
{
return (x) => g(Fix(g))(x);
}
Fix要配合一種兩層的匿名函式寫法。其中遞迴函式自身作為外層函式的引數，Fix將其轉化為了可以直接使用的函式物件。
兩個引數的Fix函式也可以順利寫出來了：
static Func<T1, T2, TR> Fix<T1, T2, TR>(Func<Func<T1, T2, TR>, Func<T1, T2, TR>> g)
{
return (x, y) => g(Fix(g))(x, y);
}
// g0 也可稱為單步函式
var g0 = (f) => (x) => (x <= 1) ? 1 : x * f(x - 1);
var fac = Fix<int, int>(g0);
fac(5);
var g1 = (f) => (x, y) => (y == 0) ? x : f(y, x % y);
var gcd = Fix<int, int, int>(g1);
gcd(10, 15);
先把單步函式抽象一下：
// use(x) 產生當次執行的計算結果
// next(f, x) 遞迴地產生 f(x)，或是在沒有下一個 x 時及時終止
// reduce(a, b) 將當次與遞迴的結果合併為最終結果
var g = (f) => (x) => reduce(use(x), next(f, x));
以一個引數的Fix函式為例分析其過程。
先分析這個兩層匿名函式g，並將內層函式單獨稱為 k：
// 注意：這是方便理解而拆開的虛擬碼，因為不可能使 k 在沒有 f 的上下文中繫結到 f。型別推斷也是個問題。
var k = (x) => reduce(use(x), next(f, x));
var g = (f) => k;
var f0 = Fix(g) = (x) => g(Fix(g))(x);
這裡的引數x被直接轉發給了內部函式h(Fix(g))，因此我們可以在分析時簡化。
var f0 = (x) => k(x), f=Fix(g);
雖然每次f=Fix(g)計算得到一個新的函式物件而不是複用已得到的f0，但二者的效果是相同的。
這裡有一個等式：
g(Fix(g)) == Fix(g)
一般地，我們稱值x是函式f的一個不動點，當且僅當f(x) = x。
那麼根據上文中的兩個等式，值Fix(g)是函式g的一個不動點。
Y-組合子
Y-組合子定義為：
Y = λf.(λx.f (x x)) (λx.f (x x))
注意：根據 α-變換，兩個 λx 是不同的變元，互不影響。即上式與下式等價：
Y = λf.(λx.f (x x)) (λy.f (y y))
但只要表示式相同，自由變元的名字無關緊要，所以在兩個不同的地方都用λx是沒問題的。
拆分一下，方便理解：
h = λx.f (x x)
Y = λf.h h
寫成 C# 是：
var Y = (f) => {
// 這雖然寫得出程式碼，但執行起來會死迴圈
var H = (x) => f(x(x));
return H(H);
};
因此這裡需要多一層轉發函式的巢狀，使x(x)被推遲執行。推遲執行最重要的目的是在遞迴到頭的時候不再計算從而能夠退出。
增加一層轉發函式，這對應於 λ-演算，即可以使用 η-變換。有兩個做法：
x x展開為λv.(x x) vf (x x)展開為λv.(f (x x)) v
第二種變換對應的 C# 是：
var Y = (g) => {
var H = (h) => {
var wrapped_k = (x) => {
// 每次 h(h) 都得到一個新的 wrapped_k
var new_wrapped_k = h(h);
// 在 wrapped_k 中使用了 g
// 換取真正的功能函式，而 new_wrapped_k(next(x)) 是能遞迴下去的
var k = g(new_wrapped_k);
return k(x);
};
return wrapped_k;
};
// 巧妙的 H(H), h(h) 組合，建立對 g 的閉包
return H(H);
};
簡寫為：
var Y = (g) => {
var H = (h) => (x) => g(h(h))(x);
return H(H);
};
Θ-組合子
var H = (h) => (g) => (x) => g(h(h)(g))(x);
var Θ = H(H);
Θ-組合子 與 Y-組合子 的唯一區別就是變數 g 在多層函式的位置，以及因此而需要的一個重複傳參的步驟。
這兩個組合子的對比同時說明了以下等式：
λx.λy.((f x y) y0 x0) == λy.λx.((f x y) x0 y0)