GHC Core / STG to supercombinators

[Csaba Hruska]

Hello,

I'd like to use GHC as a haskell frontend in a project.
I wonder what is the easiest way to compile Haskell to supercombinators
(top level functions) using GHC as a library.

Is it possible to use the simplifier to transform the parsed Haskell source
to supercombinators? i.e. to do

   - eta expansion
   - closure conversion
   - lambda lifting

Regarding the eta expansion and lambda lifting it seems (according the
comments in simplifier code) it does not guarantee to make these
transformations in every case.
If GHC could transform the Core representation to supercombinators, which
transformation should I use from *CoreToDo*?
https://github.com/ghc/ghc/blob/master/compiler/simplCore/CoreMonad.hs#L107-
L135

I'd like to use GHC as a frontend for my custom code generator which can
handle (lazy) top level functions only.
Is it better to use GHC as a library or is it better to write a compiler
plugin to capture the core representation.
I do not want to optimize the Core at all neither want to use other parts
of GHC's backend (i.e. codegen).
Ideally GHC would typecheck and transform everything to top level function
and my system would do the rest.

Do you know what would be the easiest way to do this? (i.e. via *CoreToDo*
or custom calls for the simplifying functions)

Or would it be simpler to generate top level (lazy) functions from STG?

Regards,
Csaba Hruska
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/ghc-devs/attachments/20180410/7c005655/attachment.html>