ghc feature request: core notes

[Hal Daume III]

Simon,

I wasn't suggesting extending the Core datatype.  Part of the Core Exp
datatype is these notes.  From ExternalCore.hs:

> data Exp 
>   ...
>   | Note String Exp
>   ...

My suggestion is simply to allow pragmas to fill in these Note
values.  I've actually implemented it in my copy of GHC and it's a very
very small addition.  It requires essentially modifying slightly the
parser and lexer to accept '{-# CORE' as a pragma and then to pass this
value down through all the passes (typechecking, renaming, etc.).  I think
it's about 20 additional lines of code in all.

It doesn't seem that these get thrown away anywhere in the AbsSyn -> Core
piping process.  I'm not sure the extend to which this de-simplifies
Core.  Currently these Notes are only used to store SCC information for
profiling and INLINE information.

 - Hal

--
Hal Daume III

 "Computer science is no more about computers    | hdaume@isi.edu
  than astronomy is about telescopes." -Dijkstra | www.isi.edu/~hdaume

On Tue, 4 Feb 2003, Simon Peyton-Jones wrote:

> I have to say that I'm not very keen.  There is an annotation facility
> in Core, but it's easy for the notes to be discarded.  So if they are
> conveying important info, it might easily get lost... and if not, what's
> it doing there in the first place.  What do you expect to happen to
> these annotations?
> 
> So just now I'm a bit sceptical.  Core is a data type that I'm trying
> hard to keep simple.  
> 
> Simon
> 
> | -----Original Message-----
> | From: Hal Daume III [mailto:hdaume@ISI.EDU]
> | Sent: 03 February 2003 23:24
> | To: GHC Users Mailing List
> | Subject: ghc feature request: core notes
> | 
> | I'm not sure how "generally useful" this would be, but I would find it
> | useful to be able to attach notes to core expressions from the Haskell
> | code.  The idea being something along the lines of a code annotation
> like
> | a pragma.  For instance, in my Haskell program I would have something
> | like:
> | 
> |   f x y =
> |     case {-# CORE "my first note" #-} g x of
> |       ...
> | 
> | then, the core would come out with, instead of:
> | 
> |   case g x of ...
> | 
> | we would have
> | 
> |   case {note "my first note"} g x of ...
> | 
> | The reason I would find this useful is somewhat obscure, but the basic
> | idea is that I need to be able to both preprocess code and then change
> | core based on how it was preprocessed.  I'd like to send annotations
> like
> | these out of the preprocessor so they can then be picked up later by
> my
> | core transformer.
> | 
> | If this sounds like a good enough idea to go in, but no one has time
> to
> | implement it, I could do it myself (probably), but I thought I'd ask
> the
> | experts first (or if there's anything like this in there currently)...
> | 
> |  - Hal
> | 
> | --
> | Hal Daume III
> | 
> |  "Computer science is no more about computers    | hdaume@isi.edu
> |   than astronomy is about telescopes." -Dijkstra | www.isi.edu/~hdaume
> | 
> | _______________________________________________
> | Glasgow-haskell-users mailing list
> | Glasgow-haskell-users@haskell.org
> | http://www.haskell.org/mailman/listinfo/glasgow-haskell-users
>