无法将预期类型“[Integer]”与实际类型“Bool”匹配

Question

I'm trying to iterate recursive over the list and checking if all the values are equal 0, the error im getting is:

 * Couldn't match expected type `[Integer]' with actual type `Bool'
    * In the second argument of `(:)', namely `allZero s'
      In the expression: 0 : allZero s
      In an equation for `allZero': allZero (0 : s) = 0 : allZero s

and my code is:

allZero :: [Int] -> Bool
allZero (0:_) = True
allZero (0:s) = 0 : allZero s
allZero (_:s) = False;
allZero _ = False

I don't understand why im getting this error, in the line of allZero (0:s) = 0: allZero s im giving it the correct parameter, a list 's'

Answer 1

The line:

allZero (0:s) = 

does not make much sense, since 0: allZero s means you are constructing a list, a list of numbers. But you want to return a Bool .

Furthermore the line:

allZero  = True

Is incorrect as well, since that means that means that every list that starts with 0 satisfies the functions. But in a list [0,1,4,2,5] , not all numbers are 0 .

We can check this with:

allZero (Num a, Eq a) => [a] -> Bool
allZero [] = True
allZero (0:s) = 
allZero (_:_) = False

We can make use of all:: Foldable f => (a -> Bool) -> fa -> Bool and write this as:

allZero :: (Num a, Eq a, Foldable f) => f a -> Bool
allZero = 

Answer 2

I will try to explain the error and the solution. The solution should be:

allZero :: [Int] -> Bool
allZero [] = True
allZero (x:xs) = (x == 0) && (allZero xs)

Think of the two patterns. First, if there is no elements, all are 0, that has sense, that is the first pattern [] . In the second pattern you ask if the first is 0 and you say that value && all the rest of the elements must be 0 (using recursion)

In your example:

allZero :: [Int] -> Bool
allZero (0:_) = True --Wrong, here you are saying if it start with 0, True, no matter what is next, and that's not correct
allZero (0:s) = 0 : allZero s -- this could be right along side with other patterns
allZero (_:s) = False -- this is wrong by sure, you are saying if a list has at list one element, False
allZero _ = False -- And this one has no sense among the others

You have a lot of patterns, and incorrect. You can change my first answer as the equivalent:

allZero :: [Int] -> Bool
allZero []     = True
allZero (0:xs) = (allZero xs)
allZero _      = False