How to best display type variables with the same name

[Christopher Done]

On 19 October 2016 at 17:00, Simon Peyton Jones simonpj at microsoft.com
<http://mailto:simonpj@microsoft.com> wrote:

I’m afraid I didn’t understand the issue in the link below. It
speaks of “querying the type”, but I’m not sure what that means. A
GHCi session perhaps? Does this relate to the way GHCi displays
types?

I’m a bit lost. A from-the-beginning example, showing steps and
what the unexpected behaviour is would be helpful (to me anyway)

Sure. I’ll explain from top-level down:

   -

   In this case “querying the type” means running the :type-at
   command in Intero (which itself is a fork of GHCi’s codebase around
   GHC 7.10):

   https://github.com/commercialhaskell/intero/blob/master/src/InteractiveUI.hs#L1693-L1713
   It accepts a file name, line-col to line-col span and prints the
   type of that expression/pattern. As you can see in that function it
   uses printForUserModInfo (from GhcMonad), similar to (scroll above)
   the printForUser for GHCi’s regular :type command.
   -

   Where does that info come from? When we load a module in Intero, we
   perform an additional step of “collecting info” here:

   https://github.com/commercialhaskell/intero/blob/master/src/GhciInfo.hs#L73
   That info, for each node in the AST, is ultimately stored in a
   SpanInfo:

   https://github.com/commercialhaskell/intero/blob/master/src/GhciTypes.hs#L28-L39
   Which we then use for :type-at.

So in summary we collect info from tm_typechecked_source, keep that
for later, and then when the user’s editor asks via e.g. :type-at X.hs 1 5
1 7 “what is the type of the thing at this point?” we use
GHC’s regular pretty printing function to print that type.

That actually all works splendidly. For example, if we query

foo g f = maybe g f--  ^ here or   ^ here yields g :: bfoo g f = maybe
g f--    ^ here or   ^ here yields: f :: a -> b

The tricky part arises in this example:
https://github.com/commercialhaskell/intero/issues/280#issuecomment-254784904

Which is that we have two perfectly cromulent types from the AST that
are both a in isolation, but are actually different. They will have
different Unique values in their Name’s and come from different
implicit forall‘s. The question is what’s a good way to communicate
this to the user?

This is partly a “user interface” question, and on the side a “given
an ideal UI, do we have the necessary info the GHC API?”

If it helps, I could probably spend some time making an isolated
module that uses the GHC API to compile a file and then report these
types.

Ciao!
​
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/ghc-devs/attachments/20161021/5d959d17/attachment-0001.html>