练习haskell、类型定义和守卫

Question

第一个问题：
定义一个使用分隔符值将列表连接在一起的函数。
类型定义应该是这样的：

intersperse :: a -> [[a]] -> [a]

分隔符应出现在列表元素之间，但不应跟在最后一个元素之后。
您的函数应如下所示：

ghci> :load Intersperse
[1 of 1] Compiling Main             ( Intersperse.hs, interpreted )
Ok, modules loaded: Main.
ghci> intersperse ',' []
""
ghci> intersperse ',' ["foo"]
"foo"
ghci> intersperse ',' ["foo","bar","baz","quux"]
"foo,bar,baz,quux"

一段时间后我设法解决了它：

intersperse myChar lists
    | lists == []          = ""  
    | otherwise            = attach myChar lists
        where   attach myChar (x:[]) = x 
                attach myChar (x:xs) = x ++ (myChar : []) ++ attach myChar xs 

但是，如您所见，它没有类型定义。
如果我将类型定义放在函数上方，则会出现错误。 为什么？

第二个问题：
在我得到这个解决方案之前，我想在警卫列表中添加另一个警卫。 这个quard应该在第一个后卫之后。 我想检查列表变量中是否只有一个列表，所以我只返回列表变量。 但我不能做那样的守卫（再次，一个错误出现了:-)）：

| lists == (x:[]) = lists

这也没用：

| lists == (_:[]) = lists

为什么为什么为什么？ :-)。

在此之后，我试图让其他后卫：

| length lists == 1    = lists

但它也引发了错误。

（顺便说一句，我不需要那些守卫，因为我发现“where”关键字之后的第一个模式正是我想要的。
这就是我的意思：
附上 myChar (x:[]) = x

但是，我仍然想了解为什么我尝试的 quards 不起作用。 另外，我很幸运地找到了这个解决方案，而且我不认为每次我都会注意到这样的事情:-)

非常感谢:-)。

附言 这个练习来自本书real world haskell。

Answer 1

1. "" 的类型为 [Char]，但您的类型签名说 intersperse 返回 [a]，其中 a 取决于输入类型，因此类型不匹配。

2. 我认为你不能在守卫内部进行模式匹配。

   为了这个守卫

   | length lists == 1    = lists
   

   lists 的类型为 [[a]]，但您应该返回 [a]。也就是说，如果lists 是["foo"]，你想返回"foo"。你不想返回["foo"]。

Answer 2

问题是您的函数没有通用化，它仅适用于字符串（Char 列表）。如果您将第二行更改为

lists == []          = []

你会得到你想要的，尽管由于等于运算符而依赖于Eq 类型类。它甚至适用于字符串，因为所有字符串也是列表，但并非所有列表都是字符串。

顺便说一句，您可以通过使用模式匹配进一步概括您的功能：

intersperse myChar lists = case lists of
    []      -> []
    lists   -> attach myChar lists
    where   attach myChar (x:[]) = x 
            attach myChar (x:xs) = x ++ (myChar : []) ++ attach myChar xs 

或者，更惯用的说法：

intersperse _ [] = []
intersperse x xs = attach x xs
    where   attach myChar (x:[]) = x 
            attach myChar (x:xs) = x ++ (myChar : []) ++ attach myChar xs

并摆脱内部功能：

intersperse _ [] = []
intersperse _ (xs:[]) = xs
intersperse x (xs:xss) = (xs ++ x:intersperse x xss)

关于第二个问题，您在警卫中使用的等号运算符需要双方都有值。您无法与它进行模式匹配。也许您正在寻找的是类似于这里的第二个改进。

Answer 3

这会引发错误。
为什么？ 它和你做的一样，除了你用case of写它。

intersperse :: a -> [[a]] -> [a]
intersperse myChar lists
    | lists == []          = []  
    | otherwise            = attach myChar lists
        where   attach myChar (x:[]) = x 
                attach myChar (x:xs) = x ++ (myChar : []) ++ attach myChar xs

这不会引发错误（这就是你所分割的）：

intersperse :: a -> [[a]] -> [a]
intersperse myChar lists = case lists of
    []      -> []
    lists   -> attach myChar lists
    where   attach myChar (x:[]) = x 
            attach myChar (x:xs) = x ++ (myChar : []) ++ attach myChar xs

但在我的示例中（此处的第一个函数），我将防护更改为您建议的内容，但仍然出现错误。

这是为什么呢？

非常感谢。

Answer 4

它可能是错误的，但它似乎有效

intersperse :: a -> [[a]] -> [a]
intersperse _ []             = []
intersperse separator [xs]   = xs
intersperse separator (x:xs) = x ++ [separator] ++ (intersperse separator xs)