为什么要解析错误？缩进？

Question

我写了这段代码：

addNums key num = add [] key num
    where add res a:as b:bs
        | a == [] = res
        | otherwise = add res:(a+b) as bs

在第 3 行，解释器说：

解析错误（可能是不正确的缩进）

无论是代码还是缩进，我都找不到错误。我为每个选项卡放置了四个空格。

注释：

即使这样也无法编译：

addNums key num = add [] key num
    where add res a:as b:bs
            | a == [] = res
            | otherwise = add res:(a+b) as bs

第 2 行：

模式中的解析错误：添加

Answer 1

Haskell 的主要缩进规则是，如果你想在另一行继续定义，它必须比你定义的内容进一步缩进。在这种情况下，add 函数的守卫是 less 缩进的，这就是编译器所抱怨的。

忽略代码中的其他错误，缩进应该是这样的：

addNums key num = add [] key num
    where add res a:as b:bs
            | a == [] = res
            | otherwise = add res:(a+b) as bs

还要注意，缩进的确切数量无关紧要，只有连续行相对于所定义事物的缩进。

您的代码的另一个语法问题是您似乎误解了 Haskell 的优先规则。在 Haskell 中，函数应用程序的绑定比任何运算符都更紧密，因此 add res a:as b:bs 被解析为 (add res a):(as b):bs，而您的意思是 add res (a:as) (b:bs)。

最后的问题是类型错误。 (:) 运算符的类型为a -> [a] -> [a]，这意味着它接受一个元素和一个列表，并产生一个列表。在您的代码res:(a+b) 中，您似乎有相反的情况，因为res 是一个列表，a+b 是元素。由于 Haskell 中没有运算符可以将单个元素附加到列表的 end，因此您必须使用列表连接运算符 (++) :: [a] -> [a] -> [a]：res ++ [a+b]。

您还将 element a 与 list [] 进行比较。这可能不是您的意思，如果列表为空，则模式 (a:as) 将不匹配。最简单的解决方案是添加另一个模式而不是你的守卫。

把所有这些放在一起，这段代码应该能达到你的预期：

addNums key num = add [] key num
    where add res [] _ = res
          add res (a:as) (b:bs) = add (res ++ [a+b]) as bs

附：重复追加到列表的末尾不是很有效。事实上，它是 O(n²)。您可能希望添加到前面，并在完成后反转列表。这是 O(n)。

---

参考资料：

• Indentation
• Pattern matching

Answer 2

出现缩进错误，因为您需要将 where 子句中的模式保护至少缩进到第一个定义（在您的情况下为 add）。

除此之外，由于类型错误，代码仍然无法编译。即 a 不是列表，因此 a == [] 不进行类型检查。此外，您需要更多括号（用于匹配列表的模式和添加的参数）。

你的意思是这样的吗：

addNums key num = add [] key num
    where add res (a:as) (b:bs)
            | as == [] = res
            | otherwise = add (res ++ [a+b]) as bs

编辑： 顺便说一句，我猜你真的想做以下事情：

addNums key num = add [] key num
    where add res (a:as) (b:bs)
           | as == [] = res ++ [a+b]
           | otherwise = add (res ++ [a+b]) as bs

如果是这样，你甚至可以写：addNums = zipWith (+)（虽然有点不同，因为当第二个列表比第一个短时它不会引发模式匹配异常）

Answer 3

第二个问题不是空格问题，您必须将复杂模式 a:as 和 b:bs 括起来，这样您就可以写成 add res (a:as) (b:bs)

用另一种方式来说明空白，它在where 子句中的外观就是它在顶层的外观。你会写：

addNums1 key num = add [] key num

add res (a:as) (b:bs)
  | as == [] = res
  | otherwise = add (res ++ [a+b]) as bs

所以，添加缩进，你会写

 addNums2 key num = add [] key num
   where 
   add res (a:as) (b:bs)
     | as == [] = res
     | otherwise = add (res ++ [a+b]) as bs

但是我们不能取消你的 where 子句的缩进，所以它会在左边距。 （我将其修改为等效的）

addNums key num = add [] key num
  where   
  add res a:as b:bs
| a == [] = res
| otherwise = add res:(a+b) as bs

因为守卫在add的左边；在这里，他们实际上在左边距结束。我建议将下级定义与管理 where 对齐：

woof xs = foldr moo baaaah xs
  where
  moo :: Integer -> Integer -> Integer
  moo x 0 = 17
  moo x y = x * x + y * (y + x + 1)
  baaaah :: Integer
  baaaah = 3

-- *Main> woof [1,2]
-- 529

它不像某些东西那么可爱，但更不容易出错，因为它减少了更多地考虑缩进的认知负担。 （奥列格做到了！）它也会立即避免这个困难。我认为它并不适合任何地方，但这更有吸引力，并且可能使缩进问题更清晰：

 woof xs = foldr moo baaaah xs where
   moo :: Integer -> Integer -> Integer
   moo x 0 = 17
   moo x y = x * x + y * (y + x + 1)
   baaaah :: Integer
   baaaah = 3

然后我们可以看到 where 子句中的定义列表就像 Haskell 模块中的定义列表一样，用“左边距”排列。