Why does the type of a function change when it comes out of a monad in GHCi [duplicate]

Question

This question already has an answer here:

• Why does `peek` with a polymorphic Ptr return GHC.Prim.Any when used with a bind? 1 answer

Something changes about the type of a function when it comes out of a monad.

In GHCI:

> :t map
map :: (a -> b) -> [a] -> [b]
> a <- return map
> :t a
a :: (GHC.Prim.Any -> GHC.Prim.Any)
 -> [GHC.Prim.Any] -> [GHC.Prim.Any]

This change makes it hard to store the function in a higher rank type.

What is happening here and can I make it not happen?

(Also doesn't this violate one of the monad laws?)

Answer 1

First of all, there is no point in doing anything like a <- return map - its the same as let a = map, which works just fine. That said, I don't think that is your question...

---

Checking out the documentation of GHC.Prim.Any which gives us a big hint as to the role of Any.

It's also used to instantiate un-constrained type variables after type checking. For example, length has type

length :: forall a. [a] -> Int 

and the list datacon for the empty list has type

[] :: forall a. [a]

In order to compose these two terms as length [] a type application is required, but there is no constraint on the choice. In this situation GHC uses Any

(In terms of type application syntax, that looks like length @Any ([] @Any *))

The problem is that when GHCi sees x <- return map it tries to desugar it to return map >>= \x -> ... but the ... part is whatever you enter next into GHCi. Normally it would figure out what the type variables of map are going to be instantiated to (or whether they even should be instantiated to anything) based the ..., but since it has nothing there.

Another key point that @sepp2k points out is that x can't be given a polymorphic type because (>>=) expects (on its RHS) a rank-1 function, and that means its argument can't be polymorphic. (Loosening this condition pushes you straight into RankNTypes at which point you lose the ability to infer types reliably.)

Therefore, needing x to be monomorphic and having no information to help it instantiate the type variables that prevent x from being monomorphic, it defaults to using Any. That means that instead of (a -> b) -> [a] -> [b] you get (Any -> Any) -> [Any] -> [Any].