Haskell，如何返回列表而不遇到错误

Question

So I'm trying to wrap my head around Haskell with my first project where i have a function encountering an error:

Exception: prelude.head: empty list.

selectNextGuess :: [[Card]] -> [Card]
selectNextGuess lst
    | length lst >= 1250 = lst !! (div (length lst) 2)
    | otherwise = newGuess 
        where fbList = [[feedback x y | x <- lst, y <- lst]]
              valuesList = [(calcValues(group $ sort[feedback y x | y <- lst, y /= x]), x) | x <- lst]
              (_, newGuess) = head(sort valuesList)

Any advice in steering me in the right direction to solve this would be greatly appreciated. Cheers

Answer 1

TL;DR: since a list can be empty, and there is no minimal element in the empty list, the way to return a list without the error is to maybe return a list, or rather to return a Maybe list.

---

If you call selectNextGuess [] , lst inside the function selectNextGuess becomes [] . Then, valuesList = [(calcValues(group $ sort[feedback yx | y <- lst, y /= x]), x) | x <- [] ] = [] valuesList = [(calcValues(group $ sort[feedback yx | y <- lst, y /= x]), x) | x <- [] ] = [] is also an empty list. And then (_, newGuess) = head (sort valuesList) = head (sort []) = head [] is called.

But there is no head element in the empty list. This is what the error message is telling us. You called head with [] , which is forbidden, because it has no answer.

The usual solution is to make this possibility explicit in the data type. We either have just one answer, for a non-empty list, or we have nothing :

data Maybe a =  Just a | Nothing

is such built-in type. So we can use it, and handle the empty lst explicitly:

selectNextGuess :: [[Card]] -> Maybe [Card]
selectNextGuess lst
    | length lst >= 1250 = Just $ lst !! (div (length lst) 2)
    | null lst = Nothing
    | otherwise = Just newGuess 
        where fbList = [[feedback x y | x <- lst, y <- lst]]
              valuesList = [(calcValues(group $ sort[feedback y x | y <- lst, y /= x]), x) 
                            | x <- lst]
              (_, newGuess) = head (sort valuesList)

Using null as a guard like that is a bit of an anti-pattern. We usually achieve the same goal with the explicit pattern in a separate clause, like

selectNextGuess :: [[Card]] -> Maybe [Card]
selectNextGuess [] = Nothing
selectNextGuess lst
    | length lst >= 1250 = Just $ lst !! (div (length lst) 2)
    | otherwise = Just newGuess 
        where ......

Using that head... sort... combination to find the minimal element is perfectly fine. Due to Haskell's lazy evaluation and the library sort being implemented as bottom-up mergesort , it will take O(n) time.

There is also a shorter way to write down the same thing,

....
    | otherwise = listToMaybe . map snd $ sort valuesList       -- or, 
                = listToMaybe [ x | (_, x) <- sort valuesList ]  --  whichever you prefer.
        where fbList = .....
              valuesList = .....

Since there is no more than one value "inside" a Maybe _ , the conversion function listToMaybe already takes just head element, implicitly.

Moreover, it produces Nothing automatically in the empty list [] case. So the explicit pattern clause can be removed, this way.