Haskell 有人能解释一下（（$）（==）1（1+；）0的含义吗

在上一节课上，我遇到了这个无点风格的函数，称为“猫头鹰”

其类型签名为

（a->b->c）->a->（a1->b）->a1->c

相当于

fabcd=ab（cd）

显然，

（（$）（==）1（1+）0

返回

True

因此，我的问题是：

类型签名中的

a1

是什么意思？它与

a

相关吗

（==）

是某种函数等式运算符吗？因为

0（=）0

在GHCi中抛出错误

在这种情况下，

1（1+0

是什么意思？我甚至不明白这是一个有效的表达式

为什么表达式返回

True

a1

只是“另一个类型变量”。它可能意味着任何东西，包括

a

，但不一定意味着任何东西。很可能它与

a

不同

（==）

是

=

类型类中正则相等运算符的“强制前缀”形式。通常您会编写

a==b

，但这只是

（==）ab

的语法糖，

=

的前缀应用程序

1（1+）0

在本上下文中没有任何特殊意义，三个子表达式中的每一个子表达式都是“owl”的独立参数，owl最终需要四个参数

我们可以走过去

((.)$(.)) (==) 1 (1+) 0
===                          [ apply ]
((.)(.)) (==) 1 (1+) 0
===                          [ implicit association ]
((.)(.)(==)) 1 (1+) 0
===                          [ apply the definition: (f.g) x = f (g x) ]
((.) (1 ==)) (1+) 0
===                          [ implicit association ]
((.) (1 ==) (1+))  0
===                          [ apply the definition: (f.g) x = f (g x) ]
1 == (1+0)
===                          [addition]
1 == 1
===                          [equality]
True

---

如前所述，owl相当于函数

f

f a b c d = a b (c d)

也就是说，它将第一个参数，两个参数的函数，应用于第二个参数，将第三个参数的结果应用于第四个参数。对于给定的示例

（$）（==）1（1+）0

，这意味着您首先将

（+1）

应用于

0

，然后使用

（==）

组合

1

和

（1+0）

((.)$(.)) (==) 1 (1+) 0
===                          [ apply ]
((.)(.)) (==) 1 (1+) 0
===                          [ implicit association ]
((.)(.)(==)) 1 (1+) 0
===                          [ apply the definition: (f.g) x = f (g x) ]
((.) (1 ==)) (1+) 0
===                          [ implicit association ]
((.) (1 ==) (1+))  0
===                          [ apply the definition: (f.g) x = f (g x) ]
1 == (1+0)
===                          [addition]
1 == 1
===                          [equality]
True

更广泛地说，您可能认为它是一个函数，它修改了二进制操作

a

，使其第二个参数略有变化

由于

f$x=fx

，我们有

（$）（$）=\ub$\ub=\ub

。它的类型是机械派生的，如

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

1. (.) ::  (b1 -> c1) -> ((a1 -> b1) -> (a1 -> c1))

2. (.) (.) :: {b ~ b1 -> c1, c ~ (a1 -> b1) -> (a1 -> c1)} (a -> b) -> (a -> c)

           :: (a -> b1 -> c1) -> a -> (a1 -> b1) -> (a1 -> c1)
           :: (a -> b  -> c ) -> a -> (a1 -> b ) ->  a1 -> c  

a

和

a1

是两个不同的类型变量，就像

b

和

b1

一样。但是由于最后一个类型中没有

b

或

c

，我们可以将

b1

和

c1

重命名为

b

和

c

，以简化。但不是

a1

我们可以阅读这种类型，实际上：它得到一个二进制函数

x:：a

一个参数值、

g:：a1->b

一元函数和另一个值

y:：a1

，并以唯一可能的方式组合它们，以使类型适合：

    f x       :: b -> c
    g y       :: b
    f x (g y) ::      c

---

其余的问题已经得到了回答。在组合方程中，约化通常更容易遵循，比如

\u B\u B f x g y=\u B（f x）g y=f x（g y）

，只需两次应用

\u B

的定义（我们总是可以根据需要添加任意多的参数）

我明白了，我忘记了强制前缀。我以为这是正常意义上的括号。感谢您的评估演练：

（==）1

是

（1==）

，而不是

（==1）

。这与

==

的默认定义无关，但是……请注意，

（.$）

中的

$

是不必要的；表达式

（）

是完全等效的。