haskell - 另一个无限类型错误

Question

我正在尝试从九十九个haskell 问题中解决problem 10。 这是我认为是正确的解决方案。

pack 函数（来自问题 9）已经正确。问题出在编码函数上。

pack :: (Eq a) => [a] -> [[a]]
pack [] = []
pack (x:xs) = (x : takeWhile (== x) xs) : (pack $ dropWhile (== x) xs)

encode :: (Eq a) => [a] -> [(Int, a)]
encode [] = []
encode list = (encode' $ head packed) : (encode $ tail packed)
    where packed = pack list
          encode' l = (length l, head l) 

当我从 ghci 加载文件时，这是错误：

encode.hs:6:0: 发生检查：无法构造无限类型：a = [a] 概括“编码”的类型时

第6行是包含encode [] = []的行

我的编码功能有什么问题？我不断检查使用的变量的类型，我相信没有错。

函数使用示例（假设代码工作正常）：

pack "aaaabbbbccccccddddddd"
> ["aaaa","bbbb","cccccc","ddddddd"]
encode "aaaabbbbccccccddddddd"
> [(4,'a'),(4,'b'),(6,'c'),(7,'d')]

Answer 1

这里的递归有点笨拙。最好使用高阶函数。

您已经有一个函数encode' :: [a] -> (Int, a) 对一个子列表进行编码，并且您想要对所有子列表进行编码。将函数应用于列表的每个元素是一种非常常见的模式，它被高阶函数 map :: (a -> b) -> [a] -> [b] 封装。

利用map，我们可以简单地写：

encode :: (Eq a) => [a] -> [(Int, a)]
encode list = map encode' $ pack list
   where encode' xs = (length xs, head xs)

您还可以通过使用列表推导来避免辅助函数：

encode :: (Eq a) => [a] -> [(Int, a)]
encode list = [(length xs, head xs) | xs <- pack list]

一般来说，尽量在适当的地方使用现有的高阶函数，而不是自己进行递归。它更具可读性且不易出错。

Answer 2

encode $ tail packed

我们有

packed :: [[a]]
tail packed :: [[a]]

但我们需要将[a] 传递给encode。

（这样想：list 需要经过pack。packed 是pack 的输出，但在递归调用中会再次传递给pack。）

Answer 3

您的问题是函数 encode 需要“未打包”列表，但您传递的是“打包”列表。

在这里添加类型签名很有帮助，我为encode'添加了一个类型签名

{-# LANGUAGE ScopedTypeVariables #-}

pack :: (Eq a) => [a] -> [[a]]
pack [] = []
pack (x:xs) = (x : takeWhile (== x) xs) : (pack $ dropWhile (== x) xs)

encode :: forall a. (Eq a) => [a] -> [(Int, a)]
encode [] = []
encode list = (encode' $ head packed) : (encode $ tail packed)
    where packed = pack list
          encode' :: [a] -> (Int, a)
          encode' l = (length l, head l)

编译器很快发现错误：

[1 of 1] Compiling Main             ( test.hs, interpreted )

test.hs:9:42:
    Couldn't match type `a' with `[a]'
      `a' is a rigid type variable bound by
          the type signature for encode :: Eq a => [a] -> [(Int, a)]
          at test.hs:8:1
    Expected type: [(Int, a)]
      Actual type: [(Int, [a])]
    In the second argument of `(:)', namely `(encode $ tail packed)'
    In the expression: (encode' $ head packed) : (encode $ tail packed)
Failed, modules loaded: none.

因为这只有在a 与[a] 相同且因此与[[a]] 等相同时才有效。这是一个无限类型错误。或者只是示例中“打包”列表 ([[a]]) 和“未打包”列表 ([a]) 之间的区别。

（为了更好地理解：“打包”列表是应用pack函数后的列表；-)）

编辑：修复了 ScopedTypeVariables 与 ExistentialQuantification 的错误，感谢 John L

Answer 4

您可以对要打包的结果进行模式匹配，而不是使用head 和tail。 然后它看起来像这样：

encode :: (Eq a) => [a] -> [(Int, a)]
encode [] = []
encode list = encode' x : encode xs
   where (x:xs)    = pack list
         encode' l = (length l, head l)

类型错误来自xs 是[[a]] 类型，因为pack 返回[[a]]，但encode 需要[a] 参数。

Answer 5

我同意@hammar 的观点，即高阶函数是处理这个问题的好方法。
不过，以下是对所发生情况的一般解释：

每次我遇到无限类型错误时，都会出现以下形式：
我有一个调用自身的函数，但使用比传递的“更深”* 类型调用自身。

让我们做一个简单的无限类型错误：

*Main> let f (_:xs) = f [xs]

<interactive>:1:19:
    Occurs check: cannot construct the infinite type: t0 = [t0]

让我们分解原因：无法确定f 的类型：如果f :: [a] -> [[a]]，则f [xs] :: [[a]] -> [[[a]]]，它被传递给原来的f，它不能返回[[[a]]] .

---

*我对“更深”的定义：
[[a]] 比[a]“更深”
Constructor (Constructor a) 比Constructor a 更“深”