Why does signature change after an assignment

Question

Playing around in ghci I got the following expression: unlines . map (\(a,b) -> show a ++ " " ++ show b)

Now when I check it via :t I get:

> :t  unlines . map (\(a,b) -> show a ++ " " ++ show b)
unlines . map (\(a,b) -> show a ++ " " ++ show b)
  :: (Show a, Show a1) => [(a, a1)] -> String

So exactly as expected. But now if I try to assign it to some name, I get a more specific signature than the original one:

> let f = unlines . map (\(a,b) -> show a ++ " " ++ show b)
> :t f
f :: [((), ())] -> String

Why does this happen?

Answer 1

Because of the monomorphism restriction, definitions of the form x = ... (no parameters) are given a monomorphic (i.e. non-polymorphic) type, which usually involves some defaulting as mentioned in the other answer.

To prevent this from happening, either add a type signature to your definition, or disable the monomorphism restriction using :set -XNoMonomorphismRestriction. You can add this to your .ghci file to have it run automatically on startup until it gets disabled by default in GHCi in some future version.

Answer 2

Defaulting rules.

When you type stuff in GHCi, it attempts to apply default types. IIRC, for things with a Num constraint it picks Integer, for Fractional it picks Double, and for everything else it picks ().

If you write this in a Haskell source file and load it into GHCi, this doesn't happen (I believe).

I think you can also say something like default Int to change the defaulting rules on a per-module basis.