why write type declarations in Haskell?

Question

I am new to Haskell and I am trying to understand why one needs to write type declarations. Since Haskell has type inference, when do I need the first line at all? GHCI seems to generate correct output with I use ':t'

The only example I found so far that seems to need a declaration is the following.

maximum' :: (Ord a) => [a] -> a   maximum' = foldr1 max 

However, if I add "-XNoMonomorphismRestriction" flag declaration is not needed again. Are there specific situations when type inference does not work and one needs to specify types?

Since I could have a bug in type declaration and no direct benefit, I'd rather not write it. Again, I have just started learning Haskell, so please correct me if I am wrong, as I want to develop good habits.

EDIT: It turns out that the Type inference is a double-edged sword section of the Real World Haskell book has a nice discussion of this topic.

Answer 1

• when you have big Haskell programs, having type signatures often gives you better error messages from the compiler
• sometime you can derive what a function does from its name and its signature
• often a function is understandable a lot better with type signatures, e.g. if you make use of currying
• even writing programs gets easier, I often start with type signatures and most functions declared as undefined. It everything compiles I know that my idea seems to fit not too bad. Then I go on and replace undefined by real code

Answer 2

Consider read "5". How can Haskell know the type of read "5"? It can't, because theres no way to resolve the result of the operation, since read is defined as (Read a) => String -> a. a is not dependent on the string, so it must use context.

However usually context is something like Ord or Num so its impossible to determine. This is not the monomorphism restriction but rather another case that can never be handled properly.

Examples:

Does not Work:

read "0.5" putStrLn . show . read $ "0.5" 

Does Work:

read "0.5" :: Float putStrLn . show . (read :: String -> Float) $ "0.5" 

These are necessary because the default Show instance, if I remember correctly, is Int.