尝试根据Haskell编写函数，并根据-Wall，我需要一个与（_：_：_）匹配的模式_该模式是什么意思，为什么我需要它？

Question

So I wanted to try to make this function myself (multiples everything in a list by 3 and returns a new list):

list = [1,2,3,4,5,6,7,8,9,10]
list2 = [3 * x | x <- list]

And I managed to get this using guards (basically it stops when x reaches the bound of the list):

tripleMultList :: [Int] -> Int -> [Int]
tripleMultList lst x
   | null lst = []
   | length lst - 1 == x = (lst !! x * 3) : []
   | otherwise = (lst !! x * 3) : tripleMultList lst (x + 1)

Then I decided to try to do it with pattern matching:

tripleMultList :: [Int] -> Int -> [Int]
tripleMultList [] x = []
tripleMultList [y] x | x == (length [y] - 1) = [y] !! x : []
tripleMultList [y] x = [y] !! x : tripleMultList [y] (x + 1)

But whenever I'd try to run this function I would get a non exhaustive pattern matching error so I checked ghci -Wall and it said that I needed a pattern matched to

(_:_:_) _ 

which I assume would take the form of

tripleMultList (_:_:_) _ = something

I'm aware that

(_:_:_)

has to do with selecting elements from a list and separating them from the list itself, though I have no idea why this would apply to my function. I also don't know what "_" means or does and how it applies to my function either.

So I guess my question is, what does this pattern mean and why do I need it when I have roughly the same thing in the version of my function which uses a guard and that one works fine?

Answer 1

Your function takes two arguments. GHCI is telling you that you haven't provided a definition for a function call that follows the pattern

tripleMultList (_:_:_) _

ie when the first argument matches the pattern _:_:_ and the second argument matches the pattern _ . The pattern _ matches everything. The pattern _:_:_ matches lists where the first element is anything, the second element is anything, and the rest of the list is anything. In other words, _:_:_ matches lists of at least two elements.

Look at the cases you defined:

tripleMultList [] x = []
tripleMultList [y] x | x == (length [y] - 1) = [y] !! x : []
tripleMultList [y] x = [y] !! x : tripleMultList [y] (x + 1)

That's:

• First argument: empty list; second argument: anything.
• First argument: list with a single element; second argument: anything; only if x == (length [y] - 1) is true.
• First argument: list with a single element; second argument: anything; only if the condition above is not met.

This leaves out the case when the first argument is a list with at least two elements.

If you want to follow the decomposition in your first definition, then you need to use y in the second and third definitions instead of [y] . The pattern y (a variable) matches anything (of the right type) and gives it the name y . The pattern [y] matches any list of one element and gives this element the name y .

Answer 2

You almost never want to use !! , especially not for iterating over a list. Remember the definition of a list:

 data [] a = [] | a : [] a

There are only two patterns you need to match: the empty list ( [] ) and the non-empty list ( x:y ). You have the empty-list case correct: multiplying every element of an empty list yields another empty list.

tripleMultList [] = []

For a non-empty list, you need something only slightly more complicated. You have the first element x and the rest of the elements as y . All you need to do is multiply x by 3, and add it to the list produced by multiplying everything in y by 3:

tripleMultList (x:y) = let x' = 3 * x
                           y' = tripleMultList y
                       in x' : y'

Note that we can generalize this for any operation on x :

doSomething :: (a -> b) -> [a] -> [b]
doSomething _ [] = []
doSomething f (x:y) = let x' = f x
                          y' = doSomething f y
                      in x' : y'

tripleMultList = doSomething (\x -> 3 * x)

This type of operation is so common that doSomething is already defined in Haskell, but it is called map instead.