Question

chainQuery :: (Enum a, Integral a, Ord b) => a -> b -> [c]
chainQuery n min = map length $ filter beatingLength $ map chain [1..n]
  where
    beatingLength :: [a] -> Bool
    beatingLength xs = length xs > min
    chain :: (Integral a) => a -> [a]
    chain n
      | n <= 1 = [n]
      | even n = n:(chain $ div n 2)
      | otherwise = n:(chain $ n * 3 + 1)

1. In the code sample above why isn’t GHC able to deduce that ‘c’ is an Int by looking at the type definition for length?

2. Why does GHC need to know anything about ‘b’ other than that it is an Ord?

3. Is there a better way to write this function?

Answer 1

1. GHC is able to infer [Int] as the result type for the function. The problem is that you’ve claimed in your type signature that it should be more polymorphic, that the result could be a list of any type, which does not make sense since the return value comes from the map length so it must have type [Int]. This is what GHC is complaining about when it says Could not deduce (c ~ Int).

2. You’re comparing min to length xs. The greater-than operator has the type (>) :: (Ord a) => a -> a -> Bool, which means that both sides must be the same type. The type of length xs is Int, so this forces min to be Int as well.

3. Probably. For example, you can map the length before doing the filtering. This makes it easy to use an operator section instead of your beatingLength function. You can also move the parenthesis to save a use of $ to make the code a bit neater.

   chainQuery n min = filter (> min) $ map (length . chain) [1..n]
       where chain n | n <= 1    = [1]
                     | even n    = n : chain (n `div` 2)
                     | otherwise = n : chain (3*n + 1)
   

For reference, the easiest way to solve a problem like this is to remove your type signature and see what type was inferred in GHCi using the :t command. In this case, the inferred type is

*Main> :t chainQuery 
chainQuery :: Integral a => a -> Int -> [Int]