推导组成函数的推断类型Haskell：特别是（。）map uncurry

Question

关于推导组合函数的推断类型，这里有很多线程，但是我还是很困惑。 我发现的任何一篇文章都没有给出有关如何统一类型的一般解释。

我的一份考试学习指南中有一个问题，我很难弄清楚。

8）（。）地图非推断的推断类型是什么:: ________

我大多数时候都能够派生推断类型，但我仍然感到困惑。 例如，我知道要获取（。）map uncurry的答案，您需要首先派生地图uncurry的类型。 这我能做

鉴于以下类型

map  :: (a -> b) -> [a] -> [b]
uncurry :: (a -> b -> c) -> (a, b) -> c 

我用uncurry统一了地图中的功能（a-> b）

a = a → b → c
b = (a, b) → c

然后答案是映射[a]-> [b]的另一半，其中有a和b的新值，所以

map uncurry :: [ a -> b -> c ] -> [ (a, b) -> c]

那你需要统一

(.)  :: (b -> c) -> (a -> b) -> a -> c
map uncurry :: [ a -> b -> c ] -> [ (a, b) -> c]

答案应该是

(.) map uncurry :: (a -> b1 -> b) -> [(a, b1)] -> [b]

但我不了解b1的来源或基本情况。 我认为我真正需要的是对类型统一的一般解释。 统一两种类型的方法是什么，如何知道两种类型是否不能统一。

如果有人可以逐步说明如何导出（。）地图，那么我将不胜感激。

Answer 1

派生类型签名的键提示：

1. 确保在开始之前就获得了运算符和函数的优先级。
   请注意，函数应用程序具有最高优先级，并与左侧关联，因此：
2. 第一个参数是最重要的参数-首先处理它，然后
3. 在类型签名中， ->关联到右侧。
4. 有了第一个参数的类型后，请在出现的所有位置替换该类型。

让我们来看一下您的示例。

种类

(.)  :: (b -> c) -> (a -> b) -> a -> c
map  :: (a -> b) -> [a] -> [b]
uncurry :: (a -> b -> c) -> (a, b) -> c 

给每个函数不重叠的类型名称

首先，这是令人困惑，因为有很多的a S和它们并不都意味着同样的事情，所以我打算用新的信件，每次重新命名的类型。

(.)  :: (b -> c) -> (a -> b) -> a -> c
map  :: (d -> e) -> [d] -> [e]
uncurry :: (f -> g -> h) -> (f, g) -> h 

用括号括起来的类型，向右关联

(.)  :: (b -> c) -> ((a -> b) -> a -> c)
map  :: (d -> e) -> ([d] -> [e])
uncurry :: (f -> (g -> h)) -> ((f, g) -> h)

将第一个参数的类型与该参数的整个类型匹配

现在，让我们看一下表达式(.) map uncurry 。 正如您现在已经意识到的那样，放置运算符. 中括号将其转换为遵循正常功能规则的功能，因此(.) map uncurry表示((.) map) uncurry ，要统一的第一个类型是from (.)和map 。

现在(.)具有第一个参数(b->c) ，因此(b->c)必须与map的类型统一：

(.)  :: (   b     ->      c      )   -> ((a -> b) -> (a -> c))
map  ::  (d -> e) -> ([d] -> [e])

当我们用(.)类型替换b ~ (d->e)和c ~ ([d]->[e]) ，我们得到：

(.) :: ((d->e) -> ([d]->[e]))   ->  ((a -> (d->e)) -> (a -> ([d]->[e])))

因此map成为第一个参数，因此当我们提供它时，它会从类型签名中消失，

(.)           map               ::  ((a -> (d->e)) -> (a -> ([d]->[e])))

与ghci或hugs等口译员联系

Hugs> :t (.) map
(map .) :: (a -> b -> c) -> a -> [b] -> [c]

是的-当由于->正确关联而添加方括号时，它们是相同的。

移至下一个参数

好，现在我们有了

(.) map :: ((a -> (d->e)) -> (a -> ([d]->[e])))
uncurry :: (f -> (g -> h)) -> ((f, g) -> h)

现在很想匹配这两个第一个参数，因为它们看起来相同，但是我们当然需要将(.) map的第一个参数与整个 uncurry类型进行uncurry ：

将第一个参数的类型与该参数的整个类型匹配

(.) map :: ((     a      -> (  d   -> e)) -> (a -> ([d]->[e])))
uncurry ::   (f->(g->h)) -> ((f,g) -> h)

给出a ~ (f->(g->h)) ， d ~ (f,g)和e ~ h ：

(.) map :: (((f->(g->h)) -> ((f,g)-> h)) -> ((f->(g->h)) -> ([(f,g)]->[h])))

并将其应用于uncurry给

(.) map            uncurry               :: ((f->(g->h)) -> ([(f,g)]->[h])))

与口译员核对

Hugs> :t (.) map uncurry
map . uncurry :: (a -> b -> c) -> [(a,b)] -> [c]

太好了-我们做到了！

与运营商打交道

如果我们以length . map (.) $ repeat id ++ [] ++ []为例length . map (.) $ repeat id ++ [] ++ [] length . map (.) $ repeat id ++ [] ++ [] ，我们将需要所有这些运算符的固定性，但由于它们具有优先权，因此我们可以首先将函数应用括起来：

length . map (.) $ repeat id ++ [] ++ []
length . (map (.)) $ (repeat id) ++ [] ++ []

优先考虑运算符

使用解释器的:i命令查找运算符的固定性，并按顺序排列，从高到低：

infixr 9 .
infixr 5 ++
infixr 0 $

最高优先级运算符. 首先被包围：

(length . (map (.))) $ (repeat id) ++ [] ++ []

然后是++ ，它与右侧相关：

(length . (map (.))) $ ((repeat id) ++ ([] ++ []))

而且只有$的一种用法，因此我不必理会括号。

如果愿意，可以将++运算符转换为函数(++) ，但是我完全不相信这会对您有所帮助，所以我会保留它，只记得第一个参数在左边。

从嵌套最多的括号开始通常会有所帮助。

Answer 2

(.) map uncurry等效于((.) map) uncurry 。 map函数不适用于uncurry ，它传递给(.) 。 然后，希望将其推断为函数的结果将收到uncurry作为参数。

至于b1来源，请不要忘记类型变量的名称并不重要，只要对所有出现的给定类型变量进行类似的重命名，就可以重命名它们。 所以这：

(.) map uncurry :: (a -> b1 -> b) -> [(a, b1)] -> [b]

等效于此：

(.) map uncurry :: (apple -> pear -> plum) -> [(apple, pear)] -> [plum]