Finding & assembling class dictionaries from GHC plugins?

Thu Nov 7 18:15:05 UTC 2013

On Wed, Nov 6, 2013 at 11:44 PM, Simon Peyton-Jones
<simonpj at microsoft.com>wrote:

>  Well, you are writing a function
>
>                 reify :: CoreExpr -> HsExpr RdrName
>
>
Not exactly. I'm reifying CoreExpr directly to another CoreExpr. (The
target CoreExpr calls into an API for GADT-typed lambda
terms<https://github.com/conal/lambda-ccc/blob/master/src/LambdaCCC/Lambda.hs>.
All works swimmingly as long as I'm able to avoid dictionary construction,
but I'm no longer able to do so.) I haven't explored your suggestion of
translating to HsExpr instead. Do you know of any plugins that work this
way? Do you really believe it would work out? For instance, I wouldn't know
where to insert type annotations, and I'd have to back-translate names. I
imagine there are other challenges I don't foresee.

> It takes as its input a CoreExpr and produces as its output a reification
> of the input.  I don’t see why you need start by converting Core to HsExpr.
> Just write reify directly!
>

I wasn't suggesting converting a CoreExpr to an HsExpr. Rather, I was
wondering out loud how I might get the type-checker's help to generate Core
to find/assemble a Typeable dictionary for a given Core type (since I'm
starting with Core). One idea is translate the core type cty to an HsType
hty, use hty in a very simple HsExpr like "Dict :: Dict hty" (where Dict is
from Ed K's constraints package), use the typechecker to convert that
simple HsExpr to a CoreExpr, and then extract the dictionary-forming
sub-CoreExpr. Or something simpler along the same lines.

Thanks for the help,

-- Conal

>
> Simon
>
>
>
> *From:* conal.elliott at gmail.com [mailto:conal.elliott at gmail.com] *On
> Behalf Of *Conal Elliott
> *Sent:* 07 November 2013 01:08
>
> *To:* Simon Peyton-Jones
> *Cc:* Nicolas Frisby; ghc-devs at haskell.org
> *Subject:* Re: Finding & assembling class dictionaries from GHC plugins?
>
>
>
> Thanks for the suggestion. I hadn't considered backing up to an HsExpr. I
> guess we'd have to start by converting the Core Type to an HsType to form a
> type-annotated HsExpr. Am I on the right track here?
>
> -- Conal
>
>
>
> On Wed, Nov 6, 2013 at 5:59 AM, Simon Peyton-Jones <simonpj at microsoft.com>
> wrote:
>
>  Hmm. One route would be to build a HsExpr (rather than a CoreExpr) for
> the reification of your CoreExpr, and stick that into the maw of the type
> checker.  That would hand off all this dictionary construction to the type
> checker, which is designed for the purpose.
>
>
>
> Simon
>
>
>
> *From:* conal.elliott at gmail.com [mailto:conal.elliott at gmail.com] *On
> Behalf Of *Conal Elliott
> *Sent:* 05 November 2013 23:41
> *To:* Simon Peyton-Jones
> *Cc:* Nicolas Frisby; ghc-devs at haskell.org
> *Subject:* Re: Finding & assembling class dictionaries from GHC plugins?
>
>
>
> Hi Simon,
>
> Here's some context on what I'm after. I'll try to include enough to
> clarify what I'm after, without dragging you into unnecessary detail.
>
> I have a Core expression, which I'm systematically translating to a
> related Core expression. The second one reifies the first one, so that the
> generated code *evaluates* to a run-time (not compile/Core-time)
> representation akin to the original Core expression. In this second
> (reified) representation, I need some run-time representation of types. I
> use Typeable constraints in my representation, and these constraints don't
> appear in the original Core representation. For instance, I have the
> following constructor for function application in a GADT of lambda
> expressions:
>
> > (:^) :: (Typeable a, Typeable b) => E (a -> b) -> E a -> E b
>
> My reification plugin takes a Core application expression, recursively
> reifies the function and argument expressions, and makes an expression that
> applies (:^) to the two recursive results. However--and the point of this
> thread--I also need to come up with Core expressions for the two Typeable
> dictionaries.
>
> So, to clarify my request, given a Core type representation t, I want to
> construct a Core expression that evaluates to the dictionary for Typeable t
> if one exists, or fail if there isn't one. Note that t is not necessarily
> an atomic type; it could instead be something like [(Bool,Int -> String)].
>
> I'm happy to Skype-chat if it'd help.
>
> Thanks,  - Conal
>
>
>
>
>
> On Tue, Nov 5, 2013 at 2:37 PM, Simon Peyton-Jones <simonpj at microsoft.com>
> wrote:
>
>   We just don't know how to start — ie how call the right functions from
> the type checker. Are there any resources explaining the relevant subset of
> the TcRnIf API?
>
> And I for my part don’t know where to start helping you!  Conal wrote
>
>
>
> I don't think I need to construct dictionaries for new Typeable instances.
> I only need to find and assemble *existing* Typeable instances into
> combinations like Typeable [(Bool,Int -> String)], and I don't know how to
> do so in a GHC plug-in
>
>
>
> That’s exactly what the constraint solver does.  (TcSimplify and
> friends.)  But again I need more context.
>
>
>
> I gather you are talking to Pedro too?  He knows a lot about this stuff.
>
>
>
> Also there are a bunch of folk (Luite, Edsko) worked on the new front-end
> plugin stuff, and are much more expert in it than me.
>
>
>
> We could have a skype call if that would help
>
>
>
> S
>
>
>
>
>
> *From:* Nicolas Frisby [mailto:nicolas.frisby at gmail.com]
> *Sent:* 05 November 2013 14:36
> *To:* Simon Peyton-Jones
> *Cc:* ghc-devs at haskell.org; Conal Elliott
> *Subject:* RE: Finding & assembling class dictionaries from GHC plugins?
>
>
>
> On Nov 5, 2013 3:14 AM, "Simon Peyton-Jones" <simonpj at microsoft.com>
> wrote:
>
> >
> > A core-level plug-in can’t generate fresh instances.  There are some new
> plug-in hooks that fit earlier in the pipeline, which can.  Maybe you can
> use that, and generate a data type decl with “deriving Typeable”?
>
> We're willing to do some awkward shoehorning in HERMIT to make this work
> in limited circumstances. (Hopefully including Conal's.)
>
> We just don't know how to start — ie how call the right functions from the
> type checker. Are there any resources explaining the relevant subset of the
> TcRnIf API?
>
> Thanks.
>
> >
> >
> > From: ghc-devs [mailto:ghc-devs-bounces at haskell.org] On Behalf Of Conal
> Elliott
> > Sent: 04 November 2013 20:08
> > To: ghc-devs at haskell.org
> > Subject: Finding & assembling class dictionaries from GHC plugins?
> >
> >
> >
> > I'm working on a GHC plugin (for compiling Haskell to hardware), and I
> need to synthesize Typeable (and maybe other) class dictionaries for a wide
> range of types, including composite types (functions, pairs, lists, etc).
> Can it be done, and how? I think I'm mainly looking for mechanics of
> finding existing class instances (however they're defined) and assembling
> them (for parametrized/composite dictionaries), rather than mechanisms
> specific to Typeable.
> >
> > Thanks, -- Conal
> >
> >
> > _______________________________________________
> > ghc-devs mailing list
> > ghc-devs at haskell.org
> > http://www.haskell.org/mailman/listinfo/ghc-devs
> >
>
>
>
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/ghc-devs/attachments/20131107/d3292cc6/attachment-0001.html>