函数中的非穷举模式[Haskell]

Question

我必须使函数:: [（（String， String）， Int）]-

这就是我提出的功能：

neighbours pairs@((x1,x2):xs) inputWord
 | pairs == [] = []
 | fst x1 == inputWord = ((snd x1), x2) : (neighbours xs inputWord)
 | snd x1 == inputWord = ((fst x1), x2) : (neighbours xs inputWord)
 | otherwise = (neighbours xs inputWord)

输出应该是一个元组列表，其中的字符串与元组x1中的inputWord以及整数x2成对出现

问题是我得到了我认为不应该存在的非详尽模式。

我试图替换对 == [] = []与xs == [] = []

这使得非穷举模式在列表不为空时消失，但也阻止了函数遍历元组的最后一个元组。

Answer 1

如果您定义一个帮助函数来比较inputWord，那么邻居的定义就变得简单多了：

-- You can use other, more descriptive names instead.
type Foo = ((String, String), Int)
type Bar = (String, Int)

-- If it seems odd that I'm using [Bar] instead of Maybe Bar, see below
myLookup :: String -> Foo -> [Bar]
myLookup s ((s1, s2), i) | s == s1 = [(s2, i)]
                         | s == s2 = [(s1, i)]
                         | otherwise = []

neighbors :: [Foo] -> String -> [Bar]
neighbors [] _ = []
neighbors (x:xs) inputWord = case myLookup inputWord x of
                               []  ->     neighbors xs inputWord
                               [y] -> y : neighbors xs inputWord

可以使用concatMap进一步简化，它只是将应用myLookup inputWord的结果连接到输入的每个元素。

neighbors :: [Foo] -> String -> [Bar]
neighbors xs inputWord = concatMap (myLookup inputWord) xs

考虑到这种模式，我们可以通过使用mapaybayfrom数据中的mapaybay为myLookup切换到使用更严格的mabay-Bar返回类型。可能是而不是concatMap。

import Data.Maybe (mapMaybe)

type Foo = ((String, String), Int)
type Bar = (String, Int)

myLookup :: String -> Foo -> Maybe Bar
myLookup s ((s1, s2), i) | s == s1 = Just (s2, i)
                         | s == s2 = Just (s1, i)
                         | otherwise = Nothing

neighbors :: [Foo] -> String -> [Bar]
neighbors xs inputWord = mapMaybe (myLookup inputWord) xs

Answer 2

您指定的唯一模式是：

neighbours pairs@((x1,x2):xs) inputWord

这意味着这只适用于非空列表。实际上，模式（（x1，x2）：xs）“激发”，因为它与列表的第一个元素（x1，x2）和其余元素的“cons”匹配。

检查pair=[]将永远不会成功，因为模式已经意味着这永远不会是空列表。

我们可以为空列表模式添加一个子句，例如作为要匹配的第一个模式。此外，我们可以通过使用非空列表的（（（x11，x12），x2）：xs）模式来提高代码的可读性。然后，我们不需要使用fst和snd，但可以直接使用x11和x12：

neighbours :: Eq a => [((a, a), b)] -> a -> [(a, b)]
neighbours [] _ = []
neighbours pairs@(((x11, x12),x2):xs) inputWord
    | inputWord == x11 = (x11, x2) : tl
    | inputWord == x12 = (x12, x2) : tl
    | otherwise = tl
    where tl = neighbours xs inputWord

例如：

Prelude> neighbours [(('a', 'b'), 1), (('b', 'a'), 2), (('b', 'b'), 3), (('a', 'a'), 4)] 'a'
[('a',1),('a',2),('a',4)]

然而，这个函数有点“不对称”，因为对于元组中的两个元素，它“更喜欢”第一个元素而不是第二个元素。如果两个项目x11和x12都等于inputWord，则将它们都生成可能更有意义。