[Haskell-beginners] let in GHCI

[Daniel Fischer]

On Sunday 11 December 2011, 19:14:56, Henry Lockyer wrote:
> Hello Haskellers
> 
> Why is it that in GHCI I can do, for example,
> 
> > let my6 = replicate 6
> > my6 5
> 
> [5,5,5,5,5,5]
> 
> but if I do
> 
> > sort "bav"
> 
> "abv"
> 
> this is ok, but
> 
> > let mySort = sort

It's the monomorphism restriction.
If a value is bound by a simple pattern binding (let val = whatever) 
without a type signature, and if the inferred type is constrained by some 
class requirements, the value gets a monomorphic type, any constrained type 
variables are resolved according to the defaulting rules in
http://www.haskell.org/onlinereport/haskell2010/haskellch4.html#x10-790004.3.4

The first example has no constrained type variables,

replicate :: Int -> a -> [a]

so

my6 :: a -> [a]

is parametric, it works the same for all types. Therefore it remains 
polymorphic.

But

sort :: Ord a => [a] -> [a]

has a constrained type variable, so a value bound like

let mySort = sort

gets a monomorphic type, the constrained type variable a is replaced with a 
fixed type according to defaulting rules.

Since the defaulting rules in the linked section require one of the 
constraining classes to be a numeric class, that binding should be a static 
error by these rules.

However, strict adherence to the defaulting rules would produce a *lot* of 
type errors at the ghci prompt, so ghci has extended defaulting rules, 
resolving more cases, for example, Show, Eq and Ord constraints (with no 
numeric constraint around) are satisfied by instantiating the constrained 
type variable with ().

Thus the binding

> let mySort = sort

at the ghci prompt results in

> :t mySort
mySort :: [()] -> [()]

You get the inferred (most general) type if you

1) bind the value with a function binding (one with at least one argument 
before the =),

> let mySort xs = sort xs

2) give a polymorphic type signature

> let mySort :: Ord a => [a] -> [a]; mySort = sort

3) disable the monomorphism restriction

> :set -XNoMonomorphismRestriction
> let mySort = sort

It's often a good idea to disable the monomorphism restriction at the ghci 
prompt by default, so you might consider doing that in your .ghci file.


If the monomorphism restriction so often leads to surprising and confusing 
results, why does it exist at all?

Because without it, there'd be another surprising and unpleasant result.
If you have something that looks like a constant,

name = value

you'd likely expect it to be evaluated only once. But if name got a 
polymorphic type, it would have to be re-evaluated for every use.
To avoid the unpleasant surprise of bad performance due to re-evaluation, 
we have the monomorphism restriction.

If you give it a polymorphic signature ore bind it via a function binding, 
it's obvious that the value isn't shared and has to be recalculated.

Is that a sufficiently good reason to have the MR?
Opinions differ.