Holes in GHC

[Sean Leather]

Hi Iavor,

Thank you for your response.

On Wed, Jan 25, 2012 at 17:50, Iavor Diatchki wrote:

> On Wed, Jan 25, 2012 at 7:21 AM, Thijs Alkemade wrote:
> > Also, we have a confusing problem when type checking a module. Above,
> > we showed the result of ":t map __ __" in ghci. However, if we put "f
> > = map __ __" in a module, we get:
> >
> > tcRnModule: [(f.hs:1:9-10, GHC.Prim.Any * -> b),
> > (f.hs:1:12-13, [GHC.Prim.Any *])]
> >
> > If I read GHC.Prim.Any * as forall a. a, then this is not correct: the
> > GHC.Prim.Any * in both holes should have the same type. We assume it
> > shows up because the type that should be there does not occur in the
> > type signature of f (as it's just [b]), but so far we've been unable
> > to figure out why this behavior is different in interactive mode. Does
> > someone have an idea about what to do to avoid the introduction of
> > these GHC.Prim.Any * types?
>
> The type `Any` is just an ordinary monomorphic type, (e.g., like
> Int`).  It is used to stand in for types that "do not matter" and may
> be thought of a special case of defaulting (i.e. resolving type
> ambiguity be selecting concrete types).  How it is used  is probably
> best illustrated with an example (you've found one, but I'll use a
> slightly simpler one).  Consider the expression `null []`.  It clearly
> has the type Bool, because `null` takes a list and returns a Bool, and
> `[]` is a list.  However, there is nothing that forces the list
> elements to be of one type or another, so we cannot infer the full
> type of `[]`---in some sense, the expression `null []` is of type
> `forall a. Bool` where `a` is the type of the list elements.
> Inferring this type would not be useful because we have no way to
> specify what the `a` should be, and furthermore, it does not matter!
> So, whenever GHC infers a type `forall a. P => t` where `a` does not
> appear in `P` or `t`, it knows that the `a` does not matter, so t
> simply defaults it to `Any`.
>

I believe the problem here is that GHC is inferring that a type does not
matter (and thus defaults) when, actually, we want it to matter.

So, imagine this...

Prelude> :t map (__ :: forall a . a) (__ :: forall b . b)

... and trying to find out the types to which 'a' and 'b' are instantiated.
I don't think the types should be Any thanks to the constraints imposed by
'map'.

Regards,
Sean
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/glasgow-haskell-users/attachments/20120125/8aff0868/attachment.htm>