Did you get a reply?
I’m not 100% certain of your question, but consider the
bar = show <expr>
for some expression e. In the input to the type type checker the syntax tree
for the RHS will be something like
HsApp (HsVar “show”) <syntax tree for expr>
(The “show” isn’t really a string, it’s the Name for the class method.)
After typechecking the syntax tree is augmented (or “elaborated”) with type and
dictionary application. So in concrete form it might look like
bar = show @Foo dShowFoo <expr>
Because show :: forall a. Show a => a -> String, so show is apply to the type
of its argument, and then to the dictionary.
In HsSyn this part is done with a HsWrapper See TcEvidence.HsWrapper. The
elaborated syntax tree look like
HsApp (HsWrap <wrapper> (HsVar “show”))
<syntax tree for elaborated expr>
The <wrapper> part expresses the type and dictionary application. In this case
it’ll look like
WpEvApp dShowFoo (WpTyApp Foo WpHole)
See the notes with `HsWrapper` in TcEvidence.
Does that help?
It would be great to augment the
https://ghc.haskell.org/trac/ghc/wiki/Commentary with this sort of info
(insofar as it doesn’t have it already). If you augment I can review. Email
is quickly lost.
Simon
From: ghc-devs [mailto:ghc-devs-boun...@haskell.org] On Behalf Of Robin Palotai
Sent: 19 September 2017 06:39
To: GHC developers <ghc-devs@haskell.org>; haskell <haskell-c...@haskell.org>
Subject: Determine instance method from class method callsite
Sorry, I messed up subject and mailing list. Copying to both list now after the
mistake (wanted only ghc-devs for specificity).
Thanks!
2017-09-19 7:36 GMT+02:00 Robin Palotai
<palotai.ro...@gmail.com<mailto:palotai.ro...@gmail.com>>:
Hello GHC devs,
Before inventing the wheel, want to check if there is a GHC API way to look up
the (fully) resolved instance method from a class method.
For example, given a code
data Foo Int deriving Show
bar = show (Foo 3)
when inspecting the Typechecked AST for bar's show call, I would like to get to
the Name / Id of 'show' of the 'Show' typeclass.
I believe I could use splitHsSigmaTy on the HsType of the function call to get
the context, and then evaluate the HsWrapper somehow to find out what instance
dictionary is applied to the class restriction in the context, and then look up
the instance method from the dictionary..
Two questions:
1) Is there maybe functionality for this?
2) If not, is there any guarantee about the constraint order in the context, at
the method call? So I could more easily determine which constraint's
application to look for..
Any hints welcome && Thank you!
Robin
_______________________________________________
ghc-devs mailing list
ghc-devs@haskell.org
http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-devs
