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"?

这是胡说八道。