[Haskell-beginners] Attribute Grammar and Type signature with Happy

[Julien Lange]

Thanks a lot Stephen, that was really helpful.

FYI, in case you use a Monadic parser (in Happy terms), the type
signature you are looking for is something like this:

MyRule :: { Attrs [MyMonad ()] -> ([MyMonad ()], Attrs MyRuleType) }
	where MyMonad is the type constructor for the monad, and
	      Attrs is the attributetype


You are right and I guess I should give up either Happy or AG with
Happy, but I don't really have (much) time to change the parser at the
moment (and what I want to use the attributes for is quite trivial).

So, if someone could give me more information on the status of AG in
Happy and/or what those type signatures actually mean (if they do at
all) that'd be great (so I can assess the risk of still using this, at
least as a temporary solution).


Cheers,


Julien.

Stephen Tetley wrote:
> Hello Julien
> 
> I've worked out type signatures below for both examples in the Happy
> docs. I'm afraid, I've no idea what what the type signatures actually
> mean, I worked them out simply by hacking.
> 
> I'd rather suggest the AG system within Happy is best avoided, as it
> seems like a proof of concept that didn't get fleshed out. UUAG I
> would highly recommend - its a well maintained and documented AG
> system for Haskell, that has been used for real compilers (Helium,
> UHC/EHC).
> 
> {
> module ABCParser where
> }
> 
> %tokentype { Char }
> 
> %token a { 'a' }
> %token b { 'b' }
> %token c { 'c' }
> %token newline { '\n' }
> 
> %attributetype { Attrs a }
> %attribute value { a }
> %attribute len   { Int }
> 
> %name parse abcstring
> 
> %%
> 
> abcstring :: { Attrs [()] -> ([()], Attrs [Char]) }
> abcstring
>   : alist blist clist newline
>        { $$ = $1 ++ $2 ++ $3
>        ; $2.len = $1.len
>        ; $3.len = $1.len
>        }
> 
> alist :: { Attrs [()] -> ([()], Attrs [Char]) }
> alist
>   : a alist
>        { $$ = $1 : $2
>        ; $$.len = $2.len + 1
>        }
>   |    { $$ = []; $$.len = 0 }
> 
> blist :: { Attrs [()] -> ([()], Attrs [Char]) }
> blist
>   : b blist
>        { $$ = $1 : $2
>        ; $2.len = $$.len - 1
>        }
>   |    { $$ = []
>        ; where failUnless ($$.len == 0) "blist wrong length"
>        }
> 
> clist :: { Attrs [()] -> ([()], Attrs [Char]) }
> clist
>   : c clist
>        { $$ = $1 : $2
>        ; $2.len = $$.len - 1
>        }
>   |    { $$ = []
>        ; where failUnless ($$.len == 0) "clist wrong length"
>        }
> 
> {
> happyError = error "parse error"
> failUnless b msg = if b then () else error msg
> }
> 
> -------------------------------
> 
> {
> module BitsParser (parse) where
> }
> 
> %tokentype { Char }
> 
> %token minus { '-' }
> %token plus  { '+' }
> %token one   { '1' }
> %token zero  { '0' }
> %token newline { '\n' }
> 
> %attributetype { Attrs }
> %attribute value { Integer }
> %attribute pos   { Int }
> 
> %name parse start
> 
> %%
> 
> start :: { Attrs -> ([()],Attrs) }
> start
>    : num newline { $$ = $1 }
> 
> num :: { Attrs -> ([()],Attrs) }
> num
>    : bits        { $$ = $1       ; $1.pos = 0 }
>    | plus bits   { $$ = $2       ; $2.pos = 0 }
>    | minus bits  { $$ = negate $2; $2.pos = 0 }
> 
> bits :: { Attrs -> ([()],Attrs) }
> bits
>    : bit         { $$ = $1
>                  ; $1.pos = $$.pos
>                  }
> 
>    | bits bit    { $$ = $1 + $2
>                  ; $1.pos = $$.pos + 1
>                  ; $2.pos = $$.pos
>                  }
> bit :: { Attrs -> ([()],Attrs) }
> bit
>    : zero        { $$ = 0 }
>    | one         { $$ = 2^($$.pos) }
> 
> {
> happyError = error "parse error"
> }