Haskell: type variables and generic types

Question

When I mention in the type signature of the function isQuestion the types explicitly, GHCi compiles it perfectly:

isQuestion :: [Char] -> Maybe Bool
isQuestion [] = Nothing
isQuestion xs = Just (last xs == '?')

However, when I turn to 'generic' code, it doesn't work:

isQuestion :: [a] -> Maybe b
isQuestion [] = Nothing
isQuestion xs = Just (last xs == '?')

since I get the below error:

<interactive>:138:17: error:
    * Couldn't match type `b' with `Bool'
      `b' is a rigid type variable bound by
        the type signature for:
          isQuestion :: forall a b. [a] -> Maybe b
        at <interactive>:136:1-28
      Expected type: Maybe b
        Actual type: Maybe Bool
    * In the expression: Just (last xs == '?')
      In an equation for `isQuestion':
          isQuestion xs = Just (last xs == '?')
    * Relevant bindings include
        isQuestion :: [a] -> Maybe b (bound at <interactive>:137:1)

Answer 1

First observation is that

last xs == something

can only work if there is a definition of (==) in scope for the elements of xs. But as the compiler knows nothing about a, there is no such thing. You must narrow a to be the subset of types with equality:

isQuestion :: Eq a => [a] -> Maybe b

The second observation is that something is a Char in your code ('?'), so this method can only ever work when a ≡ Char. Instead, you could add that something as a parameter:

isQuestion :: Eq a => a -> [a] -> Maybe b

Finally, as has been pointed out, you have a concrete return type, i.e. Maybe Bool, as

(==) :: a -> a -> Bool

So your function's signature could be

isQuestion :: Eq a => a -> [a] -> Maybe Bool

Edited this paragraph for clarity Note that, depending on your business logic, you might not want to make a special case of the empty string. If the only thing you care about is whether a string ends with a question mark, then Nothing and Just false would virtually mean the same thing. In that case, your function becomes a "yes or no" question and you can drop the Maybe:

isQuestion :: Eq a => a -> [a] -> Bool
isQuestion x = isSuffixOf [x]

or simply

isQuestion :: String -> Bool
isQuestion = isSuffixOf "?"

Answer 2

Parametric polymorphism is not subtyping or supertyping. It's a statement that the implementation of a value doesn't depend on part of the type. In fact, the implementation works for any choice of type at all.

Your implementation doesn't work for any choice of type. It only works if a is Char and b is Bool. You can tell this because it uses (== '?') in there, which is a function of type Char -> Bool.

Answer 3

The type [a] -> Maybe b is shorthand for forall a b. [a] -> Maybe b. But isQuestion doesn't work for all types a and b, it only works specifically if a is Char and b is Bool.