Question

I’m trying to write a program in Haskell
that gets a list (of integer) and prints out the number of elements that are bigger than the list’s average

So far I tried

getAVG::[Integer]->Double
getAVG x = (fromIntegral (sum x)) / (fromIntegral (length x))
smallerThanAVG:: [Integer]->Integer
smallerThanAVG x = (map (\y -> (if (getAVG x > y) then 1 else 0)) x)

For some reason I’m getting this error

   Couldn't match expected type `Double'
           against inferred type `Integer'
      Expected type: [Double]
      Inferred type: [Integer]
    In the second argument of `map', namely `x'

It could be that I haven’t written the logic correctly, although I think I did..
Ideas?

Answer 1

These errors are the best kind, because they pinpoint where you have made a type error.

So let’s do some manual type inference. Let’s consider the expression:

map (\y -> (if (getAvg x > y) then 1 else 0)) x

There are a few constraints we know off the bat:

map    :: (a -> b) -> [a] -> [b]  -- from definition
(>)    :: Num a => a -> a -> Bool -- from definition
getAvg :: [Integer] -> Double     -- from type declaration
1, 0   :: Num a => a              -- that's how Haskell works
x      :: [Integer]               -- from type declaration of smallerThanAVG

Now let’s look at the larger expressions.

expr1 = getAvg x
expr2 = (expr1 > y)
expr3 = (if expr2 then 1 else 0)
expr4 = (\y -> expr3)
expr5 = map expr4 x

Now let’s work backwards. expr5 is the same as the RHS of smallerThanAVG, so that means it has the same result type as what you’ve declared.

expr5 :: Integer -- wrong

However, this doesn’t match our other constraint: the result of map must be [b] for some b. Integer is definitely not a list (although if you get facetious, it could be coerced into a list of bits). You probably meant to sum that list up.

expr6 = sum expr5

sum :: Num a => [a] -> a

Now let’s work forwards.

expr1 :: Double -- result type of getAvg
y :: Double     -- (>) in expr2 requires both inputs to have the same type
expr4 :: (Integer -> [a]) -- because for `map foo xs` (expr5)
                          -- where xs :: [a], foo must accept input a
y :: Integer    -- y must have the input type of expr4

Herein lies the conflict: y cannot be both a Double and an Integer. I could equivalently restate this as: x cannot be both a [Double] and [Integer], which is what the compiler is saying. So tl;dr, the kicker is that (>) doesn’t compare different types of Nums. The meme for this sort of problem is: “needs more fromIntegral“.

(getAvg x > fromIntegral y)