Haskell `Int->；的幺半群实例解析；Int->；订购`

我计划在明天给Haskell的一篇小介绍中展示一个TypeClass强大的例子

我想我应该仔细检查一下我要展示的内容，因为我不是100%自信

假设我有两个函数：

firstSort :: Int -> Int -> Ordering
firstSort a b = compare (even a) (even b)

secondSort :: Int -> Int -> Ordering
secondSort = compare

现在，由于它们的幺半群实例，我可以组合这两种类型：

sort :: Int -> Int -> Ordering
sort = firstSort <> secondSort

使用。这是通过使用

（Int->Int）

实例化此实例的

a

来完成的。另外，

mappend

的声明让我困惑了一段时间，因为它需要3个参数，而不是2个参数，但是我记得

（a->b）->（a->b）->（a->b）

实际上与

（a->b）->（a->b）->a->b

相同

由于这个实例，我们得到

firstSort-secondSort

是：

\a b -> (firstSort a b) <> (secondSort a b)

与指定的

mappend

一起用于

firstSort

和

secondSort

因此，总的来说，它将把

monoidb=>Monoid（a->b）

实例与

b=Ordering

和

a=（Int->Int）

匹配，然后是

Monoid Ordering

实例

---

是这样吗？

是的。你的结论是正确的

由于

Int->Int->Ordering

是curry，因此可以将其视为一个参数的函数，该参数返回另一个函数。即：

Int -> (Int -> Ordering)

因此，编译器分三步解析

Monoid

实例：

 Value Type               | Monoid Instance
--------------------------|---------------------------
 Int -> (Int -> Ordering) | instance Monoid b => Monoid (a -> b)
 Int -> Ordering          | instance Monoid b => Monoid (a -> b)
 Ordering                 | instance Monoid Ordering

---

让我看看。我不认为您想要的

a

是

（Int->Int）

，因为当没有偏执时，函数类型会关联到右边。在您的案例中，类型是

firstSort :: Int -> (Int -> Bool)
secondSort :: Int -> (Int -> Bool)

所以，这里发生了一些有趣的事情。当你连接这两个函数时，它实际上做了两次！首先，

a

只是第一个

Int

，

b

是

Int->Bool

，所以我们必须使用

Int->Bool

的幺半群结构。但要做到这一点，我们必须再做一次完全相同的事情，

a

是

Int

，而

b

是

Bool

firstSort <> secondSort = \a -> (firstSort a) <> (secondSort a) 
                        = \a -> (\b -> (firstSort a b) <> (secondSort a b))

firstSort secondSort=\a->（firstSort a）（secondSort a）
=\a->（\b->（第一类a b）（第二类a b））

但最终结果仍然与您推导的结果相同：

                        = \a b -> (firstSort a b) <> (secondSort a b)

=\ab->（第一次排序ab）（第二次排序ab）

请不要在没有评论的情况下否决投票，这样我可以改进问题

firstSort <> secondSort = \a -> (firstSort a) <> (secondSort a) 
                        = \a -> (\b -> (firstSort a b) <> (secondSort a b))

                        = \a b -> (firstSort a b) <> (secondSort a b)