Haskell：為什么（（。）。（。））fg等於f。 GX？

Question

你能解釋一下表達式的含義（（。）。（。））嗎？ 據我所知（。）有類型（b - > c） - >（a - > b） - > a - > c。

Answer 1

(.) . (.) (.) . (.)是組合運算符本身的組合。

如果我們看一下

((.) . (.)) f g x

我們可以評估幾個步驟，首先我們括起來，

((((.) . (.)) f) g) x

然后我們申請，使用(foo . bar) arg = foo (bar arg) ：

~> (((.) ((.) f)) g) x
~> (((.) f) . g) x
~> ((.) f) (g x)
~> f . g x

更有原則的，

(.) :: (b -> c) -> (a -> b) -> (a -> c)

因此，使用(.)作為第一個參數(.)我們必須統一

b -> c

同

(v -> w) -> (u -> v) -> (u -> w)

產量

b = v -> w
c = (u -> v) -> (u -> w)

和

(.) (.) = ((.) .) :: (a -> v -> w) -> a -> (u -> v) -> (u -> w)

現在，要將其應用於(.) ，我們必須統一類型

a -> v -> w

重命名后的(.)類型

(s -> t) -> (r -> s) -> (r -> t)

產量

a = s -> t
v = r -> s
w = r -> t

因此

(.) . (.) :: (s -> t) -> (u -> r -> s) -> (u -> r -> t)

從類型我們可以（幾乎）讀取(.) . (.) (.) . (.)將函數（一個參數）應用於兩個參數的函數的結果。

Answer 2

你已經有了答案，這里有一個不同的看法。

在組合邏輯 (.)是B- Babc = a(bc) ： Babc = a(bc) 。 在編寫組合子表達式時，習慣上假設每個標識符僅由一個字母組成，並在應用程序中省略空格，以使表達式更具可讀性。 當然通常的currying適用： abcde是(((ab)c)d)e ，反之亦然。

(.)是B ，所以((.) . (.)) == (.) (.) (.) == BBB 。 所以，

BBBfgxy = B(Bf)gxy = (Bf)(gx)y = Bf(gx)y = (f . g x) y    
 abc        a  bc                 a b  c                  

我們可以扔掉兩個y s（這被稱為eta-reduction ： Gy=Hy - > G=H ，如果y不出現在H ^1中 ）。 但是，提出這個問題的另一種方式是

BBBfgxy = B(Bf)gxy = ((f .) . g) x y = f (g x y)     -- (.) f == (f .)
-- compare with:       (f .) g x = f (g x)

((f .) . g) xy可能比((.).(.)) fgxy更容易輸入，但是YMMV。

---

¹例如，使用S組合子 ，定義為Sfgx = fx(gx) ，不考慮該規則我們可以寫

Sfgx = fx(gx) = B(fx)gx = (f x . g) x
Sfg = B(fx)g = (f x . g)   --- WRONG, what is "x"?

這是胡說八道。