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" }