When can eta reduction change a function's type?

Question

What exactly is going on with the following? ``` > let test = map show > :t test test :: [()] -> [String] > :t (map show) (map show) :: Show a => [a] -> [String] ``` I am wondering how I failed to notice this before? I actually encountered the problem with "map fromIntegral" rather than show - my code doesn't compile with the pointfree form, but works fine without eta reduction. Is there a simple explanation of when eta reduction can change the meaning of Haskell code?

Accepted Answer

This is the monomorphism restriction, which applies when a binding doesn't take parameters and allows the binding to be shareable when it otherwise wouldn't be due to polymorphism, on the theory that if you don't give it a parameter you want to treat it as something "constant"-ish (hence shared). You can disable it in `ghci` with `:set -XNoMonomorphismRestriction`; this is often useful in `ghci`, where you often intend such expressions to be fully polymorphic. (In a Haskell source file, make the first line

```
 {-# LANGUAGE NoMonomorphismRestriction #-}
```

instead.)

When can eta reduction change a function's type?

Solution

Problem