{-# LANGUAGE Rank2Types, GADTs #-}
{-# LANGUAGE ScopedTypeVariables #-}
module AG2AspectAG where
{-# LINE 2 "src-ag/HsToken.ag" #-}
import CommonTypes
import UU.Scanner.Position(Pos)
{-# LINE 10 "src-generated/AG2AspectAG.hs" #-}
{-# LINE 2 "src-ag/Expression.ag" #-}
import UU.Scanner.Position(Pos)
import HsToken
{-# LINE 16 "src-generated/AG2AspectAG.hs" #-}
{-# LINE 2 "src-ag/Patterns.ag" #-}
import UU.Scanner.Position(Pos)
import CommonTypes (ConstructorIdent,Identifier)
{-# LINE 23 "src-generated/AG2AspectAG.hs" #-}
{-# LINE 2 "src-ag/AbstractSyntax.ag" #-}
import Data.Set(Set)
import Data.Map(Map)
import Patterns (Pattern(..),Patterns)
import Expression (Expression(..))
import Macro
import CommonTypes
import ErrorMessages
{-# LINE 35 "src-generated/AG2AspectAG.hs" #-}
{-# LINE 8 "src-ag/AG2AspectAG.ag" #-}
import Options
import Data.Char
import Data.List
import qualified Data.Map as Map
import qualified Data.Set as Set
import Data.Maybe
import Pretty
import PPUtil
import UU.Scanner.Position
import AbstractSyntax
import TokenDef
import CommonTypes
{-# LINE 56 "src-generated/AG2AspectAG.hs" #-}
import Control.Monad.Identity (Identity)
import qualified Control.Monad.Identity
{-# LINE 28 "src-ag/AG2AspectAG.ag" #-}
pragmaAspectAG = pp "{-# LANGUAGE EmptyDataDecls, NoMonomorphismRestriction , TypeSynonymInstances, MultiParamTypeClasses, FlexibleContexts, FlexibleInstances #-}"
{-# LINE 63 "src-generated/AG2AspectAG.hs" #-}
{-# LINE 33 "src-ag/AG2AspectAG.ag" #-}
ppName l = ppListSep "" "" "_" l
{-# LINE 68 "src-generated/AG2AspectAG.hs" #-}
{-# LINE 70 "src-ag/AG2AspectAG.ag" #-}
type FieldMap = [(Identifier, Type)]
type DataTypes = Map.Map NontermIdent (Map.Map ConstructorIdent FieldMap)
{-# LINE 74 "src-generated/AG2AspectAG.hs" #-}
{-# LINE 342 "src-ag/AG2AspectAG.ag" #-}
filterAtts newAtts = filter (\att -> Map.member (identifier att) newAtts)
filterNotAtts newAtts = filter (\att -> not (Map.member (identifier att) newAtts))
defAtt att = "data " >|< attTName att >|< "; " >|< attName att >|< " = proxy :: Proxy " >|< attTName att
attName att = pp $ "att_" ++ att
attTName att = pp $ "Att_" ++ att
defAttRec recPref ppNt atts noGroup =
let recName = ppName [recPref, ppNt]
fields = ppCommas (map (\(a,t) -> ppName [pp a, recName ] >|< " ::" >|< ppShow t) (groupAtts atts noGroup))
in
"data " >|< recName >|< " = " >|< recName >|< " { " >|< fields >|< " }"
groupAtts atts noGroup = (Map.toAscList . Map.difference atts) noGroup
defLocalAtts prodName total actual (l:ls) = ppName [pp l, prodName] >|<
ppListSep "(" ")" "," (replicate (actual-1) "_" ++ "x" : replicate (total-actual) "_") >|<
pp " = x" >-<
defLocalAtts prodName total (actual+1) ls
defLocalAtts _ _ _ [] = empty
{-# LINE 103 "src-generated/AG2AspectAG.hs" #-}
{-# LINE 397 "src-ag/AG2AspectAG.ag" #-}
ntsList att ppNtL = "nts_" ++ att ++ " = " >|< ppListSep "" "" " .*. " ((map fst ppNtL) ++ [pp "hNil"])
filterNts att = filter ( Map.member (identifier att) . snd )
{-# LINE 110 "src-generated/AG2AspectAG.hs" #-}
{-# LINE 455 "src-ag/AG2AspectAG.ag" #-}
data PPRule = PPRule Identifier Identifier Bool ([(Identifier,Type)] -> [Identifier] -> PP_Doc)
ppRule (field,attr) owrt def = PPRule field attr owrt def
ruleField (PPRule field _ _ _ ) = field
ruleAttr (PPRule _ attr _ _ ) = attr
ruleOwrt (PPRule _ _ owrt _ ) = owrt
ruleDef (PPRule _ _ _ def) = def
{-# LINE 122 "src-generated/AG2AspectAG.hs" #-}
{-# LINE 494 "src-ag/AG2AspectAG.ag" #-}
defInhGRule ppNt prodName newNT newProd ch rules inhNoGroup synNoGroup chids locals =
let ppAtt = ppName [pp "inh", prodName]
ppR = ppAtt >|< pp " = inhdefM att_inh nts_group $" >-<
indent 4 "do " >-<
indent 5 "loc <- at loc" >-<
indent 5 "lhs <- at lhs" >-<
indent 5 ch >-<
indent 5 "return $" >-<
indent 6 (foldr (>-<) (pp "emptyRecord") (map (chGRule ppNt prodName rules inhNoGroup synNoGroup chids locals) chids))
in if (newNT || (not newNT && newProd))
then (ppR, [ ppAtt ])
else (empty, [])
chGRule ppNt prodName rules inhNoGroup synNoGroup chids locals (idCh,tp) =
let chName = ppName [pp "ch", pp idCh, prodName]
ppTp = ppShow tp
chRules = ppCommas $ mapGRuleDefs (== idCh) rules inhNoGroup synNoGroup chids locals
in if (isNonterminal tp)
then chName >|< ".=." >-<
indent 1 "InhG_" >|< ppShow tp >|< pp " {" >-<
indent 2 chRules >-<
indent 1 "} .*. "
else empty
defSynGRule ppNt prod newNT newProd ch rules inhNoGroup synNoGroup chids locals =
let ppAtt = ppName [pp "syn", ppNt, pp prod]
ppTAtt = "SynG_" >|< ppNt
ppR = ppAtt >|< pp " = syndefM att_syn $" >-<
indent 4 "do " >-<
indent 5 "loc <- at loc" >-<
indent 5 "lhs <- at lhs" >-<
indent 5 ch >-<
indent 5 "return $" >-<
indent 6 ppTAtt >|< pp " {" >-<
indent 7 (ppCommas $ mapGRuleDefs ((== "lhs") . show) rules inhNoGroup synNoGroup chids locals) >-<
indent 6 "}"
in if (newNT || (not newNT && newProd))
then (ppR, [ ppAtt ])
else (empty, [])
defLocRule ppNt prod newNT newProd ch rules inhNoGroup synNoGroup chids locals =
let ppAtt = ppName [pp "loc", ppNt, pp prod]
ppTAtt = ppName [pp "Loc", ppNt, pp prod]
ppR = ppAtt >|< pp " = locdefM att_loc $" >-<
indent 4 "do " >-<
indent 5 "loc <- at loc" >-<
indent 5 "lhs <- at lhs" >-<
indent 5 ch >-<
indent 5 "return $" >-<
indent 6 (ppListSep "(" ")" "," $ mapLRuleDefs rules inhNoGroup synNoGroup chids locals)
in (ppR, [ ppAtt ])
defInstRules ppNt prod newNT newProd ch rules chids locals
= let ppAsp = ppName [pp "inst", ppNt, pp prod]
instRules = filter ((=="inst") . show . ruleField) rules
ppAtt att = ppListSep "`ext` " "" "_" [pp "inst_ch", pp att, ppNt, pp prod]
in ( ppAsp >|< pp " = emptyRule " >|< (map (ppAtt . ruleAttr) instRules) >-<
(vlist $ map (defInstRule ppNt prod ch chids locals) instRules)
, [ ppAsp ])
defInstRule ppNt prod ch chids locals rule =
let ppAtt = ppName [pp "ch", pp (ruleAttr rule), ppNt, pp prod]
in pp "inst_" >|< ppAtt >|< pp " = instdefM " >|< ppAtt >|< pp " $" >-<
indent 4 "do " >-<
indent 5 "loc <- at loc" >-<
indent 5 "lhs <- at lhs" >-<
indent 5 ch >-<
indent 5 "return $" >-<
indent 6 ((ruleDef rule) chids locals)
defSynRules ppNt prod newNT newProd newAtts ch rules inhNoGroup synNoGroup chids locals
= let synRules = filter ( (=="lhs") . show . ruleField) rules
ngRules = filter ((flip elem synNoGroup) . getName . ruleAttr) synRules
(ppR, ppRA) = unzip $ map (defSynRule True ppNt prod newNT newProd newAtts ch chids locals) ngRules
in (vlist ppR, concat ppRA )
modSynRules ppNt prod newNT newProd newAtts ch rules inhNoGroup synNoGroup chids locals
= let synRules = filter ( (=="lhs") . show . ruleField) rules
ngRules = filter ((flip elem synNoGroup) . getName . ruleAttr) synRules
(ppR, ppRA) = unzip $ map (defSynRule False ppNt prod newNT newProd newAtts ch chids locals) ngRules
in (vlist ppR, concat ppRA )
defSynRule new ppNt prod newNT newProd newAtts ch chids locals rule =
let att = ruleAttr rule
newAtt = Map.member att newAtts
owrt = ruleOwrt rule
ppAtt = ppName [pp att, pp (if new then "syn" else "synM"), ppNt, pp prod]
ppR def = ppAtt >|< pp (" = " ++ def ++ " ") >|< attName (show att) >|< pp " $" >-<
indent 4 "do " >-<
indent 5 "loc <- at loc" >-<
indent 5 "lhs <- at lhs" >-<
indent 5 ch >-<
indent 5 "return $" >-<
indent 6 ((ruleDef rule) chids locals)
in
if new
then if (not owrt && (newNT || (not newNT && newProd) || newAtt))
then (ppR "syndefM", [ ppAtt ])
else (empty, [])
else if owrt
then (ppR "synmodM", [ ppAtt ])
else (empty, [])
defInhRules ppNt prodName newNT newProd newAtts ch rules inhNoGroup synNoGroup chids locals
= let ngRules = filter ((flip elem inhNoGroup) . getName . ruleAttr) rules
(ppR, ppRA) = unzip $ map (defInhRule True ppNt prodName newNT newProd newAtts ch ngRules inhNoGroup synNoGroup chids locals) inhNoGroup
in (vlist ppR, concat ppRA)
modInhRules ppNt prodName newNT newProd newAtts ch rules inhNoGroup synNoGroup chids locals
= let ngRules = filter ((flip elem inhNoGroup) . getName . ruleAttr) rules
(ppR, ppRA) = unzip $ map (defInhRule False ppNt prodName newNT newProd newAtts ch ngRules inhNoGroup synNoGroup chids locals) inhNoGroup
in (vlist ppR, concat ppRA)
defInhRule new ppNt prodName newNT newProd newAtts ch rules inhNoGroup synNoGroup chids locals att =
let ppAtt = ppName [pp att, pp (if new then "inh" else "inhM"),prodName]
newAtt = Map.member (identifier att) newAtts
chRMaybe = map (chRule new ppNt prodName att rules inhNoGroup synNoGroup chids locals) chids
chR = [ x | (Just x) <- chRMaybe ]
ppR def = ppAtt >|< pp (" = " ++ def ++ " ") >|< attName att >|< " nts_" >|< att >|< " $" >-<
indent 4 "do " >-<
indent 5 "loc <- at loc" >-<
indent 5 "lhs <- at lhs" >-<
indent 5 ch >-<
indent 5 "return $" >-<
indent 6 (foldr (>-<) (pp "emptyRecord") chR)
in
if new
then if (newNT || (not newNT && newProd) || newAtt)
then (ppR "inhdefM", [ ppAtt ])
else (empty, [])
else if (not . null) chR
then (ppR "inhmodM", [ ppAtt ])
else (empty, [])
chRule new ppNt prodName att rules inhNoGroup synNoGroup chids locals (idCh,tp) =
let chName = ppName [pp "ch", pp idCh, prodName]
ppTp = ppShow tp
chRule = inhRuleDef new (== idCh) (== att) rules inhNoGroup synNoGroup chids locals
in if (isNonterminal tp && (not . null) chRule)
then Just $ chName >|< ".=. (" >|< chRule >|< ") .*. "
else Nothing
mapLRuleDefs rules inhNoGroup synNoGroup chids locals
= map appSnd $ sortBy cmpField $ filter ((== "loc") . show . ruleField) rules
where cmpField r1 r2 = compare (ruleField r1) (ruleField r2)
appSnd rule = (ruleDef rule) chids locals
mapGRuleDefs filt rules inhNoGroup synNoGroup chids locals
= map appSnd $ sortBy cmpField $ filter (not . (flip elem inhNoGroup) . getName . ruleAttr)
$ filter (not . (flip elem synNoGroup) . getName . ruleAttr)
$ filter ( filt . ruleField) rules
where cmpField r1 r2 = compare (ruleField r1) (ruleField r2)
appSnd rule = (ruleDef rule) chids locals
inhRuleDef new filt1 filt2 rules inhNoGroup synNoGroup chids locals
= map appSnd $ sortBy cmpField $ filter ( (== not new) . ruleOwrt)
$ filter ((flip elem inhNoGroup) . getName . ruleAttr)
$ filter ( filt2 . getName . ruleAttr)
$ filter ( filt1 . ruleField) rules
where cmpField r1 r2 = compare (ruleField r1) (ruleField r2)
appSnd rule = (ruleDef rule) chids locals
defRule ppNt (field,att) noGroup rhs = \chids locals ->
let ppAtt = if (elem (getName att) noGroup)
then empty
else case (show field) of
"lhs" -> att >|< "_" >|< pp "SynG" >|< pp "_" >|< ppNt >|< " = "
"loc" -> empty
"inst" -> empty
otherwise -> att >|< "_" >|< pp "InhG" >|< pp "_" >|<
(maybe (error $ "lhs field " ++ show field ++" is not a child")
ppShow (lookup field chids))
>|< " = "
in ppAtt >|< (rhs noGroup field chids locals)
rhsRule ppNt ppProd tks noGroup field chids locals = vlist . lines2PP . (map (token2PP ppNt ppProd field chids locals noGroup )) $ tks
lines2PP [] = []
lines2PP xs = map line2PP . shiftLeft . getLines $ xs
token2PP ppNt ppProd field chids locals noGroup tk
= case tk of
AGLocal var pos _ -> (pos, if (elem var locals)
then (ppListSep "(" "" "_" [pp var, ppNt, ppProd]) >|< pp " (loc # att_loc)) "
else pp var)
AGField field attr pos _ -> let ppChT = maybe (error $ "rhs field " ++ show field ++ " is not a child") ppShow (lookup field chids)
ppAtt = case (show field) of
"lhs" -> attName "inh"
"loc" -> attName "loc"
otherwise -> attName "syn"
ppSubAtt = case (show field) of
"lhs" -> ppName [pp (getName attr), pp "InhG", ppNt]
"loc" -> ppName [pp (getName attr), ppNt, ppProd]
otherwise -> ppName [pp (getName attr), pp "SynG", ppChT]
in (pos, if ((elem (getName attr) noGroup) && ((show field) /= "loc"))
then pp "(" >|< pp (getName field) >|< " # " >|< attName (getName attr) >|< pp ")"
else pp "(" >|< ppSubAtt >|< " (" >|< pp (getName field) >|< " # " >|< ppAtt >|< ")) ")
HsToken value pos -> (pos, pp value)
CharToken value pos -> (pos, pp (show value))
StrToken value pos -> (pos, pp (show value))
Err mesg pos -> (pos, pp $ " ***" ++ mesg ++ "*** ")
line2PP ts = let f (p,t) r = let ct = column p
in \c -> pp (spaces (ct-c)) >|< t >|< r (length (show t) +ct)
spaces x | x < 0 = ""
| otherwise = replicate x ' '
in foldr f (pp . const "") ts 1
{-# LINE 347 "src-generated/AG2AspectAG.hs" #-}
{-# LINE 721 "src-ag/AG2AspectAG.ag" #-}
ppMacro (Macro con children) = "( atts_" >|< show con >|< ", " >|< ppListSep "" "" " <.> " ppChildren >|<")"
where ppChildren = map ppChild children
ppChild (RuleChild ch n) = chName ch >|< " ==> " >|< ppMacro n
ppChild (ChildChild ch n) = chName ch >|< " --> " >|< n
ppChild (ValueChild ch n) = chName ch >|< " ~~> " >|< n
chName ch = ppName [pp "ch", pp ch, pp con]
{-# LINE 357 "src-generated/AG2AspectAG.hs" #-}
{-# LINE 754 "src-ag/AG2AspectAG.ag" #-}
ppNoGroupAtts syn noGroup = let synatts = Map.keys $ Map.filterWithKey (\att _ -> elem (getName att) noGroup) syn
in map (flip (>|<) "_inh") noGroup ++ map (flip (>|<) "_syn") synatts
ruleName att prodName = ppName [att,prodName]
elemNT a b = False
{-# LINE 367 "src-generated/AG2AspectAG.hs" #-}
{-# LINE 797 "src-ag/AG2AspectAG.ag" #-}
attTypes atts = map (\(a,t) -> "(HCons (LVPair (Proxy Att_" >|< a >|< ") " >|< ppShow t >|< ") ") $ Map.toAscList atts
{-# LINE 372 "src-generated/AG2AspectAG.hs" #-}
{-# LINE 851 "src-ag/AG2AspectAG.ag" #-}
attVars atts = map (\(a,_) -> "_" >|< a >|< " ") $ Map.toAscList atts
attFields atts noGroup ppNt =
let ng = map (\(a,_) -> attName (getName a) >|< " .=. _" >|< a >|< " .*. ") $ Map.toAscList noGroup
g = ppCommas $ map (\(a,_) -> ppName [pp a, pp "InhG",ppNt] >|< "= _" >|< a) $ Map.toAscList $ Map.difference atts noGroup
in "(" >|< ng >|< "att_inh .=. " >|< ppName [pp "InhG", ppNt] >|< " { " >|< g >|< " } .*. emptyRecord)"
{-# LINE 381 "src-generated/AG2AspectAG.hs" #-}
data Inh_Child = Inh_Child { Inh_Child -> Maybe String
ext_Inh_Child :: (Maybe String), Inh_Child -> Map Identifier Attributes
inhMap_Inh_Child :: (Map Identifier Attributes), Inh_Child -> [String]
inhNoGroup_Inh_Child :: ([String]), Inh_Child -> Attributes
newAtts_Inh_Child :: ( Attributes ), Inh_Child -> [String]
o_noGroup_Inh_Child :: ([String]), Inh_Child -> Bool
o_rename_Inh_Child :: (Bool), Inh_Child -> PP_Doc
ppNt_Inh_Child :: (PP_Doc), Inh_Child -> PP_Doc
ppProd_Inh_Child :: (PP_Doc), Inh_Child -> Map Identifier Attributes
synMap_Inh_Child :: (Map Identifier Attributes), Inh_Child -> [String]
synNoGroup_Inh_Child :: ([String]) }
data Syn_Child = Syn_Child { Syn_Child -> FieldMap
idCL_Syn_Child :: ([(Identifier,Type)]), Syn_Child -> [(Identifier, (PP_Doc, PP_Doc))]
ppCSF_Syn_Child :: ([(Identifier,(PP_Doc,PP_Doc))]), Syn_Child -> [PP_Doc]
ppDL_Syn_Child :: ([PP_Doc]), Syn_Child -> PP_Doc
ppL_Syn_Child :: (PP_Doc), Syn_Child -> [PP_Doc]
ppLI_Syn_Child :: ([PP_Doc]), Syn_Child -> PP_Doc
ppR_Syn_Child :: (PP_Doc), Syn_Child -> Attributes
prdInh_Syn_Child :: (Attributes) }
{-# INLINABLE wrap_Child #-}
wrap_Child :: T_Child -> Inh_Child -> (Syn_Child )
wrap_Child :: T_Child -> Inh_Child -> Syn_Child
wrap_Child (T_Child Identity T_Child_s2
act) (Inh_Child Maybe String
_lhsIext Map Identifier Attributes
_lhsIinhMap [String]
_lhsIinhNoGroup Attributes
_lhsInewAtts [String]
_lhsIo_noGroup Bool
_lhsIo_rename PP_Doc
_lhsIppNt PP_Doc
_lhsIppProd Map Identifier Attributes
_lhsIsynMap [String]
_lhsIsynNoGroup) =
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
do T_Child_s2
sem <- Identity T_Child_s2
act
let arg1 :: T_Child_vIn1
arg1 = Maybe String
-> Map Identifier Attributes
-> [String]
-> Attributes
-> [String]
-> Bool
-> PP_Doc
-> PP_Doc
-> Map Identifier Attributes
-> [String]
-> T_Child_vIn1
T_Child_vIn1 Maybe String
_lhsIext Map Identifier Attributes
_lhsIinhMap [String]
_lhsIinhNoGroup Attributes
_lhsInewAtts [String]
_lhsIo_noGroup Bool
_lhsIo_rename PP_Doc
_lhsIppNt PP_Doc
_lhsIppProd Map Identifier Attributes
_lhsIsynMap [String]
_lhsIsynNoGroup
(T_Child_vOut1 FieldMap
_lhsOidCL [(Identifier, (PP_Doc, PP_Doc))]
_lhsOppCSF [PP_Doc]
_lhsOppDL PP_Doc
_lhsOppL [PP_Doc]
_lhsOppLI PP_Doc
_lhsOppR Attributes
_lhsOprdInh) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_Child_s2 -> T_Child_v1
inv_Child_s2 T_Child_s2
sem T_Child_vIn1
arg1)
forall (m :: * -> *) a. Monad m => a -> m a
return (FieldMap
-> [(Identifier, (PP_Doc, PP_Doc))]
-> [PP_Doc]
-> PP_Doc
-> [PP_Doc]
-> PP_Doc
-> Attributes
-> Syn_Child
Syn_Child FieldMap
_lhsOidCL [(Identifier, (PP_Doc, PP_Doc))]
_lhsOppCSF [PP_Doc]
_lhsOppDL PP_Doc
_lhsOppL [PP_Doc]
_lhsOppLI PP_Doc
_lhsOppR Attributes
_lhsOprdInh)
)
{-# INLINE sem_Child #-}
sem_Child :: Child -> T_Child
sem_Child :: Child -> T_Child
sem_Child ( Child Identifier
name_ Type
tp_ ChildKind
kind_ ) = Identifier -> Type -> ChildKind -> T_Child
sem_Child_Child Identifier
name_ Type
tp_ ChildKind
kind_
newtype T_Child = T_Child {
T_Child -> Identity T_Child_s2
attach_T_Child :: Identity (T_Child_s2 )
}
newtype T_Child_s2 = C_Child_s2 {
T_Child_s2 -> T_Child_v1
inv_Child_s2 :: (T_Child_v1 )
}
data T_Child_s3 = C_Child_s3
type T_Child_v1 = (T_Child_vIn1 ) -> (T_Child_vOut1 )
data T_Child_vIn1 = T_Child_vIn1 (Maybe String) (Map Identifier Attributes) ([String]) ( Attributes ) ([String]) (Bool) (PP_Doc) (PP_Doc) (Map Identifier Attributes) ([String])
data T_Child_vOut1 = T_Child_vOut1 ([(Identifier,Type)]) ([(Identifier,(PP_Doc,PP_Doc))]) ([PP_Doc]) (PP_Doc) ([PP_Doc]) (PP_Doc) (Attributes)
{-# NOINLINE sem_Child_Child #-}
sem_Child_Child :: (Identifier) -> (Type) -> (ChildKind) -> T_Child
sem_Child_Child :: Identifier -> Type -> ChildKind -> T_Child
sem_Child_Child Identifier
arg_name_ Type
arg_tp_ ChildKind
arg_kind_ = Identity T_Child_s2 -> T_Child
T_Child (forall (m :: * -> *) a. Monad m => a -> m a
return T_Child_s2
st2) where
{-# NOINLINE st2 #-}
st2 :: T_Child_s2
st2 = let
v1 :: T_Child_v1
v1 :: T_Child_v1
v1 = \ (T_Child_vIn1 Maybe String
_lhsIext Map Identifier Attributes
_lhsIinhMap [String]
_lhsIinhNoGroup Attributes
_lhsInewAtts [String]
_lhsIo_noGroup Bool
_lhsIo_rename PP_Doc
_lhsIppNt PP_Doc
_lhsIppProd Map Identifier Attributes
_lhsIsynMap [String]
_lhsIsynNoGroup) -> ( let
_chnt :: Identifier
_chnt = Identifier -> Type -> Identifier
rule0 Identifier
arg_name_ Type
arg_tp_
_inh :: Attributes
_inh = Identifier -> Map Identifier Attributes -> Attributes
rule1 Identifier
_chnt Map Identifier Attributes
_lhsIinhMap
_syn :: Attributes
_syn = Identifier -> Map Identifier Attributes -> Attributes
rule2 Identifier
_chnt Map Identifier Attributes
_lhsIsynMap
_lhsOprdInh :: Attributes
_lhsOprdInh :: Attributes
_lhsOprdInh = forall {p}. p -> p
rule3 Attributes
_inh
_ppCh :: PP_Doc
_ppCh = Identifier -> PP_Doc
rule4 Identifier
arg_name_
_ppTCh :: PP_Doc
_ppTCh = Type -> PP_Doc
rule5 Type
arg_tp_
_chName :: PP_Doc
_chName = PP_Doc -> PP_Doc -> PP_Doc -> PP_Doc
rule6 PP_Doc
_lhsIppNt PP_Doc
_lhsIppProd PP_Doc
_ppCh
_lhsOppDL :: [PP_Doc]
_lhsOppDL :: [PP_Doc]
_lhsOppDL = PP_Doc -> PP_Doc -> ChildKind -> [PP_Doc]
rule7 PP_Doc
_chName PP_Doc
_ppTCh ChildKind
arg_kind_
_chLabel :: PP_Doc
_chLabel = PP_Doc -> PP_Doc
rule8 PP_Doc
_chName
_chTLabel :: PP_Doc
_chTLabel = PP_Doc -> PP_Doc
rule9 PP_Doc
_chName
_lhsOppL :: PP_Doc
_lhsOppL :: PP_Doc
_lhsOppL = PP_Doc -> PP_Doc -> PP_Doc -> ChildKind -> PP_Doc
rule10 PP_Doc
_chLabel PP_Doc
_chTLabel PP_Doc
_ppTCh ChildKind
arg_kind_
_lhsOppLI :: [PP_Doc]
_lhsOppLI :: [PP_Doc]
_lhsOppLI = forall {a}. a -> a -> [a]
rule11 PP_Doc
_chLabel PP_Doc
_chTLabel
_lhsOppR :: PP_Doc
_lhsOppR :: PP_Doc
_lhsOppR = PP_Doc -> PP_Doc -> Identifier -> PP_Doc
rule12 PP_Doc
_lhsIppNt PP_Doc
_lhsIppProd Identifier
arg_name_
_lhsOidCL :: [(Identifier,Type)]
_lhsOidCL :: FieldMap
_lhsOidCL = forall {a}. a -> Type -> [(a, Type)]
rule13 Identifier
arg_name_ Type
arg_tp_
_lhsOppCSF :: [(Identifier,(PP_Doc,PP_Doc))]
_lhsOppCSF :: [(Identifier, (PP_Doc, PP_Doc))]
_lhsOppCSF = PP_Doc
-> ChildKind
-> Identifier
-> Type
-> [(Identifier, (PP_Doc, PP_Doc))]
rule14 PP_Doc
_chLabel ChildKind
arg_kind_ Identifier
arg_name_ Type
arg_tp_
__result_ :: T_Child_vOut1
__result_ = FieldMap
-> [(Identifier, (PP_Doc, PP_Doc))]
-> [PP_Doc]
-> PP_Doc
-> [PP_Doc]
-> PP_Doc
-> Attributes
-> T_Child_vOut1
T_Child_vOut1 FieldMap
_lhsOidCL [(Identifier, (PP_Doc, PP_Doc))]
_lhsOppCSF [PP_Doc]
_lhsOppDL PP_Doc
_lhsOppL [PP_Doc]
_lhsOppLI PP_Doc
_lhsOppR Attributes
_lhsOprdInh
in T_Child_vOut1
__result_ )
in T_Child_v1 -> T_Child_s2
C_Child_s2 T_Child_v1
v1
{-# INLINE rule0 #-}
{-# LINE 19 "src-ag/DistChildAttr.ag" #-}
rule0 = \ name_ tp_ ->
{-# LINE 19 "src-ag/DistChildAttr.ag" #-}
case tp_ of
NT nt _ _ -> nt
Self -> error ("The type of child " ++ show name_ ++ " should not be a Self type.")
Haskell t -> identifier ""
{-# LINE 452 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule1 #-}
{-# LINE 23 "src-ag/DistChildAttr.ag" #-}
rule1 = \ _chnt ((_lhsIinhMap) :: Map Identifier Attributes) ->
{-# LINE 23 "src-ag/DistChildAttr.ag" #-}
Map.findWithDefault Map.empty _chnt _lhsIinhMap
{-# LINE 458 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule2 #-}
{-# LINE 24 "src-ag/DistChildAttr.ag" #-}
rule2 = \ _chnt ((_lhsIsynMap) :: Map Identifier Attributes) ->
{-# LINE 24 "src-ag/DistChildAttr.ag" #-}
Map.findWithDefault Map.empty _chnt _lhsIsynMap
{-# LINE 464 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule3 #-}
{-# LINE 67 "src-ag/AG2AspectAG.ag" #-}
rule3 = \ _inh ->
{-# LINE 67 "src-ag/AG2AspectAG.ag" #-}
_inh
{-# LINE 470 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule4 #-}
{-# LINE 182 "src-ag/AG2AspectAG.ag" #-}
rule4 = \ name_ ->
{-# LINE 182 "src-ag/AG2AspectAG.ag" #-}
pp name_
{-# LINE 476 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule5 #-}
{-# LINE 183 "src-ag/AG2AspectAG.ag" #-}
rule5 = \ tp_ ->
{-# LINE 183 "src-ag/AG2AspectAG.ag" #-}
ppShow tp_
{-# LINE 482 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule6 #-}
{-# LINE 184 "src-ag/AG2AspectAG.ag" #-}
rule6 = \ ((_lhsIppNt) :: PP_Doc) ((_lhsIppProd) :: PP_Doc) _ppCh ->
{-# LINE 184 "src-ag/AG2AspectAG.ag" #-}
ppName [_ppCh , _lhsIppNt, _lhsIppProd]
{-# LINE 488 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule7 #-}
{-# LINE 242 "src-ag/AG2AspectAG.ag" #-}
rule7 = \ _chName _ppTCh kind_ ->
{-# LINE 242 "src-ag/AG2AspectAG.ag" #-}
case kind_ of
ChildSyntax -> [ _chName >|< pp " :: " >|< _ppTCh ]
_ -> []
{-# LINE 496 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule8 #-}
{-# LINE 285 "src-ag/AG2AspectAG.ag" #-}
rule8 = \ _chName ->
{-# LINE 285 "src-ag/AG2AspectAG.ag" #-}
"ch_" >|< _chName
{-# LINE 502 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule9 #-}
{-# LINE 286 "src-ag/AG2AspectAG.ag" #-}
rule9 = \ _chName ->
{-# LINE 286 "src-ag/AG2AspectAG.ag" #-}
"Ch_" >|< _chName
{-# LINE 508 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule10 #-}
{-# LINE 287 "src-ag/AG2AspectAG.ag" #-}
rule10 = \ _chLabel _chTLabel _ppTCh kind_ ->
{-# LINE 287 "src-ag/AG2AspectAG.ag" #-}
"data " >|< _chTLabel >|< "; " >|< _chLabel >|< pp " = proxy :: " >|<
case kind_ of
ChildSyntax -> "Proxy " >|< "(" >|< _chTLabel >|< ", " >|< _ppTCh >|< ")"
_ -> "SemType " >|< _ppTCh >|< pp " nt => Proxy " >|<
"(" >|< _chTLabel >|< ", nt)"
{-# LINE 518 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule11 #-}
{-# LINE 293 "src-ag/AG2AspectAG.ag" #-}
rule11 = \ _chLabel _chTLabel ->
{-# LINE 293 "src-ag/AG2AspectAG.ag" #-}
[ _chLabel , _chTLabel ]
{-# LINE 524 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule12 #-}
{-# LINE 451 "src-ag/AG2AspectAG.ag" #-}
rule12 = \ ((_lhsIppNt) :: PP_Doc) ((_lhsIppProd) :: PP_Doc) name_ ->
{-# LINE 451 "src-ag/AG2AspectAG.ag" #-}
let chName = ppListSep "" "" "_" [pp name_, _lhsIppNt, _lhsIppProd]
in pp name_ >|< " <- at ch_" >|< chName
{-# LINE 531 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule13 #-}
{-# LINE 489 "src-ag/AG2AspectAG.ag" #-}
rule13 = \ name_ tp_ ->
{-# LINE 489 "src-ag/AG2AspectAG.ag" #-}
[ (name_, removeDeforested tp_ ) ]
{-# LINE 537 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule14 #-}
{-# LINE 827 "src-ag/AG2AspectAG.ag" #-}
rule14 = \ _chLabel kind_ name_ tp_ ->
{-# LINE 827 "src-ag/AG2AspectAG.ag" #-}
let
semC = if (isNonterminal tp_)
then "sem_" >|< ppShow tp_ >|< " _" >|< name_
else "sem_Lit _" >|< name_
in case kind_ of
ChildSyntax -> [(name_, ( _chLabel >|< " .=. (" >|< semC >|< ") .*. "
, _chLabel >|< " .=. _" >|< name_ >|< " .*. "))]
_ -> []
{-# LINE 550 "src-generated/AG2AspectAG.hs" #-}
data Inh_Children = Inh_Children { Inh_Children -> Maybe String
ext_Inh_Children :: (Maybe String), Inh_Children -> Map Identifier Attributes
inhMap_Inh_Children :: (Map Identifier Attributes), Inh_Children -> [String]
inhNoGroup_Inh_Children :: ([String]), Inh_Children -> Attributes
newAtts_Inh_Children :: ( Attributes ), Inh_Children -> [String]
o_noGroup_Inh_Children :: ([String]), Inh_Children -> Bool
o_rename_Inh_Children :: (Bool), Inh_Children -> PP_Doc
ppNt_Inh_Children :: (PP_Doc), Inh_Children -> PP_Doc
ppProd_Inh_Children :: (PP_Doc), Inh_Children -> Map Identifier Attributes
synMap_Inh_Children :: (Map Identifier Attributes), Inh_Children -> [String]
synNoGroup_Inh_Children :: ([String]) }
data Syn_Children = Syn_Children { Syn_Children -> FieldMap
idCL_Syn_Children :: ([(Identifier,Type)]), Syn_Children -> [(Identifier, (PP_Doc, PP_Doc))]
ppCSF_Syn_Children :: ([(Identifier,(PP_Doc,PP_Doc))]), Syn_Children -> [PP_Doc]
ppDL_Syn_Children :: ([PP_Doc]), Syn_Children -> PP_Doc
ppL_Syn_Children :: (PP_Doc), Syn_Children -> [PP_Doc]
ppLI_Syn_Children :: ([PP_Doc]), Syn_Children -> PP_Doc
ppR_Syn_Children :: (PP_Doc), Syn_Children -> Attributes
prdInh_Syn_Children :: (Attributes) }
{-# INLINABLE wrap_Children #-}
wrap_Children :: T_Children -> Inh_Children -> (Syn_Children )
wrap_Children :: T_Children -> Inh_Children -> Syn_Children
wrap_Children (T_Children Identity T_Children_s5
act) (Inh_Children Maybe String
_lhsIext Map Identifier Attributes
_lhsIinhMap [String]
_lhsIinhNoGroup Attributes
_lhsInewAtts [String]
_lhsIo_noGroup Bool
_lhsIo_rename PP_Doc
_lhsIppNt PP_Doc
_lhsIppProd Map Identifier Attributes
_lhsIsynMap [String]
_lhsIsynNoGroup) =
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
do T_Children_s5
sem <- Identity T_Children_s5
act
let arg4 :: T_Children_vIn4
arg4 = Maybe String
-> Map Identifier Attributes
-> [String]
-> Attributes
-> [String]
-> Bool
-> PP_Doc
-> PP_Doc
-> Map Identifier Attributes
-> [String]
-> T_Children_vIn4
T_Children_vIn4 Maybe String
_lhsIext Map Identifier Attributes
_lhsIinhMap [String]
_lhsIinhNoGroup Attributes
_lhsInewAtts [String]
_lhsIo_noGroup Bool
_lhsIo_rename PP_Doc
_lhsIppNt PP_Doc
_lhsIppProd Map Identifier Attributes
_lhsIsynMap [String]
_lhsIsynNoGroup
(T_Children_vOut4 FieldMap
_lhsOidCL [(Identifier, (PP_Doc, PP_Doc))]
_lhsOppCSF [PP_Doc]
_lhsOppDL PP_Doc
_lhsOppL [PP_Doc]
_lhsOppLI PP_Doc
_lhsOppR Attributes
_lhsOprdInh) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_Children_s5 -> T_Children_v4
inv_Children_s5 T_Children_s5
sem T_Children_vIn4
arg4)
forall (m :: * -> *) a. Monad m => a -> m a
return (FieldMap
-> [(Identifier, (PP_Doc, PP_Doc))]
-> [PP_Doc]
-> PP_Doc
-> [PP_Doc]
-> PP_Doc
-> Attributes
-> Syn_Children
Syn_Children FieldMap
_lhsOidCL [(Identifier, (PP_Doc, PP_Doc))]
_lhsOppCSF [PP_Doc]
_lhsOppDL PP_Doc
_lhsOppL [PP_Doc]
_lhsOppLI PP_Doc
_lhsOppR Attributes
_lhsOprdInh)
)
{-# NOINLINE sem_Children #-}
sem_Children :: Children -> T_Children
sem_Children :: Children -> T_Children
sem_Children Children
list = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
Prelude.foldr T_Child -> T_Children -> T_Children
sem_Children_Cons T_Children
sem_Children_Nil (forall a b. (a -> b) -> [a] -> [b]
Prelude.map Child -> T_Child
sem_Child Children
list)
newtype T_Children = T_Children {
T_Children -> Identity T_Children_s5
attach_T_Children :: Identity (T_Children_s5 )
}
newtype T_Children_s5 = C_Children_s5 {
T_Children_s5 -> T_Children_v4
inv_Children_s5 :: (T_Children_v4 )
}
data T_Children_s6 = C_Children_s6
type T_Children_v4 = (T_Children_vIn4 ) -> (T_Children_vOut4 )
data T_Children_vIn4 = T_Children_vIn4 (Maybe String) (Map Identifier Attributes) ([String]) ( Attributes ) ([String]) (Bool) (PP_Doc) (PP_Doc) (Map Identifier Attributes) ([String])
data T_Children_vOut4 = T_Children_vOut4 ([(Identifier,Type)]) ([(Identifier,(PP_Doc,PP_Doc))]) ([PP_Doc]) (PP_Doc) ([PP_Doc]) (PP_Doc) (Attributes)
{-# NOINLINE sem_Children_Cons #-}
sem_Children_Cons :: T_Child -> T_Children -> T_Children
sem_Children_Cons :: T_Child -> T_Children -> T_Children
sem_Children_Cons T_Child
arg_hd_ T_Children
arg_tl_ = Identity T_Children_s5 -> T_Children
T_Children (forall (m :: * -> *) a. Monad m => a -> m a
return T_Children_s5
st5) where
{-# NOINLINE st5 #-}
st5 :: T_Children_s5
st5 = let
v4 :: T_Children_v4
v4 :: T_Children_v4
v4 = \ (T_Children_vIn4 Maybe String
_lhsIext Map Identifier Attributes
_lhsIinhMap [String]
_lhsIinhNoGroup Attributes
_lhsInewAtts [String]
_lhsIo_noGroup Bool
_lhsIo_rename PP_Doc
_lhsIppNt PP_Doc
_lhsIppProd Map Identifier Attributes
_lhsIsynMap [String]
_lhsIsynNoGroup) -> ( let
_hdX2 :: T_Child_s2
_hdX2 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Child -> Identity T_Child_s2
attach_T_Child (T_Child
arg_hd_))
_tlX5 :: T_Children_s5
_tlX5 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Children -> Identity T_Children_s5
attach_T_Children (T_Children
arg_tl_))
(T_Child_vOut1 FieldMap
_hdIidCL [(Identifier, (PP_Doc, PP_Doc))]
_hdIppCSF [PP_Doc]
_hdIppDL PP_Doc
_hdIppL [PP_Doc]
_hdIppLI PP_Doc
_hdIppR Attributes
_hdIprdInh) = T_Child_s2 -> T_Child_v1
inv_Child_s2 T_Child_s2
_hdX2 (Maybe String
-> Map Identifier Attributes
-> [String]
-> Attributes
-> [String]
-> Bool
-> PP_Doc
-> PP_Doc
-> Map Identifier Attributes
-> [String]
-> T_Child_vIn1
T_Child_vIn1 Maybe String
_hdOext Map Identifier Attributes
_hdOinhMap [String]
_hdOinhNoGroup Attributes
_hdOnewAtts [String]
_hdOo_noGroup Bool
_hdOo_rename PP_Doc
_hdOppNt PP_Doc
_hdOppProd Map Identifier Attributes
_hdOsynMap [String]
_hdOsynNoGroup)
(T_Children_vOut4 FieldMap
_tlIidCL [(Identifier, (PP_Doc, PP_Doc))]
_tlIppCSF [PP_Doc]
_tlIppDL PP_Doc
_tlIppL [PP_Doc]
_tlIppLI PP_Doc
_tlIppR Attributes
_tlIprdInh) = T_Children_s5 -> T_Children_v4
inv_Children_s5 T_Children_s5
_tlX5 (Maybe String
-> Map Identifier Attributes
-> [String]
-> Attributes
-> [String]
-> Bool
-> PP_Doc
-> PP_Doc
-> Map Identifier Attributes
-> [String]
-> T_Children_vIn4
T_Children_vIn4 Maybe String
_tlOext Map Identifier Attributes
_tlOinhMap [String]
_tlOinhNoGroup Attributes
_tlOnewAtts [String]
_tlOo_noGroup Bool
_tlOo_rename PP_Doc
_tlOppNt PP_Doc
_tlOppProd Map Identifier Attributes
_tlOsynMap [String]
_tlOsynNoGroup)
_lhsOppDL :: [PP_Doc]
_lhsOppDL :: [PP_Doc]
_lhsOppDL = [PP_Doc] -> [PP_Doc] -> [PP_Doc]
rule15 [PP_Doc]
_hdIppDL [PP_Doc]
_tlIppDL
_lhsOidCL :: [(Identifier,Type)]
_lhsOidCL :: FieldMap
_lhsOidCL = FieldMap -> FieldMap -> FieldMap
rule16 FieldMap
_hdIidCL FieldMap
_tlIidCL
_lhsOppCSF :: [(Identifier,(PP_Doc,PP_Doc))]
_lhsOppCSF :: [(Identifier, (PP_Doc, PP_Doc))]
_lhsOppCSF = [(Identifier, (PP_Doc, PP_Doc))]
-> [(Identifier, (PP_Doc, PP_Doc))]
-> [(Identifier, (PP_Doc, PP_Doc))]
rule17 [(Identifier, (PP_Doc, PP_Doc))]
_hdIppCSF [(Identifier, (PP_Doc, PP_Doc))]
_tlIppCSF
_lhsOppL :: PP_Doc
_lhsOppL :: PP_Doc
_lhsOppL = PP_Doc -> PP_Doc -> PP_Doc
rule18 PP_Doc
_hdIppL PP_Doc
_tlIppL
_lhsOppLI :: [PP_Doc]
_lhsOppLI :: [PP_Doc]
_lhsOppLI = [PP_Doc] -> [PP_Doc] -> [PP_Doc]
rule19 [PP_Doc]
_hdIppLI [PP_Doc]
_tlIppLI
_lhsOppR :: PP_Doc
_lhsOppR :: PP_Doc
_lhsOppR = PP_Doc -> PP_Doc -> PP_Doc
rule20 PP_Doc
_hdIppR PP_Doc
_tlIppR
_lhsOprdInh :: Attributes
_lhsOprdInh :: Attributes
_lhsOprdInh = Attributes -> Attributes -> Attributes
rule21 Attributes
_hdIprdInh Attributes
_tlIprdInh
_hdOext :: Maybe String
_hdOext = Maybe String -> Maybe String
rule22 Maybe String
_lhsIext
_hdOinhMap :: Map Identifier Attributes
_hdOinhMap = Map Identifier Attributes -> Map Identifier Attributes
rule23 Map Identifier Attributes
_lhsIinhMap
_hdOinhNoGroup :: [String]
_hdOinhNoGroup = [String] -> [String]
rule24 [String]
_lhsIinhNoGroup
_hdOnewAtts :: Attributes
_hdOnewAtts = Attributes -> Attributes
rule25 Attributes
_lhsInewAtts
_hdOo_noGroup :: [String]
_hdOo_noGroup = [String] -> [String]
rule26 [String]
_lhsIo_noGroup
_hdOo_rename :: Bool
_hdOo_rename = Bool -> Bool
rule27 Bool
_lhsIo_rename
_hdOppNt :: PP_Doc
_hdOppNt = PP_Doc -> PP_Doc
rule28 PP_Doc
_lhsIppNt
_hdOppProd :: PP_Doc
_hdOppProd = PP_Doc -> PP_Doc
rule29 PP_Doc
_lhsIppProd
_hdOsynMap :: Map Identifier Attributes
_hdOsynMap = Map Identifier Attributes -> Map Identifier Attributes
rule30 Map Identifier Attributes
_lhsIsynMap
_hdOsynNoGroup :: [String]
_hdOsynNoGroup = [String] -> [String]
rule31 [String]
_lhsIsynNoGroup
_tlOext :: Maybe String
_tlOext = Maybe String -> Maybe String
rule32 Maybe String
_lhsIext
_tlOinhMap :: Map Identifier Attributes
_tlOinhMap = Map Identifier Attributes -> Map Identifier Attributes
rule33 Map Identifier Attributes
_lhsIinhMap
_tlOinhNoGroup :: [String]
_tlOinhNoGroup = [String] -> [String]
rule34 [String]
_lhsIinhNoGroup
_tlOnewAtts :: Attributes
_tlOnewAtts = Attributes -> Attributes
rule35 Attributes
_lhsInewAtts
_tlOo_noGroup :: [String]
_tlOo_noGroup = [String] -> [String]
rule36 [String]
_lhsIo_noGroup
_tlOo_rename :: Bool
_tlOo_rename = Bool -> Bool
rule37 Bool
_lhsIo_rename
_tlOppNt :: PP_Doc
_tlOppNt = PP_Doc -> PP_Doc
rule38 PP_Doc
_lhsIppNt
_tlOppProd :: PP_Doc
_tlOppProd = PP_Doc -> PP_Doc
rule39 PP_Doc
_lhsIppProd
_tlOsynMap :: Map Identifier Attributes
_tlOsynMap = Map Identifier Attributes -> Map Identifier Attributes
rule40 Map Identifier Attributes
_lhsIsynMap
_tlOsynNoGroup :: [String]
_tlOsynNoGroup = [String] -> [String]
rule41 [String]
_lhsIsynNoGroup
__result_ :: T_Children_vOut4
__result_ = FieldMap
-> [(Identifier, (PP_Doc, PP_Doc))]
-> [PP_Doc]
-> PP_Doc
-> [PP_Doc]
-> PP_Doc
-> Attributes
-> T_Children_vOut4
T_Children_vOut4 FieldMap
_lhsOidCL [(Identifier, (PP_Doc, PP_Doc))]
_lhsOppCSF [PP_Doc]
_lhsOppDL PP_Doc
_lhsOppL [PP_Doc]
_lhsOppLI PP_Doc
_lhsOppR Attributes
_lhsOprdInh
in T_Children_vOut4
__result_ )
in T_Children_v4 -> T_Children_s5
C_Children_s5 T_Children_v4
v4
{-# INLINE rule15 #-}
{-# LINE 238 "src-ag/AG2AspectAG.ag" #-}
rule15 = \ ((_hdIppDL) :: [PP_Doc]) ((_tlIppDL) :: [PP_Doc]) ->
{-# LINE 238 "src-ag/AG2AspectAG.ag" #-}
_hdIppDL ++ _tlIppDL
{-# LINE 635 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule16 #-}
rule16 = \ ((_hdIidCL) :: [(Identifier,Type)]) ((_tlIidCL) :: [(Identifier,Type)]) ->
_hdIidCL ++ _tlIidCL
{-# INLINE rule17 #-}
rule17 = \ ((_hdIppCSF) :: [(Identifier,(PP_Doc,PP_Doc))]) ((_tlIppCSF) :: [(Identifier,(PP_Doc,PP_Doc))]) ->
_hdIppCSF ++ _tlIppCSF
{-# INLINE rule18 #-}
rule18 = \ ((_hdIppL) :: PP_Doc) ((_tlIppL) :: PP_Doc) ->
_hdIppL >-< _tlIppL
{-# INLINE rule19 #-}
rule19 = \ ((_hdIppLI) :: [PP_Doc]) ((_tlIppLI) :: [PP_Doc]) ->
_hdIppLI ++ _tlIppLI
{-# INLINE rule20 #-}
rule20 = \ ((_hdIppR) :: PP_Doc) ((_tlIppR) :: PP_Doc) ->
_hdIppR >-< _tlIppR
{-# INLINE rule21 #-}
rule21 = \ ((_hdIprdInh) :: Attributes) ((_tlIprdInh) :: Attributes) ->
_hdIprdInh `Map.union` _tlIprdInh
{-# INLINE rule22 #-}
rule22 = \ ((_lhsIext) :: Maybe String) ->
_lhsIext
{-# INLINE rule23 #-}
rule23 = \ ((_lhsIinhMap) :: Map Identifier Attributes) ->
_lhsIinhMap
{-# INLINE rule24 #-}
rule24 = \ ((_lhsIinhNoGroup) :: [String]) ->
_lhsIinhNoGroup
{-# INLINE rule25 #-}
rule25 = \ ((_lhsInewAtts) :: Attributes ) ->
_lhsInewAtts
{-# INLINE rule26 #-}
rule26 = \ ((_lhsIo_noGroup) :: [String]) ->
_lhsIo_noGroup
{-# INLINE rule27 #-}
rule27 = \ ((_lhsIo_rename) :: Bool) ->
_lhsIo_rename
{-# INLINE rule28 #-}
rule28 = \ ((_lhsIppNt) :: PP_Doc) ->
_lhsIppNt
{-# INLINE rule29 #-}
rule29 = \ ((_lhsIppProd) :: PP_Doc) ->
_lhsIppProd
{-# INLINE rule30 #-}
rule30 = \ ((_lhsIsynMap) :: Map Identifier Attributes) ->
_lhsIsynMap
{-# INLINE rule31 #-}
rule31 = \ ((_lhsIsynNoGroup) :: [String]) ->
_lhsIsynNoGroup
{-# INLINE rule32 #-}
rule32 = \ ((_lhsIext) :: Maybe String) ->
_lhsIext
{-# INLINE rule33 #-}
rule33 = \ ((_lhsIinhMap) :: Map Identifier Attributes) ->
_lhsIinhMap
{-# INLINE rule34 #-}
rule34 = \ ((_lhsIinhNoGroup) :: [String]) ->
_lhsIinhNoGroup
{-# INLINE rule35 #-}
rule35 = \ ((_lhsInewAtts) :: Attributes ) ->
_lhsInewAtts
{-# INLINE rule36 #-}
rule36 = \ ((_lhsIo_noGroup) :: [String]) ->
_lhsIo_noGroup
{-# INLINE rule37 #-}
rule37 = \ ((_lhsIo_rename) :: Bool) ->
_lhsIo_rename
{-# INLINE rule38 #-}
rule38 = \ ((_lhsIppNt) :: PP_Doc) ->
_lhsIppNt
{-# INLINE rule39 #-}
rule39 = \ ((_lhsIppProd) :: PP_Doc) ->
_lhsIppProd
{-# INLINE rule40 #-}
rule40 = \ ((_lhsIsynMap) :: Map Identifier Attributes) ->
_lhsIsynMap
{-# INLINE rule41 #-}
rule41 = \ ((_lhsIsynNoGroup) :: [String]) ->
_lhsIsynNoGroup
{-# NOINLINE sem_Children_Nil #-}
sem_Children_Nil :: T_Children
sem_Children_Nil :: T_Children
sem_Children_Nil = Identity T_Children_s5 -> T_Children
T_Children (forall (m :: * -> *) a. Monad m => a -> m a
return T_Children_s5
st5) where
{-# NOINLINE st5 #-}
st5 :: T_Children_s5
st5 = let
v4 :: T_Children_v4
v4 :: T_Children_v4
v4 = \ (T_Children_vIn4 Maybe String
_lhsIext Map Identifier Attributes
_lhsIinhMap [String]
_lhsIinhNoGroup Attributes
_lhsInewAtts [String]
_lhsIo_noGroup Bool
_lhsIo_rename PP_Doc
_lhsIppNt PP_Doc
_lhsIppProd Map Identifier Attributes
_lhsIsynMap [String]
_lhsIsynNoGroup) -> ( let
_lhsOppDL :: [PP_Doc]
_lhsOppDL :: [PP_Doc]
_lhsOppDL = forall {a}. () -> [a]
rule42 ()
_lhsOidCL :: [(Identifier,Type)]
_lhsOidCL :: FieldMap
_lhsOidCL = forall {a}. () -> [a]
rule43 ()
_lhsOppCSF :: [(Identifier,(PP_Doc,PP_Doc))]
_lhsOppCSF :: [(Identifier, (PP_Doc, PP_Doc))]
_lhsOppCSF = forall {a}. () -> [a]
rule44 ()
_lhsOppL :: PP_Doc
_lhsOppL :: PP_Doc
_lhsOppL = () -> PP_Doc
rule45 ()
_lhsOppLI :: [PP_Doc]
_lhsOppLI :: [PP_Doc]
_lhsOppLI = forall {a}. () -> [a]
rule46 ()
_lhsOppR :: PP_Doc
_lhsOppR :: PP_Doc
_lhsOppR = () -> PP_Doc
rule47 ()
_lhsOprdInh :: Attributes
_lhsOprdInh :: Attributes
_lhsOprdInh = forall {k} {a}. () -> Map k a
rule48 ()
__result_ :: T_Children_vOut4
__result_ = FieldMap
-> [(Identifier, (PP_Doc, PP_Doc))]
-> [PP_Doc]
-> PP_Doc
-> [PP_Doc]
-> PP_Doc
-> Attributes
-> T_Children_vOut4
T_Children_vOut4 FieldMap
_lhsOidCL [(Identifier, (PP_Doc, PP_Doc))]
_lhsOppCSF [PP_Doc]
_lhsOppDL PP_Doc
_lhsOppL [PP_Doc]
_lhsOppLI PP_Doc
_lhsOppR Attributes
_lhsOprdInh
in T_Children_vOut4
__result_ )
in T_Children_v4 -> T_Children_s5
C_Children_s5 T_Children_v4
v4
{-# INLINE rule42 #-}
{-# LINE 239 "src-ag/AG2AspectAG.ag" #-}
rule42 = \ (_ :: ()) ->
{-# LINE 239 "src-ag/AG2AspectAG.ag" #-}
[]
{-# LINE 743 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule43 #-}
rule43 = \ (_ :: ()) ->
[]
{-# INLINE rule44 #-}
rule44 = \ (_ :: ()) ->
[]
{-# INLINE rule45 #-}
rule45 = \ (_ :: ()) ->
empty
{-# INLINE rule46 #-}
rule46 = \ (_ :: ()) ->
[]
{-# INLINE rule47 #-}
rule47 = \ (_ :: ()) ->
empty
{-# INLINE rule48 #-}
rule48 = \ (_ :: ()) ->
Map.empty
data Inh_Expression = Inh_Expression { Inh_Expression -> PP_Doc
ppNt_Inh_Expression :: (PP_Doc), Inh_Expression -> PP_Doc
ppProd_Inh_Expression :: (PP_Doc) }
data Syn_Expression = Syn_Expression { Syn_Expression
-> [String] -> Identifier -> FieldMap -> [Identifier] -> PP_Doc
ppRE_Syn_Expression :: ([String] -> Identifier -> [(Identifier,Type)] -> [Identifier] -> PP_Doc) }
{-# INLINABLE wrap_Expression #-}
wrap_Expression :: T_Expression -> Inh_Expression -> (Syn_Expression )
wrap_Expression :: T_Expression -> Inh_Expression -> Syn_Expression
wrap_Expression (T_Expression Identity T_Expression_s8
act) (Inh_Expression PP_Doc
_lhsIppNt PP_Doc
_lhsIppProd) =
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
do T_Expression_s8
sem <- Identity T_Expression_s8
act
let arg7 :: T_Expression_vIn7
arg7 = PP_Doc -> PP_Doc -> T_Expression_vIn7
T_Expression_vIn7 PP_Doc
_lhsIppNt PP_Doc
_lhsIppProd
(T_Expression_vOut7 [String] -> Identifier -> FieldMap -> [Identifier] -> PP_Doc
_lhsOppRE) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_Expression_s8 -> T_Expression_v7
inv_Expression_s8 T_Expression_s8
sem T_Expression_vIn7
arg7)
forall (m :: * -> *) a. Monad m => a -> m a
return (([String] -> Identifier -> FieldMap -> [Identifier] -> PP_Doc)
-> Syn_Expression
Syn_Expression [String] -> Identifier -> FieldMap -> [Identifier] -> PP_Doc
_lhsOppRE)
)
{-# INLINE sem_Expression #-}
sem_Expression :: Expression -> T_Expression
sem_Expression :: Expression -> T_Expression
sem_Expression ( Expression Pos
pos_ [HsToken]
tks_ ) = Pos -> [HsToken] -> T_Expression
sem_Expression_Expression Pos
pos_ [HsToken]
tks_
newtype T_Expression = T_Expression {
T_Expression -> Identity T_Expression_s8
attach_T_Expression :: Identity (T_Expression_s8 )
}
newtype T_Expression_s8 = C_Expression_s8 {
T_Expression_s8 -> T_Expression_v7
inv_Expression_s8 :: (T_Expression_v7 )
}
data T_Expression_s9 = C_Expression_s9
type T_Expression_v7 = (T_Expression_vIn7 ) -> (T_Expression_vOut7 )
data T_Expression_vIn7 = T_Expression_vIn7 (PP_Doc) (PP_Doc)
data T_Expression_vOut7 = T_Expression_vOut7 ([String] -> Identifier -> [(Identifier,Type)] -> [Identifier] -> PP_Doc)
{-# NOINLINE sem_Expression_Expression #-}
sem_Expression_Expression :: (Pos) -> ([HsToken]) -> T_Expression
sem_Expression_Expression :: Pos -> [HsToken] -> T_Expression
sem_Expression_Expression Pos
_ [HsToken]
arg_tks_ = Identity T_Expression_s8 -> T_Expression
T_Expression (forall (m :: * -> *) a. Monad m => a -> m a
return T_Expression_s8
st8) where
{-# NOINLINE st8 #-}
st8 :: T_Expression_s8
st8 = let
v7 :: T_Expression_v7
v7 :: T_Expression_v7
v7 = \ (T_Expression_vIn7 PP_Doc
_lhsIppNt PP_Doc
_lhsIppProd) -> ( let
_lhsOppRE :: [String] -> Identifier -> [(Identifier,Type)] -> [Identifier] -> PP_Doc
_lhsOppRE :: [String] -> Identifier -> FieldMap -> [Identifier] -> PP_Doc
_lhsOppRE = forall {p}.
PP_Doc
-> PP_Doc
-> [HsToken]
-> [String]
-> p
-> FieldMap
-> [Identifier]
-> PP_Doc
rule49 PP_Doc
_lhsIppNt PP_Doc
_lhsIppProd [HsToken]
arg_tks_
__result_ :: T_Expression_vOut7
__result_ = ([String] -> Identifier -> FieldMap -> [Identifier] -> PP_Doc)
-> T_Expression_vOut7
T_Expression_vOut7 [String] -> Identifier -> FieldMap -> [Identifier] -> PP_Doc
_lhsOppRE
in T_Expression_vOut7
__result_ )
in T_Expression_v7 -> T_Expression_s8
C_Expression_s8 T_Expression_v7
v7
{-# INLINE rule49 #-}
{-# LINE 484 "src-ag/AG2AspectAG.ag" #-}
rule49 = \ ((_lhsIppNt) :: PP_Doc) ((_lhsIppProd) :: PP_Doc) tks_ ->
{-# LINE 484 "src-ag/AG2AspectAG.ag" #-}
rhsRule _lhsIppNt _lhsIppProd tks_
{-# LINE 810 "src-generated/AG2AspectAG.hs" #-}
data Inh_Grammar = Inh_Grammar { Inh_Grammar
-> (Set Identifier, DataTypes,
Map Identifier (Attributes, Attributes))
agi_Inh_Grammar :: ((Set NontermIdent, DataTypes, Map NontermIdent (Attributes, Attributes))), Inh_Grammar -> Maybe String
ext_Inh_Grammar :: (Maybe String), Inh_Grammar -> Options
options_Inh_Grammar :: (Options) }
data Syn_Grammar = Syn_Grammar { Syn_Grammar -> PP_Doc
imp_Syn_Grammar :: (PP_Doc), Syn_Grammar -> PP_Doc
pp_Syn_Grammar :: (PP_Doc) }
{-# INLINABLE wrap_Grammar #-}
wrap_Grammar :: T_Grammar -> Inh_Grammar -> (Syn_Grammar )
wrap_Grammar :: T_Grammar -> Inh_Grammar -> Syn_Grammar
wrap_Grammar (T_Grammar Identity T_Grammar_s11
act) (Inh_Grammar (Set Identifier, DataTypes,
Map Identifier (Attributes, Attributes))
_lhsIagi Maybe String
_lhsIext Options
_lhsIoptions) =
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
do T_Grammar_s11
sem <- Identity T_Grammar_s11
act
let arg10 :: T_Grammar_vIn10
arg10 = (Set Identifier, DataTypes,
Map Identifier (Attributes, Attributes))
-> Maybe String -> Options -> T_Grammar_vIn10
T_Grammar_vIn10 (Set Identifier, DataTypes,
Map Identifier (Attributes, Attributes))
_lhsIagi Maybe String
_lhsIext Options
_lhsIoptions
(T_Grammar_vOut10 PP_Doc
_lhsOimp PP_Doc
_lhsOpp) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_Grammar_s11 -> T_Grammar_v10
inv_Grammar_s11 T_Grammar_s11
sem T_Grammar_vIn10
arg10)
forall (m :: * -> *) a. Monad m => a -> m a
return (PP_Doc -> PP_Doc -> Syn_Grammar
Syn_Grammar PP_Doc
_lhsOimp PP_Doc
_lhsOpp)
)
{-# INLINE sem_Grammar #-}
sem_Grammar :: Grammar -> T_Grammar
sem_Grammar :: Grammar -> T_Grammar
sem_Grammar ( Grammar TypeSyns
typeSyns_ UseMap
useMap_ Derivings
derivings_ Set Identifier
wrappers_ Nonterminals
nonts_ PragmaMap
pragmas_ AttrOrderMap
manualAttrOrderMap_ ParamMap
paramMap_ ContextMap
contextMap_ QuantMap
quantMap_ UniqueMap
uniqueMap_ Map Identifier (Map Identifier (Map Identifier [Expression]))
augmentsMap_ Map Identifier (Map Identifier (Map Identifier [Expression]))
aroundsMap_ Map
Identifier
(Map
Identifier (Map Identifier (Identifier, [Identifier], Expression)))
mergeMap_ ) = TypeSyns
-> UseMap
-> Derivings
-> Set Identifier
-> T_Nonterminals
-> PragmaMap
-> AttrOrderMap
-> ParamMap
-> ContextMap
-> QuantMap
-> UniqueMap
-> Map Identifier (Map Identifier (Map Identifier [Expression]))
-> Map Identifier (Map Identifier (Map Identifier [Expression]))
-> Map
Identifier
(Map
Identifier (Map Identifier (Identifier, [Identifier], Expression)))
-> T_Grammar
sem_Grammar_Grammar TypeSyns
typeSyns_ UseMap
useMap_ Derivings
derivings_ Set Identifier
wrappers_ ( Nonterminals -> T_Nonterminals
sem_Nonterminals Nonterminals
nonts_ ) PragmaMap
pragmas_ AttrOrderMap
manualAttrOrderMap_ ParamMap
paramMap_ ContextMap
contextMap_ QuantMap
quantMap_ UniqueMap
uniqueMap_ Map Identifier (Map Identifier (Map Identifier [Expression]))
augmentsMap_ Map Identifier (Map Identifier (Map Identifier [Expression]))
aroundsMap_ Map
Identifier
(Map
Identifier (Map Identifier (Identifier, [Identifier], Expression)))
mergeMap_
newtype T_Grammar = T_Grammar {
T_Grammar -> Identity T_Grammar_s11
attach_T_Grammar :: Identity (T_Grammar_s11 )
}
newtype T_Grammar_s11 = C_Grammar_s11 {
T_Grammar_s11 -> T_Grammar_v10
inv_Grammar_s11 :: (T_Grammar_v10 )
}
data T_Grammar_s12 = C_Grammar_s12
type T_Grammar_v10 = (T_Grammar_vIn10 ) -> (T_Grammar_vOut10 )
data T_Grammar_vIn10 = T_Grammar_vIn10 ((Set NontermIdent, DataTypes, Map NontermIdent (Attributes, Attributes))) (Maybe String) (Options)
data T_Grammar_vOut10 = T_Grammar_vOut10 (PP_Doc) (PP_Doc)
{-# NOINLINE sem_Grammar_Grammar #-}
sem_Grammar_Grammar :: (TypeSyns) -> (UseMap) -> (Derivings) -> (Set NontermIdent) -> T_Nonterminals -> (PragmaMap) -> (AttrOrderMap) -> (ParamMap) -> (ContextMap) -> (QuantMap) -> (UniqueMap) -> (Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) -> (Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) -> (Map NontermIdent (Map ConstructorIdent (Map Identifier (Identifier, [Identifier], Expression)))) -> T_Grammar
sem_Grammar_Grammar :: TypeSyns
-> UseMap
-> Derivings
-> Set Identifier
-> T_Nonterminals
-> PragmaMap
-> AttrOrderMap
-> ParamMap
-> ContextMap
-> QuantMap
-> UniqueMap
-> Map Identifier (Map Identifier (Map Identifier [Expression]))
-> Map Identifier (Map Identifier (Map Identifier [Expression]))
-> Map
Identifier
(Map
Identifier (Map Identifier (Identifier, [Identifier], Expression)))
-> T_Grammar
sem_Grammar_Grammar TypeSyns
arg_typeSyns_ UseMap
_ Derivings
arg_derivings_ Set Identifier
_ T_Nonterminals
arg_nonts_ PragmaMap
_ AttrOrderMap
_ ParamMap
_ ContextMap
_ QuantMap
_ UniqueMap
_ Map Identifier (Map Identifier (Map Identifier [Expression]))
_ Map Identifier (Map Identifier (Map Identifier [Expression]))
_ Map
Identifier
(Map
Identifier (Map Identifier (Identifier, [Identifier], Expression)))
_ = Identity T_Grammar_s11 -> T_Grammar
T_Grammar (forall (m :: * -> *) a. Monad m => a -> m a
return T_Grammar_s11
st11) where
{-# NOINLINE st11 #-}
st11 :: T_Grammar_s11
st11 = let
v10 :: T_Grammar_v10
v10 :: T_Grammar_v10
v10 = \ (T_Grammar_vIn10 (Set Identifier, DataTypes,
Map Identifier (Attributes, Attributes))
_lhsIagi Maybe String
_lhsIext Options
_lhsIoptions) -> ( let
_nontsX26 :: T_Nonterminals_s26
_nontsX26 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Nonterminals -> Identity T_Nonterminals_s26
attach_T_Nonterminals (T_Nonterminals
arg_nonts_))
(T_Nonterminals_vOut25 Set Identifier
_nontsIextendedNTs Map Identifier Attributes
_nontsIinhMap' PP_Doc
_nontsIppA [PP_Doc]
_nontsIppAI PP_Doc
_nontsIppCata PP_Doc
_nontsIppD [PP_Doc]
_nontsIppDI PP_Doc
_nontsIppL [PP_Doc]
_nontsIppLI [(PP_Doc, Attributes)]
_nontsIppNtL PP_Doc
_nontsIppR PP_Doc
_nontsIppSF PP_Doc
_nontsIppW Map Identifier Attributes
_nontsIsynMap') = T_Nonterminals_s26 -> T_Nonterminals_v25
inv_Nonterminals_s26 T_Nonterminals_s26
_nontsX26 (Derivings
-> Maybe String
-> Map Identifier Attributes
-> Attributes
-> Set Identifier
-> DataTypes
-> [String]
-> Bool
-> Map Identifier Attributes
-> TypeSyns
-> T_Nonterminals_vIn25
T_Nonterminals_vIn25 Derivings
_nontsOderivs Maybe String
_nontsOext Map Identifier Attributes
_nontsOinhMap Attributes
_nontsOnewAtts Set Identifier
_nontsOnewNTs DataTypes
_nontsOnewProds [String]
_nontsOo_noGroup Bool
_nontsOo_rename Map Identifier Attributes
_nontsOsynMap TypeSyns
_nontsOtSyns)
_nontsOinhMap :: Map Identifier Attributes
_nontsOinhMap = Map Identifier Attributes -> Map Identifier Attributes
rule50 Map Identifier Attributes
_nontsIinhMap'
_nontsOsynMap :: Map Identifier Attributes
_nontsOsynMap = Map Identifier Attributes -> Map Identifier Attributes
rule51 Map Identifier Attributes
_nontsIsynMap'
_nontsOo_rename :: Bool
_nontsOo_rename = Options -> Bool
rule52 Options
_lhsIoptions
_o_noGroup :: [String]
_o_noGroup = Options -> [String]
rule53 Options
_lhsIoptions
_nontsOo_noGroup :: [String]
_nontsOo_noGroup = forall {p}. p -> p
rule54 [String]
_o_noGroup
_newAtts :: Attributes
_newAtts = (Set Identifier, DataTypes,
Map Identifier (Attributes, Attributes))
-> Attributes
rule55 (Set Identifier, DataTypes,
Map Identifier (Attributes, Attributes))
_lhsIagi
_nontsOnewAtts :: Attributes
_nontsOnewAtts = forall {p}. p -> p
rule56 Attributes
_newAtts
_newProds :: DataTypes
_newProds = (Set Identifier, DataTypes,
Map Identifier (Attributes, Attributes))
-> DataTypes
rule57 (Set Identifier, DataTypes,
Map Identifier (Attributes, Attributes))
_lhsIagi
_nontsOnewProds :: DataTypes
_nontsOnewProds = forall {p}. p -> p
rule58 DataTypes
_newProds
_nontsOnewNTs :: Set Identifier
_nontsOnewNTs = (Set Identifier, DataTypes,
Map Identifier (Attributes, Attributes))
-> Set Identifier -> Set Identifier
rule59 (Set Identifier, DataTypes,
Map Identifier (Attributes, Attributes))
_lhsIagi Set Identifier
_nontsIextendedNTs
_lhsOimp :: PP_Doc
_lhsOimp :: PP_Doc
_lhsOimp = Maybe String
-> [PP_Doc] -> [PP_Doc] -> [PP_Doc] -> [PP_Doc] -> PP_Doc
rule60 Maybe String
_lhsIext [PP_Doc]
_nontsIppDI [PP_Doc]
_nontsIppLI [PP_Doc]
_ppAI [PP_Doc]
_ppANT
_lhsOpp :: PP_Doc
_lhsOpp :: PP_Doc
_lhsOpp = Options
-> PP_Doc
-> PP_Doc
-> PP_Doc
-> PP_Doc
-> PP_Doc
-> PP_Doc
-> PP_Doc
-> PP_Doc
rule61 Options
_lhsIoptions PP_Doc
_nontsIppCata PP_Doc
_nontsIppD PP_Doc
_nontsIppL PP_Doc
_nontsIppSF PP_Doc
_nontsIppW PP_Doc
_ppA PP_Doc
_ppR
_nontsOderivs :: Derivings
_nontsOderivs = forall {p}. p -> p
rule62 Derivings
arg_derivings_
_nontsOtSyns :: TypeSyns
_nontsOtSyns = forall {p}. p -> p
rule63 TypeSyns
arg_typeSyns_
_ppA :: PP_Doc
_ppA = forall {a}.
Maybe String -> Map Identifier a -> PP_Doc -> [String] -> PP_Doc
rule64 Maybe String
_lhsIext Attributes
_newAtts PP_Doc
_nontsIppA [String]
_o_noGroup
_ppAI :: [PP_Doc]
_ppAI = forall {a}.
Maybe String
-> Map Identifier a -> [PP_Doc] -> [String] -> [PP_Doc]
rule65 Maybe String
_lhsIext Attributes
_newAtts [PP_Doc]
_nontsIppAI [String]
_o_noGroup
_ppANT :: [PP_Doc]
_ppANT = forall {a}. Map Identifier a -> [String] -> [PP_Doc]
rule66 Attributes
_newAtts [String]
_o_noGroup
_ppNtL :: [(PP_Doc, Attributes)]
_ppNtL = [(PP_Doc, Attributes)] -> [(PP_Doc, Attributes)]
rule67 [(PP_Doc, Attributes)]
_nontsIppNtL
_ppR :: PP_Doc
_ppR = forall {a} {a}.
Map Identifier a
-> PP_Doc -> [String] -> [(PP_Doc, Map Identifier a)] -> PP_Doc
rule68 Attributes
_newAtts PP_Doc
_nontsIppR [String]
_o_noGroup [(PP_Doc, Attributes)]
_ppNtL
_nontsOext :: Maybe String
_nontsOext = Maybe String -> Maybe String
rule69 Maybe String
_lhsIext
__result_ :: T_Grammar_vOut10
__result_ = PP_Doc -> PP_Doc -> T_Grammar_vOut10
T_Grammar_vOut10 PP_Doc
_lhsOimp PP_Doc
_lhsOpp
in T_Grammar_vOut10
__result_ )
in T_Grammar_v10 -> T_Grammar_s11
C_Grammar_s11 T_Grammar_v10
v10
{-# INLINE rule50 #-}
{-# LINE 15 "src-ag/DistChildAttr.ag" #-}
rule50 = \ ((_nontsIinhMap') :: Map Identifier Attributes) ->
{-# LINE 15 "src-ag/DistChildAttr.ag" #-}
_nontsIinhMap'
{-# LINE 881 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule51 #-}
{-# LINE 16 "src-ag/DistChildAttr.ag" #-}
rule51 = \ ((_nontsIsynMap') :: Map Identifier Attributes) ->
{-# LINE 16 "src-ag/DistChildAttr.ag" #-}
_nontsIsynMap'
{-# LINE 887 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule52 #-}
{-# LINE 43 "src-ag/AG2AspectAG.ag" #-}
rule52 = \ ((_lhsIoptions) :: Options) ->
{-# LINE 43 "src-ag/AG2AspectAG.ag" #-}
rename _lhsIoptions
{-# LINE 893 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule53 #-}
{-# LINE 47 "src-ag/AG2AspectAG.ag" #-}
rule53 = \ ((_lhsIoptions) :: Options) ->
{-# LINE 47 "src-ag/AG2AspectAG.ag" #-}
sort $ noGroup _lhsIoptions
{-# LINE 899 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule54 #-}
{-# LINE 48 "src-ag/AG2AspectAG.ag" #-}
rule54 = \ _o_noGroup ->
{-# LINE 48 "src-ag/AG2AspectAG.ag" #-}
_o_noGroup
{-# LINE 905 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule55 #-}
{-# LINE 80 "src-ag/AG2AspectAG.ag" #-}
rule55 = \ ((_lhsIagi) :: (Set NontermIdent, DataTypes, Map NontermIdent (Attributes, Attributes))) ->
{-# LINE 80 "src-ag/AG2AspectAG.ag" #-}
case _lhsIagi of
(_,_,atts) -> ( Map.unions . (\(a,b) -> a++b) . unzip . Map.elems) atts
{-# LINE 912 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule56 #-}
{-# LINE 82 "src-ag/AG2AspectAG.ag" #-}
rule56 = \ _newAtts ->
{-# LINE 82 "src-ag/AG2AspectAG.ag" #-}
_newAtts
{-# LINE 918 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule57 #-}
{-# LINE 88 "src-ag/AG2AspectAG.ag" #-}
rule57 = \ ((_lhsIagi) :: (Set NontermIdent, DataTypes, Map NontermIdent (Attributes, Attributes))) ->
{-# LINE 88 "src-ag/AG2AspectAG.ag" #-}
case _lhsIagi of
(_,prods,_) -> prods
{-# LINE 925 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule58 #-}
{-# LINE 90 "src-ag/AG2AspectAG.ag" #-}
rule58 = \ _newProds ->
{-# LINE 90 "src-ag/AG2AspectAG.ag" #-}
_newProds
{-# LINE 931 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule59 #-}
{-# LINE 112 "src-ag/AG2AspectAG.ag" #-}
rule59 = \ ((_lhsIagi) :: (Set NontermIdent, DataTypes, Map NontermIdent (Attributes, Attributes))) ((_nontsIextendedNTs) :: Set NontermIdent) ->
{-# LINE 112 "src-ag/AG2AspectAG.ag" #-}
case _lhsIagi of
(newNTs,_,_) -> Set.difference newNTs _nontsIextendedNTs
{-# LINE 938 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule60 #-}
{-# LINE 127 "src-ag/AG2AspectAG.ag" #-}
rule60 = \ ((_lhsIext) :: Maybe String) ((_nontsIppDI) :: [PP_Doc]) ((_nontsIppLI) :: [PP_Doc]) _ppAI _ppANT ->
{-# LINE 127 "src-ag/AG2AspectAG.ag" #-}
"import Language.Grammars.AspectAG" >-<
"import Language.Grammars.AspectAG.Derive" >-<
"import Data.HList.Label4" >-<
"import Data.HList.TypeEqGeneric1" >-<
"import Data.HList.TypeCastGeneric1" >-<
maybe empty ("import qualified" >#<) _lhsIext >-<
maybe empty (\ext -> "import" >#< ext >#< ppListSep "(" ")" "," (_nontsIppDI ++ _nontsIppLI ++ _ppAI ++ _ppANT )) _lhsIext
{-# LINE 950 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule61 #-}
{-# LINE 140 "src-ag/AG2AspectAG.ag" #-}
rule61 = \ ((_lhsIoptions) :: Options) ((_nontsIppCata) :: PP_Doc) ((_nontsIppD) :: PP_Doc) ((_nontsIppL) :: PP_Doc) ((_nontsIppSF) :: PP_Doc) ((_nontsIppW) :: PP_Doc) _ppA _ppR ->
{-# LINE 140 "src-ag/AG2AspectAG.ag" #-}
(if dataTypes _lhsIoptions
then "-- datatypes" >-< _nontsIppD >-<
"-- labels" >-< _nontsIppL
else empty)
>-<
(if folds _lhsIoptions
then "-- attributes" >-< _ppA >-<
"-- rules" >-< _ppR >-<
"-- catas" >-< _nontsIppCata
else empty)
>-<
(if semfuns _lhsIoptions
then "-- semantic functions" >-< _nontsIppSF
else empty)
>-<
(if wrappers _lhsIoptions
then "-- wrappers" >-< _nontsIppW
else empty)
{-# LINE 973 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule62 #-}
{-# LINE 202 "src-ag/AG2AspectAG.ag" #-}
rule62 = \ derivings_ ->
{-# LINE 202 "src-ag/AG2AspectAG.ag" #-}
derivings_
{-# LINE 979 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule63 #-}
{-# LINE 251 "src-ag/AG2AspectAG.ag" #-}
rule63 = \ typeSyns_ ->
{-# LINE 251 "src-ag/AG2AspectAG.ag" #-}
typeSyns_
{-# LINE 985 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule64 #-}
{-# LINE 300 "src-ag/AG2AspectAG.ag" #-}
rule64 = \ ((_lhsIext) :: Maybe String) _newAtts ((_nontsIppA) :: PP_Doc) _o_noGroup ->
{-# LINE 300 "src-ag/AG2AspectAG.ag" #-}
vlist (map defAtt (filterAtts _newAtts _o_noGroup )) >-<
defAtt "loc" >-<
(case _lhsIext of
Nothing -> defAtt "inh" >-< defAtt "syn"
otherwise -> empty) >-<
_nontsIppA
{-# LINE 996 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule65 #-}
{-# LINE 308 "src-ag/AG2AspectAG.ag" #-}
rule65 = \ ((_lhsIext) :: Maybe String) _newAtts ((_nontsIppAI) :: [PP_Doc]) _o_noGroup ->
{-# LINE 308 "src-ag/AG2AspectAG.ag" #-}
let atts = filterNotAtts _newAtts _o_noGroup
in (foldr (\a as -> attName a : as) [] atts) ++
(foldr (\a as -> attTName a : as) [] atts) ++
(case _lhsIext of
Nothing -> []
otherwise -> [ attName "inh", attName "syn", attTName "inh", attTName "syn" ]) ++
_nontsIppAI
{-# LINE 1008 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule66 #-}
{-# LINE 318 "src-ag/AG2AspectAG.ag" #-}
rule66 = \ _newAtts _o_noGroup ->
{-# LINE 318 "src-ag/AG2AspectAG.ag" #-}
let atts = filterNotAtts _newAtts _o_noGroup
in (foldr (\a as -> ("nts_" >|< a) : as) [] atts)
{-# LINE 1015 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule67 #-}
{-# LINE 392 "src-ag/AG2AspectAG.ag" #-}
rule67 = \ ((_nontsIppNtL) :: [(PP_Doc, Attributes)]) ->
{-# LINE 392 "src-ag/AG2AspectAG.ag" #-}
_nontsIppNtL
{-# LINE 1021 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule68 #-}
{-# LINE 393 "src-ag/AG2AspectAG.ag" #-}
rule68 = \ _newAtts ((_nontsIppR) :: PP_Doc) _o_noGroup _ppNtL ->
{-# LINE 393 "src-ag/AG2AspectAG.ag" #-}
ntsList "group" _ppNtL >-<
vlist (map (\att -> ntsList att (filterNts att _ppNtL )) (filterAtts _newAtts _o_noGroup )) >-<
_nontsIppR
{-# LINE 1029 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule69 #-}
rule69 = \ ((_lhsIext) :: Maybe String) ->
_lhsIext
data Inh_HsToken = Inh_HsToken { }
data Syn_HsToken = Syn_HsToken { }
{-# INLINABLE wrap_HsToken #-}
wrap_HsToken :: T_HsToken -> Inh_HsToken -> (Syn_HsToken )
wrap_HsToken :: T_HsToken -> Inh_HsToken -> Syn_HsToken
wrap_HsToken (T_HsToken Identity T_HsToken_s14
act) (Inh_HsToken
Inh_HsToken ) =
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
do T_HsToken_s14
sem <- Identity T_HsToken_s14
act
let arg13 :: T_HsToken_vIn13
arg13 = T_HsToken_vIn13
T_HsToken_vIn13
(T_HsToken_vOut13
T_HsToken_vOut13 ) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_HsToken_s14 -> T_HsToken_v13
inv_HsToken_s14 T_HsToken_s14
sem T_HsToken_vIn13
arg13)
forall (m :: * -> *) a. Monad m => a -> m a
return (Syn_HsToken
Syn_HsToken )
)
{-# NOINLINE sem_HsToken #-}
sem_HsToken :: HsToken -> T_HsToken
sem_HsToken :: HsToken -> T_HsToken
sem_HsToken ( AGLocal Identifier
var_ Pos
pos_ Maybe String
rdesc_ ) = Identifier -> Pos -> Maybe String -> T_HsToken
sem_HsToken_AGLocal Identifier
var_ Pos
pos_ Maybe String
rdesc_
sem_HsToken ( AGField Identifier
field_ Identifier
attr_ Pos
pos_ Maybe String
rdesc_ ) = Identifier -> Identifier -> Pos -> Maybe String -> T_HsToken
sem_HsToken_AGField Identifier
field_ Identifier
attr_ Pos
pos_ Maybe String
rdesc_
sem_HsToken ( HsToken String
value_ Pos
pos_ ) = String -> Pos -> T_HsToken
sem_HsToken_HsToken String
value_ Pos
pos_
sem_HsToken ( CharToken String
value_ Pos
pos_ ) = String -> Pos -> T_HsToken
sem_HsToken_CharToken String
value_ Pos
pos_
sem_HsToken ( StrToken String
value_ Pos
pos_ ) = String -> Pos -> T_HsToken
sem_HsToken_StrToken String
value_ Pos
pos_
sem_HsToken ( Err String
mesg_ Pos
pos_ ) = String -> Pos -> T_HsToken
sem_HsToken_Err String
mesg_ Pos
pos_
newtype T_HsToken = T_HsToken {
T_HsToken -> Identity T_HsToken_s14
attach_T_HsToken :: Identity (T_HsToken_s14 )
}
newtype T_HsToken_s14 = C_HsToken_s14 {
T_HsToken_s14 -> T_HsToken_v13
inv_HsToken_s14 :: (T_HsToken_v13 )
}
data T_HsToken_s15 = C_HsToken_s15
type T_HsToken_v13 = (T_HsToken_vIn13 ) -> (T_HsToken_vOut13 )
data T_HsToken_vIn13 = T_HsToken_vIn13
data T_HsToken_vOut13 = T_HsToken_vOut13
{-# NOINLINE sem_HsToken_AGLocal #-}
sem_HsToken_AGLocal :: (Identifier) -> (Pos) -> (Maybe String) -> T_HsToken
sem_HsToken_AGLocal :: Identifier -> Pos -> Maybe String -> T_HsToken
sem_HsToken_AGLocal Identifier
_ Pos
_ Maybe String
_ = Identity T_HsToken_s14 -> T_HsToken
T_HsToken (forall (m :: * -> *) a. Monad m => a -> m a
return T_HsToken_s14
st14) where
{-# NOINLINE st14 #-}
st14 :: T_HsToken_s14
st14 = let
v13 :: T_HsToken_v13
v13 :: T_HsToken_v13
v13 = \ (T_HsToken_vIn13
T_HsToken_vIn13 ) -> ( let
__result_ :: T_HsToken_vOut13
__result_ = T_HsToken_vOut13
T_HsToken_vOut13
in T_HsToken_vOut13
__result_ )
in T_HsToken_v13 -> T_HsToken_s14
C_HsToken_s14 T_HsToken_v13
v13
{-# NOINLINE sem_HsToken_AGField #-}
sem_HsToken_AGField :: (Identifier) -> (Identifier) -> (Pos) -> (Maybe String) -> T_HsToken
sem_HsToken_AGField :: Identifier -> Identifier -> Pos -> Maybe String -> T_HsToken
sem_HsToken_AGField Identifier
_ Identifier
_ Pos
_ Maybe String
_ = Identity T_HsToken_s14 -> T_HsToken
T_HsToken (forall (m :: * -> *) a. Monad m => a -> m a
return T_HsToken_s14
st14) where
{-# NOINLINE st14 #-}
st14 :: T_HsToken_s14
st14 = let
v13 :: T_HsToken_v13
v13 :: T_HsToken_v13
v13 = \ (T_HsToken_vIn13
T_HsToken_vIn13 ) -> ( let
__result_ :: T_HsToken_vOut13
__result_ = T_HsToken_vOut13
T_HsToken_vOut13
in T_HsToken_vOut13
__result_ )
in T_HsToken_v13 -> T_HsToken_s14
C_HsToken_s14 T_HsToken_v13
v13
{-# NOINLINE sem_HsToken_HsToken #-}
sem_HsToken_HsToken :: (String) -> (Pos) -> T_HsToken
sem_HsToken_HsToken :: String -> Pos -> T_HsToken
sem_HsToken_HsToken String
_ Pos
_ = Identity T_HsToken_s14 -> T_HsToken
T_HsToken (forall (m :: * -> *) a. Monad m => a -> m a
return T_HsToken_s14
st14) where
{-# NOINLINE st14 #-}
st14 :: T_HsToken_s14
st14 = let
v13 :: T_HsToken_v13
v13 :: T_HsToken_v13
v13 = \ (T_HsToken_vIn13
T_HsToken_vIn13 ) -> ( let
__result_ :: T_HsToken_vOut13
__result_ = T_HsToken_vOut13
T_HsToken_vOut13
in T_HsToken_vOut13
__result_ )
in T_HsToken_v13 -> T_HsToken_s14
C_HsToken_s14 T_HsToken_v13
v13
{-# NOINLINE sem_HsToken_CharToken #-}
sem_HsToken_CharToken :: (String) -> (Pos) -> T_HsToken
sem_HsToken_CharToken :: String -> Pos -> T_HsToken
sem_HsToken_CharToken String
_ Pos
_ = Identity T_HsToken_s14 -> T_HsToken
T_HsToken (forall (m :: * -> *) a. Monad m => a -> m a
return T_HsToken_s14
st14) where
{-# NOINLINE st14 #-}
st14 :: T_HsToken_s14
st14 = let
v13 :: T_HsToken_v13
v13 :: T_HsToken_v13
v13 = \ (T_HsToken_vIn13
T_HsToken_vIn13 ) -> ( let
__result_ :: T_HsToken_vOut13
__result_ = T_HsToken_vOut13
T_HsToken_vOut13
in T_HsToken_vOut13
__result_ )
in T_HsToken_v13 -> T_HsToken_s14
C_HsToken_s14 T_HsToken_v13
v13
{-# NOINLINE sem_HsToken_StrToken #-}
sem_HsToken_StrToken :: (String) -> (Pos) -> T_HsToken
sem_HsToken_StrToken :: String -> Pos -> T_HsToken
sem_HsToken_StrToken String
_ Pos
_ = Identity T_HsToken_s14 -> T_HsToken
T_HsToken (forall (m :: * -> *) a. Monad m => a -> m a
return T_HsToken_s14
st14) where
{-# NOINLINE st14 #-}
st14 :: T_HsToken_s14
st14 = let
v13 :: T_HsToken_v13
v13 :: T_HsToken_v13
v13 = \ (T_HsToken_vIn13
T_HsToken_vIn13 ) -> ( let
__result_ :: T_HsToken_vOut13
__result_ = T_HsToken_vOut13
T_HsToken_vOut13
in T_HsToken_vOut13
__result_ )
in T_HsToken_v13 -> T_HsToken_s14
C_HsToken_s14 T_HsToken_v13
v13
{-# NOINLINE sem_HsToken_Err #-}
sem_HsToken_Err :: (String) -> (Pos) -> T_HsToken
sem_HsToken_Err :: String -> Pos -> T_HsToken
sem_HsToken_Err String
_ Pos
_ = Identity T_HsToken_s14 -> T_HsToken
T_HsToken (forall (m :: * -> *) a. Monad m => a -> m a
return T_HsToken_s14
st14) where
{-# NOINLINE st14 #-}
st14 :: T_HsToken_s14
st14 = let
v13 :: T_HsToken_v13
v13 :: T_HsToken_v13
v13 = \ (T_HsToken_vIn13
T_HsToken_vIn13 ) -> ( let
__result_ :: T_HsToken_vOut13
__result_ = T_HsToken_vOut13
T_HsToken_vOut13
in T_HsToken_vOut13
__result_ )
in T_HsToken_v13 -> T_HsToken_s14
C_HsToken_s14 T_HsToken_v13
v13
data Inh_HsTokens = Inh_HsTokens { }
data Syn_HsTokens = Syn_HsTokens { }
{-# INLINABLE wrap_HsTokens #-}
wrap_HsTokens :: T_HsTokens -> Inh_HsTokens -> (Syn_HsTokens )
wrap_HsTokens :: T_HsTokens -> Inh_HsTokens -> Syn_HsTokens
wrap_HsTokens (T_HsTokens Identity T_HsTokens_s17
act) (Inh_HsTokens
Inh_HsTokens ) =
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
do T_HsTokens_s17
sem <- Identity T_HsTokens_s17
act
let arg16 :: T_HsTokens_vIn16
arg16 = T_HsTokens_vIn16
T_HsTokens_vIn16
(T_HsTokens_vOut16
T_HsTokens_vOut16 ) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_HsTokens_s17 -> T_HsTokens_v16
inv_HsTokens_s17 T_HsTokens_s17
sem T_HsTokens_vIn16
arg16)
forall (m :: * -> *) a. Monad m => a -> m a
return (Syn_HsTokens
Syn_HsTokens )
)
{-# NOINLINE sem_HsTokens #-}
sem_HsTokens :: HsTokens -> T_HsTokens
sem_HsTokens :: [HsToken] -> T_HsTokens
sem_HsTokens [HsToken]
list = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
Prelude.foldr T_HsToken -> T_HsTokens -> T_HsTokens
sem_HsTokens_Cons T_HsTokens
sem_HsTokens_Nil (forall a b. (a -> b) -> [a] -> [b]
Prelude.map HsToken -> T_HsToken
sem_HsToken [HsToken]
list)
newtype T_HsTokens = T_HsTokens {
T_HsTokens -> Identity T_HsTokens_s17
attach_T_HsTokens :: Identity (T_HsTokens_s17 )
}
newtype T_HsTokens_s17 = C_HsTokens_s17 {
T_HsTokens_s17 -> T_HsTokens_v16
inv_HsTokens_s17 :: (T_HsTokens_v16 )
}
data T_HsTokens_s18 = C_HsTokens_s18
type T_HsTokens_v16 = (T_HsTokens_vIn16 ) -> (T_HsTokens_vOut16 )
data T_HsTokens_vIn16 = T_HsTokens_vIn16
data T_HsTokens_vOut16 = T_HsTokens_vOut16
{-# NOINLINE sem_HsTokens_Cons #-}
sem_HsTokens_Cons :: T_HsToken -> T_HsTokens -> T_HsTokens
sem_HsTokens_Cons :: T_HsToken -> T_HsTokens -> T_HsTokens
sem_HsTokens_Cons T_HsToken
arg_hd_ T_HsTokens
arg_tl_ = Identity T_HsTokens_s17 -> T_HsTokens
T_HsTokens (forall (m :: * -> *) a. Monad m => a -> m a
return T_HsTokens_s17
st17) where
{-# NOINLINE st17 #-}
st17 :: T_HsTokens_s17
st17 = let
v16 :: T_HsTokens_v16
v16 :: T_HsTokens_v16
v16 = \ (T_HsTokens_vIn16
T_HsTokens_vIn16 ) -> ( let
_hdX14 :: T_HsToken_s14
_hdX14 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_HsToken -> Identity T_HsToken_s14
attach_T_HsToken (T_HsToken
arg_hd_))
_tlX17 :: T_HsTokens_s17
_tlX17 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_HsTokens -> Identity T_HsTokens_s17
attach_T_HsTokens (T_HsTokens
arg_tl_))
(T_HsToken_vOut13
T_HsToken_vOut13 ) = T_HsToken_s14 -> T_HsToken_v13
inv_HsToken_s14 T_HsToken_s14
_hdX14 (T_HsToken_vIn13
T_HsToken_vIn13 )
(T_HsTokens_vOut16
T_HsTokens_vOut16 ) = T_HsTokens_s17 -> T_HsTokens_v16
inv_HsTokens_s17 T_HsTokens_s17
_tlX17 (T_HsTokens_vIn16
T_HsTokens_vIn16 )
__result_ :: T_HsTokens_vOut16
__result_ = T_HsTokens_vOut16
T_HsTokens_vOut16
in T_HsTokens_vOut16
__result_ )
in T_HsTokens_v16 -> T_HsTokens_s17
C_HsTokens_s17 T_HsTokens_v16
v16
{-# NOINLINE sem_HsTokens_Nil #-}
sem_HsTokens_Nil :: T_HsTokens
sem_HsTokens_Nil :: T_HsTokens
sem_HsTokens_Nil = Identity T_HsTokens_s17 -> T_HsTokens
T_HsTokens (forall (m :: * -> *) a. Monad m => a -> m a
return T_HsTokens_s17
st17) where
{-# NOINLINE st17 #-}
st17 :: T_HsTokens_s17
st17 = let
v16 :: T_HsTokens_v16
v16 :: T_HsTokens_v16
v16 = \ (T_HsTokens_vIn16
T_HsTokens_vIn16 ) -> ( let
__result_ :: T_HsTokens_vOut16
__result_ = T_HsTokens_vOut16
T_HsTokens_vOut16
in T_HsTokens_vOut16
__result_ )
in T_HsTokens_v16 -> T_HsTokens_s17
C_HsTokens_s17 T_HsTokens_v16
v16
data Inh_HsTokensRoot = Inh_HsTokensRoot { }
data Syn_HsTokensRoot = Syn_HsTokensRoot { }
{-# INLINABLE wrap_HsTokensRoot #-}
wrap_HsTokensRoot :: T_HsTokensRoot -> Inh_HsTokensRoot -> (Syn_HsTokensRoot )
wrap_HsTokensRoot :: T_HsTokensRoot -> Inh_HsTokensRoot -> Syn_HsTokensRoot
wrap_HsTokensRoot (T_HsTokensRoot Identity T_HsTokensRoot_s20
act) (Inh_HsTokensRoot
Inh_HsTokensRoot ) =
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
do T_HsTokensRoot_s20
sem <- Identity T_HsTokensRoot_s20
act
let arg19 :: T_HsTokensRoot_vIn19
arg19 = T_HsTokensRoot_vIn19
T_HsTokensRoot_vIn19
(T_HsTokensRoot_vOut19
T_HsTokensRoot_vOut19 ) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_HsTokensRoot_s20 -> T_HsTokensRoot_v19
inv_HsTokensRoot_s20 T_HsTokensRoot_s20
sem T_HsTokensRoot_vIn19
arg19)
forall (m :: * -> *) a. Monad m => a -> m a
return (Syn_HsTokensRoot
Syn_HsTokensRoot )
)
{-# INLINE sem_HsTokensRoot #-}
sem_HsTokensRoot :: HsTokensRoot -> T_HsTokensRoot
sem_HsTokensRoot :: HsTokensRoot -> T_HsTokensRoot
sem_HsTokensRoot ( HsTokensRoot [HsToken]
tokens_ ) = T_HsTokens -> T_HsTokensRoot
sem_HsTokensRoot_HsTokensRoot ( [HsToken] -> T_HsTokens
sem_HsTokens [HsToken]
tokens_ )
newtype T_HsTokensRoot = T_HsTokensRoot {
T_HsTokensRoot -> Identity T_HsTokensRoot_s20
attach_T_HsTokensRoot :: Identity (T_HsTokensRoot_s20 )
}
newtype T_HsTokensRoot_s20 = C_HsTokensRoot_s20 {
T_HsTokensRoot_s20 -> T_HsTokensRoot_v19
inv_HsTokensRoot_s20 :: (T_HsTokensRoot_v19 )
}
data T_HsTokensRoot_s21 = C_HsTokensRoot_s21
type T_HsTokensRoot_v19 = (T_HsTokensRoot_vIn19 ) -> (T_HsTokensRoot_vOut19 )
data T_HsTokensRoot_vIn19 = T_HsTokensRoot_vIn19
data T_HsTokensRoot_vOut19 = T_HsTokensRoot_vOut19
{-# NOINLINE sem_HsTokensRoot_HsTokensRoot #-}
sem_HsTokensRoot_HsTokensRoot :: T_HsTokens -> T_HsTokensRoot
sem_HsTokensRoot_HsTokensRoot :: T_HsTokens -> T_HsTokensRoot
sem_HsTokensRoot_HsTokensRoot T_HsTokens
arg_tokens_ = Identity T_HsTokensRoot_s20 -> T_HsTokensRoot
T_HsTokensRoot (forall (m :: * -> *) a. Monad m => a -> m a
return T_HsTokensRoot_s20
st20) where
{-# NOINLINE st20 #-}
st20 :: T_HsTokensRoot_s20
st20 = let
v19 :: T_HsTokensRoot_v19
v19 :: T_HsTokensRoot_v19
v19 = \ (T_HsTokensRoot_vIn19
T_HsTokensRoot_vIn19 ) -> ( let
_tokensX17 :: T_HsTokens_s17
_tokensX17 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_HsTokens -> Identity T_HsTokens_s17
attach_T_HsTokens (T_HsTokens
arg_tokens_))
(T_HsTokens_vOut16
T_HsTokens_vOut16 ) = T_HsTokens_s17 -> T_HsTokens_v16
inv_HsTokens_s17 T_HsTokens_s17
_tokensX17 (T_HsTokens_vIn16
T_HsTokens_vIn16 )
__result_ :: T_HsTokensRoot_vOut19
__result_ = T_HsTokensRoot_vOut19
T_HsTokensRoot_vOut19
in T_HsTokensRoot_vOut19
__result_ )
in T_HsTokensRoot_v19 -> T_HsTokensRoot_s20
C_HsTokensRoot_s20 T_HsTokensRoot_v19
v19
data Inh_Nonterminal = Inh_Nonterminal { Inh_Nonterminal -> Derivings
derivs_Inh_Nonterminal :: (Derivings), Inh_Nonterminal -> Maybe String
ext_Inh_Nonterminal :: (Maybe String), Inh_Nonterminal -> Map Identifier Attributes
inhMap_Inh_Nonterminal :: (Map Identifier Attributes), Inh_Nonterminal -> Attributes
newAtts_Inh_Nonterminal :: ( Attributes ), Inh_Nonterminal -> Set Identifier
newNTs_Inh_Nonterminal :: (Set NontermIdent), Inh_Nonterminal -> DataTypes
newProds_Inh_Nonterminal :: ( DataTypes ), Inh_Nonterminal -> [String]
o_noGroup_Inh_Nonterminal :: ([String]), Inh_Nonterminal -> Bool
o_rename_Inh_Nonterminal :: (Bool), Inh_Nonterminal -> Map Identifier Attributes
synMap_Inh_Nonterminal :: (Map Identifier Attributes), Inh_Nonterminal -> TypeSyns
tSyns_Inh_Nonterminal :: (TypeSyns) }
data Syn_Nonterminal = Syn_Nonterminal { Syn_Nonterminal -> Set Identifier
extendedNTs_Syn_Nonterminal :: (Set NontermIdent), Syn_Nonterminal -> Map Identifier Attributes
inhMap'_Syn_Nonterminal :: (Map Identifier Attributes), Syn_Nonterminal -> PP_Doc
ppA_Syn_Nonterminal :: (PP_Doc), Syn_Nonterminal -> [PP_Doc]
ppAI_Syn_Nonterminal :: ([PP_Doc]), Syn_Nonterminal -> PP_Doc
ppCata_Syn_Nonterminal :: (PP_Doc), Syn_Nonterminal -> PP_Doc
ppD_Syn_Nonterminal :: (PP_Doc), Syn_Nonterminal -> [PP_Doc]
ppDI_Syn_Nonterminal :: ([PP_Doc]), Syn_Nonterminal -> PP_Doc
ppL_Syn_Nonterminal :: (PP_Doc), Syn_Nonterminal -> [PP_Doc]
ppLI_Syn_Nonterminal :: ([PP_Doc]), Syn_Nonterminal -> [(PP_Doc, Attributes)]
ppNtL_Syn_Nonterminal :: ([(PP_Doc, Attributes)]), Syn_Nonterminal -> PP_Doc
ppR_Syn_Nonterminal :: (PP_Doc), Syn_Nonterminal -> PP_Doc
ppSF_Syn_Nonterminal :: (PP_Doc), Syn_Nonterminal -> PP_Doc
ppW_Syn_Nonterminal :: (PP_Doc), Syn_Nonterminal -> Map Identifier Attributes
synMap'_Syn_Nonterminal :: (Map Identifier Attributes) }
{-# INLINABLE wrap_Nonterminal #-}
wrap_Nonterminal :: T_Nonterminal -> Inh_Nonterminal -> (Syn_Nonterminal )
wrap_Nonterminal :: T_Nonterminal -> Inh_Nonterminal -> Syn_Nonterminal
wrap_Nonterminal (T_Nonterminal Identity T_Nonterminal_s23
act) (Inh_Nonterminal Derivings
_lhsIderivs Maybe String
_lhsIext Map Identifier Attributes
_lhsIinhMap Attributes
_lhsInewAtts Set Identifier
_lhsInewNTs DataTypes
_lhsInewProds [String]
_lhsIo_noGroup Bool
_lhsIo_rename Map Identifier Attributes
_lhsIsynMap TypeSyns
_lhsItSyns) =
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
do T_Nonterminal_s23
sem <- Identity T_Nonterminal_s23
act
let arg22 :: T_Nonterminal_vIn22
arg22 = Derivings
-> Maybe String
-> Map Identifier Attributes
-> Attributes
-> Set Identifier
-> DataTypes
-> [String]
-> Bool
-> Map Identifier Attributes
-> TypeSyns
-> T_Nonterminal_vIn22
T_Nonterminal_vIn22 Derivings
_lhsIderivs Maybe String
_lhsIext Map Identifier Attributes
_lhsIinhMap Attributes
_lhsInewAtts Set Identifier
_lhsInewNTs DataTypes
_lhsInewProds [String]
_lhsIo_noGroup Bool
_lhsIo_rename Map Identifier Attributes
_lhsIsynMap TypeSyns
_lhsItSyns
(T_Nonterminal_vOut22 Set Identifier
_lhsOextendedNTs Map Identifier Attributes
_lhsOinhMap' PP_Doc
_lhsOppA [PP_Doc]
_lhsOppAI PP_Doc
_lhsOppCata PP_Doc
_lhsOppD [PP_Doc]
_lhsOppDI PP_Doc
_lhsOppL [PP_Doc]
_lhsOppLI [(PP_Doc, Attributes)]
_lhsOppNtL PP_Doc
_lhsOppR PP_Doc
_lhsOppSF PP_Doc
_lhsOppW Map Identifier Attributes
_lhsOsynMap') <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_Nonterminal_s23 -> T_Nonterminal_v22
inv_Nonterminal_s23 T_Nonterminal_s23
sem T_Nonterminal_vIn22
arg22)
forall (m :: * -> *) a. Monad m => a -> m a
return (Set Identifier
-> Map Identifier Attributes
-> PP_Doc
-> [PP_Doc]
-> PP_Doc
-> PP_Doc
-> [PP_Doc]
-> PP_Doc
-> [PP_Doc]
-> [(PP_Doc, Attributes)]
-> PP_Doc
-> PP_Doc
-> PP_Doc
-> Map Identifier Attributes
-> Syn_Nonterminal
Syn_Nonterminal Set Identifier
_lhsOextendedNTs Map Identifier Attributes
_lhsOinhMap' PP_Doc
_lhsOppA [PP_Doc]
_lhsOppAI PP_Doc
_lhsOppCata PP_Doc
_lhsOppD [PP_Doc]
_lhsOppDI PP_Doc
_lhsOppL [PP_Doc]
_lhsOppLI [(PP_Doc, Attributes)]
_lhsOppNtL PP_Doc
_lhsOppR PP_Doc
_lhsOppSF PP_Doc
_lhsOppW Map Identifier Attributes
_lhsOsynMap')
)
{-# INLINE sem_Nonterminal #-}
sem_Nonterminal :: Nonterminal -> T_Nonterminal
sem_Nonterminal :: Nonterminal -> T_Nonterminal
sem_Nonterminal ( Nonterminal Identifier
nt_ [Identifier]
params_ Attributes
inh_ Attributes
syn_ Productions
prods_ ) = Identifier
-> [Identifier]
-> Attributes
-> Attributes
-> T_Productions
-> T_Nonterminal
sem_Nonterminal_Nonterminal Identifier
nt_ [Identifier]
params_ Attributes
inh_ Attributes
syn_ ( Productions -> T_Productions
sem_Productions Productions
prods_ )
newtype T_Nonterminal = T_Nonterminal {
T_Nonterminal -> Identity T_Nonterminal_s23
attach_T_Nonterminal :: Identity (T_Nonterminal_s23 )
}
newtype T_Nonterminal_s23 = C_Nonterminal_s23 {
T_Nonterminal_s23 -> T_Nonterminal_v22
inv_Nonterminal_s23 :: (T_Nonterminal_v22 )
}
data T_Nonterminal_s24 = C_Nonterminal_s24
type T_Nonterminal_v22 = (T_Nonterminal_vIn22 ) -> (T_Nonterminal_vOut22 )
data T_Nonterminal_vIn22 = T_Nonterminal_vIn22 (Derivings) (Maybe String) (Map Identifier Attributes) ( Attributes ) (Set NontermIdent) ( DataTypes ) ([String]) (Bool) (Map Identifier Attributes) (TypeSyns)
data T_Nonterminal_vOut22 = T_Nonterminal_vOut22 (Set NontermIdent) (Map Identifier Attributes) (PP_Doc) ([PP_Doc]) (PP_Doc) (PP_Doc) ([PP_Doc]) (PP_Doc) ([PP_Doc]) ([(PP_Doc, Attributes)]) (PP_Doc) (PP_Doc) (PP_Doc) (Map Identifier Attributes)
{-# NOINLINE sem_Nonterminal_Nonterminal #-}
sem_Nonterminal_Nonterminal :: (NontermIdent) -> ([Identifier]) -> (Attributes) -> (Attributes) -> T_Productions -> T_Nonterminal
sem_Nonterminal_Nonterminal :: Identifier
-> [Identifier]
-> Attributes
-> Attributes
-> T_Productions
-> T_Nonterminal
sem_Nonterminal_Nonterminal Identifier
arg_nt_ [Identifier]
_ Attributes
arg_inh_ Attributes
arg_syn_ T_Productions
arg_prods_ = Identity T_Nonterminal_s23 -> T_Nonterminal
T_Nonterminal (forall (m :: * -> *) a. Monad m => a -> m a
return T_Nonterminal_s23
st23) where
{-# NOINLINE st23 #-}
st23 :: T_Nonterminal_s23
st23 = let
v22 :: T_Nonterminal_v22
v22 :: T_Nonterminal_v22
v22 = \ (T_Nonterminal_vIn22 Derivings
_lhsIderivs Maybe String
_lhsIext Map Identifier Attributes
_lhsIinhMap Attributes
_lhsInewAtts Set Identifier
_lhsInewNTs DataTypes
_lhsInewProds [String]
_lhsIo_noGroup Bool
_lhsIo_rename Map Identifier Attributes
_lhsIsynMap TypeSyns
_lhsItSyns) -> ( let
_prodsX38 :: T_Productions_s38
_prodsX38 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Productions -> Identity T_Productions_s38
attach_T_Productions (T_Productions
arg_prods_))
(T_Productions_vOut37 Bool
_prodsIhasMoreProds PP_Doc
_prodsIppA PP_Doc
_prodsIppCata [PP_Doc]
_prodsIppDL PP_Doc
_prodsIppL [PP_Doc]
_prodsIppLI PP_Doc
_prodsIppR [PP_Doc]
_prodsIppRA PP_Doc
_prodsIppSF PP_Doc
_prodsIppSPF Attributes
_prodsIprdInh) = T_Productions_s38 -> T_Productions_v37
inv_Productions_s38 T_Productions_s38
_prodsX38 (Maybe String
-> Attributes
-> Map Identifier Attributes
-> [String]
-> Attributes
-> Bool
-> Map Identifier FieldMap
-> [String]
-> Bool
-> PP_Doc
-> Attributes
-> Map Identifier Attributes
-> [String]
-> T_Productions_vIn37
T_Productions_vIn37 Maybe String
_prodsOext Attributes
_prodsOinh Map Identifier Attributes
_prodsOinhMap [String]
_prodsOinhNoGroup Attributes
_prodsOnewAtts Bool
_prodsOnewNT Map Identifier FieldMap
_prodsOnewProds [String]
_prodsOo_noGroup Bool
_prodsOo_rename PP_Doc
_prodsOppNt Attributes
_prodsOsyn Map Identifier Attributes
_prodsOsynMap [String]
_prodsOsynNoGroup)
_lhsOinhMap' :: Map Identifier Attributes
_lhsOinhMap' :: Map Identifier Attributes
_lhsOinhMap' = forall {a} {k}. a -> k -> Map k a
rule70 Attributes
arg_inh_ Identifier
arg_nt_
_lhsOsynMap' :: Map Identifier Attributes
_lhsOsynMap' :: Map Identifier Attributes
_lhsOsynMap' = forall k a. k -> a -> Map k a
rule71 Identifier
arg_nt_ Attributes
arg_syn_
_inhNoGroup :: Attributes
_inhNoGroup = [String] -> Attributes -> Attributes
rule72 [String]
_lhsIo_noGroup Attributes
_prodsIprdInh
_synNoGroup :: Attributes
_synNoGroup = forall {a}. [String] -> Map Identifier a -> Map Identifier a
rule73 [String]
_lhsIo_noGroup Attributes
arg_syn_
_prodsOinhNoGroup :: [String]
_prodsOinhNoGroup = forall {a}. Map Identifier a -> [String]
rule74 Attributes
_inhNoGroup
_prodsOsynNoGroup :: [String]
_prodsOsynNoGroup = forall {a}. Map Identifier a -> [String]
rule75 Attributes
_synNoGroup
_prodsOnewProds :: Map Identifier FieldMap
_prodsOnewProds = DataTypes -> Identifier -> Map Identifier FieldMap
rule76 DataTypes
_lhsInewProds Identifier
arg_nt_
_lhsOextendedNTs :: Set NontermIdent
_lhsOextendedNTs :: Set Identifier
_lhsOextendedNTs = forall {a}. Bool -> a -> Set a
rule77 Bool
_prodsIhasMoreProds Identifier
arg_nt_
_ppNt :: PP_Doc
_ppNt = Identifier -> PP_Doc
rule78 Identifier
arg_nt_
_prodsOppNt :: PP_Doc
_prodsOppNt = forall {p}. p -> p
rule79 PP_Doc
_ppNt
_lhsOppD :: PP_Doc
_lhsOppD :: PP_Doc
_lhsOppD = Derivings
-> Set Identifier
-> TypeSyns
-> PP_Doc
-> [PP_Doc]
-> Identifier
-> PP_Doc
rule80 Derivings
_lhsIderivs Set Identifier
_lhsInewNTs TypeSyns
_lhsItSyns PP_Doc
_ppNt [PP_Doc]
_prodsIppDL Identifier
arg_nt_
_lhsOppDI :: [PP_Doc]
_lhsOppDI :: [PP_Doc]
_lhsOppDI = forall {a}. Set Identifier -> a -> Identifier -> [a]
rule81 Set Identifier
_lhsInewNTs PP_Doc
_ppNt Identifier
arg_nt_
_ntLabel :: PP_Doc
_ntLabel = PP_Doc -> PP_Doc
rule82 PP_Doc
_ppNt
_lhsOppL :: PP_Doc
_lhsOppL :: PP_Doc
_lhsOppL = Set Identifier
-> PP_Doc -> PP_Doc -> PP_Doc -> Identifier -> PP_Doc
rule83 Set Identifier
_lhsInewNTs PP_Doc
_ntLabel PP_Doc
_ppNt PP_Doc
_prodsIppL Identifier
arg_nt_
_lhsOppLI :: [PP_Doc]
_lhsOppLI :: [PP_Doc]
_lhsOppLI = Set Identifier -> PP_Doc -> [PP_Doc] -> Identifier -> [PP_Doc]
rule84 Set Identifier
_lhsInewNTs PP_Doc
_ntLabel [PP_Doc]
_prodsIppLI Identifier
arg_nt_
_lhsOppA :: PP_Doc
_lhsOppA :: PP_Doc
_lhsOppA = forall {b} {b}.
Map Identifier b
-> Set Identifier
-> PP_Doc
-> PP_Doc
-> Map Identifier b
-> Attributes
-> Identifier
-> Attributes
-> PP_Doc
rule85 Attributes
_inhNoGroup Set Identifier
_lhsInewNTs PP_Doc
_ppNt PP_Doc
_prodsIppA Attributes
_synNoGroup Attributes
arg_inh_ Identifier
arg_nt_ Attributes
arg_syn_
_lhsOppAI :: [PP_Doc]
_lhsOppAI :: [PP_Doc]
_lhsOppAI = Set Identifier -> PP_Doc -> Identifier -> [PP_Doc]
rule86 Set Identifier
_lhsInewNTs PP_Doc
_ppNt Identifier
arg_nt_
_lhsOppNtL :: [(PP_Doc, Attributes)]
_lhsOppNtL :: [(PP_Doc, Attributes)]
_lhsOppNtL = forall {a}.
Map Identifier a
-> Identifier -> Map Identifier a -> [(PP_Doc, Map Identifier a)]
rule87 Attributes
arg_inh_ Identifier
arg_nt_ Attributes
arg_syn_
_prodsOnewNT :: Bool
_prodsOnewNT = Set Identifier -> Identifier -> Bool
rule88 Set Identifier
_lhsInewNTs Identifier
arg_nt_
_lhsOppR :: PP_Doc
_lhsOppR :: PP_Doc
_lhsOppR = PP_Doc -> Identifier -> PP_Doc
rule89 PP_Doc
_prodsIppR Identifier
arg_nt_
_lhsOppCata :: PP_Doc
_lhsOppCata :: PP_Doc
_lhsOppCata = PP_Doc -> PP_Doc -> PP_Doc
rule90 PP_Doc
_ppNt PP_Doc
_prodsIppCata
_prodsOsyn :: Attributes
_prodsOsyn = forall {p}. p -> p
rule91 Attributes
arg_syn_
_prodsOinh :: Attributes
_prodsOinh = forall {p}. p -> p
rule92 Attributes
arg_inh_
_lhsOppSF :: PP_Doc
_lhsOppSF :: PP_Doc
_lhsOppSF = Attributes -> PP_Doc -> PP_Doc -> Attributes -> PP_Doc
rule93 Attributes
_inhNoGroup PP_Doc
_ppNt PP_Doc
_prodsIppSPF Attributes
_synNoGroup
_lhsOppW :: PP_Doc
_lhsOppW :: PP_Doc
_lhsOppW = forall {b} {b}.
Map Identifier b -> PP_Doc -> Map Identifier b -> PP_Doc
rule94 Attributes
_inhNoGroup PP_Doc
_ppNt Attributes
arg_inh_
_prodsOext :: Maybe String
_prodsOext = Maybe String -> Maybe String
rule95 Maybe String
_lhsIext
_prodsOinhMap :: Map Identifier Attributes
_prodsOinhMap = Map Identifier Attributes -> Map Identifier Attributes
rule96 Map Identifier Attributes
_lhsIinhMap
_prodsOnewAtts :: Attributes
_prodsOnewAtts = Attributes -> Attributes
rule97 Attributes
_lhsInewAtts
_prodsOo_noGroup :: [String]
_prodsOo_noGroup = [String] -> [String]
rule98 [String]
_lhsIo_noGroup
_prodsOo_rename :: Bool
_prodsOo_rename = Bool -> Bool
rule99 Bool
_lhsIo_rename
_prodsOsynMap :: Map Identifier Attributes
_prodsOsynMap = Map Identifier Attributes -> Map Identifier Attributes
rule100 Map Identifier Attributes
_lhsIsynMap
__result_ :: T_Nonterminal_vOut22
__result_ = Set Identifier
-> Map Identifier Attributes
-> PP_Doc
-> [PP_Doc]
-> PP_Doc
-> PP_Doc
-> [PP_Doc]
-> PP_Doc
-> [PP_Doc]
-> [(PP_Doc, Attributes)]
-> PP_Doc
-> PP_Doc
-> PP_Doc
-> Map Identifier Attributes
-> T_Nonterminal_vOut22
T_Nonterminal_vOut22 Set Identifier
_lhsOextendedNTs Map Identifier Attributes
_lhsOinhMap' PP_Doc
_lhsOppA [PP_Doc]
_lhsOppAI PP_Doc
_lhsOppCata PP_Doc
_lhsOppD [PP_Doc]
_lhsOppDI PP_Doc
_lhsOppL [PP_Doc]
_lhsOppLI [(PP_Doc, Attributes)]
_lhsOppNtL PP_Doc
_lhsOppR PP_Doc
_lhsOppSF PP_Doc
_lhsOppW Map Identifier Attributes
_lhsOsynMap'
in T_Nonterminal_vOut22
__result_ )
in T_Nonterminal_v22 -> T_Nonterminal_s23
C_Nonterminal_s23 T_Nonterminal_v22
v22
{-# INLINE rule70 #-}
{-# LINE 7 "src-ag/DistChildAttr.ag" #-}
rule70 = \ inh_ nt_ ->
{-# LINE 7 "src-ag/DistChildAttr.ag" #-}
Map.singleton nt_ inh_
{-# LINE 1320 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule71 #-}
{-# LINE 8 "src-ag/DistChildAttr.ag" #-}
rule71 = \ nt_ syn_ ->
{-# LINE 8 "src-ag/DistChildAttr.ag" #-}
Map.singleton nt_ syn_
{-# LINE 1326 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule72 #-}
{-# LINE 51 "src-ag/AG2AspectAG.ag" #-}
rule72 = \ ((_lhsIo_noGroup) :: [String]) ((_prodsIprdInh) :: Attributes) ->
{-# LINE 51 "src-ag/AG2AspectAG.ag" #-}
Map.filterWithKey (\att _ -> elem (getName att) _lhsIo_noGroup) _prodsIprdInh
{-# LINE 1332 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule73 #-}
{-# LINE 52 "src-ag/AG2AspectAG.ag" #-}
rule73 = \ ((_lhsIo_noGroup) :: [String]) syn_ ->
{-# LINE 52 "src-ag/AG2AspectAG.ag" #-}
Map.filterWithKey (\att _ -> elem (getName att) _lhsIo_noGroup) syn_
{-# LINE 1338 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule74 #-}
{-# LINE 57 "src-ag/AG2AspectAG.ag" #-}
rule74 = \ _inhNoGroup ->
{-# LINE 57 "src-ag/AG2AspectAG.ag" #-}
map show $ Map.keys _inhNoGroup
{-# LINE 1344 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule75 #-}
{-# LINE 58 "src-ag/AG2AspectAG.ag" #-}
rule75 = \ _synNoGroup ->
{-# LINE 58 "src-ag/AG2AspectAG.ag" #-}
map show $ Map.keys _synNoGroup
{-# LINE 1350 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule76 #-}
{-# LINE 94 "src-ag/AG2AspectAG.ag" #-}
rule76 = \ ((_lhsInewProds) :: DataTypes ) nt_ ->
{-# LINE 94 "src-ag/AG2AspectAG.ag" #-}
case Map.lookup nt_ _lhsInewProds of
Just prds -> prds
Nothing -> Map.empty
{-# LINE 1358 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule77 #-}
{-# LINE 107 "src-ag/AG2AspectAG.ag" #-}
rule77 = \ ((_prodsIhasMoreProds) :: Bool ) nt_ ->
{-# LINE 107 "src-ag/AG2AspectAG.ag" #-}
if _prodsIhasMoreProds
then Set.singleton nt_
else Set.empty
{-# LINE 1366 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule78 #-}
{-# LINE 173 "src-ag/AG2AspectAG.ag" #-}
rule78 = \ nt_ ->
{-# LINE 173 "src-ag/AG2AspectAG.ag" #-}
pp nt_
{-# LINE 1372 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule79 #-}
{-# LINE 190 "src-ag/AG2AspectAG.ag" #-}
rule79 = \ _ppNt ->
{-# LINE 190 "src-ag/AG2AspectAG.ag" #-}
_ppNt
{-# LINE 1378 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule80 #-}
{-# LINE 209 "src-ag/AG2AspectAG.ag" #-}
rule80 = \ ((_lhsIderivs) :: Derivings) ((_lhsInewNTs) :: Set NontermIdent) ((_lhsItSyns) :: TypeSyns) _ppNt ((_prodsIppDL) :: [PP_Doc]) nt_ ->
{-# LINE 209 "src-ag/AG2AspectAG.ag" #-}
if (Set.member nt_ _lhsInewNTs)
then case (lookup nt_ _lhsItSyns) of
Nothing -> "data " >|< _ppNt
>|< " = " >|< vlist_sep " | " _prodsIppDL >-<
case (Map.lookup nt_ _lhsIderivs) of
Just ntds -> pp " deriving " >|< (ppListSep "(" ")" ", " $ Set.elems ntds)
Nothing -> empty
Just tp -> "type " >|< _ppNt >|< " = " >|< ppShow tp
else empty
{-# LINE 1392 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule81 #-}
{-# LINE 222 "src-ag/AG2AspectAG.ag" #-}
rule81 = \ ((_lhsInewNTs) :: Set NontermIdent) _ppNt nt_ ->
{-# LINE 222 "src-ag/AG2AspectAG.ag" #-}
if (not $ Set.member nt_ _lhsInewNTs)
then [ _ppNt ]
else [ ]
{-# LINE 1400 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule82 #-}
{-# LINE 262 "src-ag/AG2AspectAG.ag" #-}
rule82 = \ _ppNt ->
{-# LINE 262 "src-ag/AG2AspectAG.ag" #-}
"nt_" >|< _ppNt
{-# LINE 1406 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule83 #-}
{-# LINE 264 "src-ag/AG2AspectAG.ag" #-}
rule83 = \ ((_lhsInewNTs) :: Set NontermIdent) _ntLabel _ppNt ((_prodsIppL) :: PP_Doc) nt_ ->
{-# LINE 264 "src-ag/AG2AspectAG.ag" #-}
( if (Set.member nt_ _lhsInewNTs)
then _ntLabel >|< " = proxy :: Proxy " >|< _ppNt
else empty) >-<
_prodsIppL
{-# LINE 1415 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule84 #-}
{-# LINE 269 "src-ag/AG2AspectAG.ag" #-}
rule84 = \ ((_lhsInewNTs) :: Set NontermIdent) _ntLabel ((_prodsIppLI) :: [PP_Doc]) nt_ ->
{-# LINE 269 "src-ag/AG2AspectAG.ag" #-}
( if (not $ Set.member nt_ _lhsInewNTs)
then [ _ntLabel ]
else [ ]) ++
_prodsIppLI
{-# LINE 1424 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule85 #-}
{-# LINE 324 "src-ag/AG2AspectAG.ag" #-}
rule85 = \ _inhNoGroup ((_lhsInewNTs) :: Set NontermIdent) _ppNt ((_prodsIppA) :: PP_Doc) _synNoGroup inh_ nt_ syn_ ->
{-# LINE 324 "src-ag/AG2AspectAG.ag" #-}
( if (Set.member nt_ _lhsInewNTs)
then
defAttRec (pp "InhG") _ppNt inh_ _inhNoGroup >-<
defAttRec (pp "SynG") _ppNt syn_ _synNoGroup
else empty) >-<
_prodsIppA
{-# LINE 1435 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule86 #-}
{-# LINE 338 "src-ag/AG2AspectAG.ag" #-}
rule86 = \ ((_lhsInewNTs) :: Set NontermIdent) _ppNt nt_ ->
{-# LINE 338 "src-ag/AG2AspectAG.ag" #-}
if (not $ Set.member nt_ _lhsInewNTs)
then [ ppName [(pp "InhG"), _ppNt ] >#< pp "(..)", ppName [(pp "SynG"), _ppNt ] >#< pp "(..)" ]
else [ ]
{-# LINE 1443 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule87 #-}
{-# LINE 406 "src-ag/AG2AspectAG.ag" #-}
rule87 = \ inh_ nt_ syn_ ->
{-# LINE 406 "src-ag/AG2AspectAG.ag" #-}
[ ("nt_" >|< nt_, Map.union inh_ syn_) ]
{-# LINE 1449 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule88 #-}
{-# LINE 415 "src-ag/AG2AspectAG.ag" #-}
rule88 = \ ((_lhsInewNTs) :: Set NontermIdent) nt_ ->
{-# LINE 415 "src-ag/AG2AspectAG.ag" #-}
Set.member nt_ _lhsInewNTs
{-# LINE 1455 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule89 #-}
{-# LINE 425 "src-ag/AG2AspectAG.ag" #-}
rule89 = \ ((_prodsIppR) :: PP_Doc) nt_ ->
{-# LINE 425 "src-ag/AG2AspectAG.ag" #-}
pp "----" >|< pp nt_ >-< _prodsIppR
{-# LINE 1461 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule90 #-}
{-# LINE 735 "src-ag/AG2AspectAG.ag" #-}
rule90 = \ _ppNt ((_prodsIppCata) :: PP_Doc) ->
{-# LINE 735 "src-ag/AG2AspectAG.ag" #-}
"----" >|< _ppNt >-< _prodsIppCata
{-# LINE 1467 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule91 #-}
{-# LINE 766 "src-ag/AG2AspectAG.ag" #-}
rule91 = \ syn_ ->
{-# LINE 766 "src-ag/AG2AspectAG.ag" #-}
syn_
{-# LINE 1473 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule92 #-}
{-# LINE 767 "src-ag/AG2AspectAG.ag" #-}
rule92 = \ inh_ ->
{-# LINE 767 "src-ag/AG2AspectAG.ag" #-}
inh_
{-# LINE 1479 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule93 #-}
{-# LINE 779 "src-ag/AG2AspectAG.ag" #-}
rule93 = \ _inhNoGroup _ppNt ((_prodsIppSPF) :: PP_Doc) _synNoGroup ->
{-# LINE 779 "src-ag/AG2AspectAG.ag" #-}
let inhAtts = attTypes _inhNoGroup
synAtts = attTypes _synNoGroup
in
"----" >|< _ppNt >-<
"type T_" >|< _ppNt >|< " = " >|<
"(Record " >|<
inhAtts >|<
"(HCons (LVPair (Proxy Att_inh) InhG_" >|< _ppNt >|< ") HNil))" >|<
replicate (length inhAtts) ")" >|< " -> " >|<
"(Record " >|<
synAtts >|<
"(HCons (LVPair (Proxy Att_syn) SynG_" >|< _ppNt >|< ") HNil))" >|<
replicate (length synAtts) ")" >-<
"-- instance SemType T_" >|< _ppNt >|< " " >|< _ppNt >-<
"-- sem_" >|< _ppNt >|< " :: " >|< _ppNt >|< " -> T_" >|< _ppNt >-<
_prodsIppSPF
{-# LINE 1500 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule94 #-}
{-# LINE 847 "src-ag/AG2AspectAG.ag" #-}
rule94 = \ _inhNoGroup _ppNt inh_ ->
{-# LINE 847 "src-ag/AG2AspectAG.ag" #-}
ppName [pp "wrap", _ppNt ] >|< " sem " >|< attVars inh_ >|< " = " >-<
" sem " >|< attFields inh_ _inhNoGroup _ppNt
{-# LINE 1507 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule95 #-}
rule95 = \ ((_lhsIext) :: Maybe String) ->
_lhsIext
{-# INLINE rule96 #-}
rule96 = \ ((_lhsIinhMap) :: Map Identifier Attributes) ->
_lhsIinhMap
{-# INLINE rule97 #-}
rule97 = \ ((_lhsInewAtts) :: Attributes ) ->
_lhsInewAtts
{-# INLINE rule98 #-}
rule98 = \ ((_lhsIo_noGroup) :: [String]) ->
_lhsIo_noGroup
{-# INLINE rule99 #-}
rule99 = \ ((_lhsIo_rename) :: Bool) ->
_lhsIo_rename
{-# INLINE rule100 #-}
rule100 = \ ((_lhsIsynMap) :: Map Identifier Attributes) ->
_lhsIsynMap
data Inh_Nonterminals = Inh_Nonterminals { Inh_Nonterminals -> Derivings
derivs_Inh_Nonterminals :: (Derivings), Inh_Nonterminals -> Maybe String
ext_Inh_Nonterminals :: (Maybe String), Inh_Nonterminals -> Map Identifier Attributes
inhMap_Inh_Nonterminals :: (Map Identifier Attributes), Inh_Nonterminals -> Attributes
newAtts_Inh_Nonterminals :: ( Attributes ), Inh_Nonterminals -> Set Identifier
newNTs_Inh_Nonterminals :: (Set NontermIdent), Inh_Nonterminals -> DataTypes
newProds_Inh_Nonterminals :: ( DataTypes ), Inh_Nonterminals -> [String]
o_noGroup_Inh_Nonterminals :: ([String]), Inh_Nonterminals -> Bool
o_rename_Inh_Nonterminals :: (Bool), Inh_Nonterminals -> Map Identifier Attributes
synMap_Inh_Nonterminals :: (Map Identifier Attributes), Inh_Nonterminals -> TypeSyns
tSyns_Inh_Nonterminals :: (TypeSyns) }
data Syn_Nonterminals = Syn_Nonterminals { Syn_Nonterminals -> Set Identifier
extendedNTs_Syn_Nonterminals :: (Set NontermIdent), Syn_Nonterminals -> Map Identifier Attributes
inhMap'_Syn_Nonterminals :: (Map Identifier Attributes), Syn_Nonterminals -> PP_Doc
ppA_Syn_Nonterminals :: (PP_Doc), Syn_Nonterminals -> [PP_Doc]
ppAI_Syn_Nonterminals :: ([PP_Doc]), Syn_Nonterminals -> PP_Doc
ppCata_Syn_Nonterminals :: (PP_Doc), Syn_Nonterminals -> PP_Doc
ppD_Syn_Nonterminals :: (PP_Doc), Syn_Nonterminals -> [PP_Doc]
ppDI_Syn_Nonterminals :: ([PP_Doc]), Syn_Nonterminals -> PP_Doc
ppL_Syn_Nonterminals :: (PP_Doc), Syn_Nonterminals -> [PP_Doc]
ppLI_Syn_Nonterminals :: ([PP_Doc]), Syn_Nonterminals -> [(PP_Doc, Attributes)]
ppNtL_Syn_Nonterminals :: ([(PP_Doc, Attributes)]), Syn_Nonterminals -> PP_Doc
ppR_Syn_Nonterminals :: (PP_Doc), Syn_Nonterminals -> PP_Doc
ppSF_Syn_Nonterminals :: (PP_Doc), Syn_Nonterminals -> PP_Doc
ppW_Syn_Nonterminals :: (PP_Doc), Syn_Nonterminals -> Map Identifier Attributes
synMap'_Syn_Nonterminals :: (Map Identifier Attributes) }
{-# INLINABLE wrap_Nonterminals #-}
wrap_Nonterminals :: T_Nonterminals -> Inh_Nonterminals -> (Syn_Nonterminals )
wrap_Nonterminals :: T_Nonterminals -> Inh_Nonterminals -> Syn_Nonterminals
wrap_Nonterminals (T_Nonterminals Identity T_Nonterminals_s26
act) (Inh_Nonterminals Derivings
_lhsIderivs Maybe String
_lhsIext Map Identifier Attributes
_lhsIinhMap Attributes
_lhsInewAtts Set Identifier
_lhsInewNTs DataTypes
_lhsInewProds [String]
_lhsIo_noGroup Bool
_lhsIo_rename Map Identifier Attributes
_lhsIsynMap TypeSyns
_lhsItSyns) =
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
do T_Nonterminals_s26
sem <- Identity T_Nonterminals_s26
act
let arg25 :: T_Nonterminals_vIn25
arg25 = Derivings
-> Maybe String
-> Map Identifier Attributes
-> Attributes
-> Set Identifier
-> DataTypes
-> [String]
-> Bool
-> Map Identifier Attributes
-> TypeSyns
-> T_Nonterminals_vIn25
T_Nonterminals_vIn25 Derivings
_lhsIderivs Maybe String
_lhsIext Map Identifier Attributes
_lhsIinhMap Attributes
_lhsInewAtts Set Identifier
_lhsInewNTs DataTypes
_lhsInewProds [String]
_lhsIo_noGroup Bool
_lhsIo_rename Map Identifier Attributes
_lhsIsynMap TypeSyns
_lhsItSyns
(T_Nonterminals_vOut25 Set Identifier
_lhsOextendedNTs Map Identifier Attributes
_lhsOinhMap' PP_Doc
_lhsOppA [PP_Doc]
_lhsOppAI PP_Doc
_lhsOppCata PP_Doc
_lhsOppD [PP_Doc]
_lhsOppDI PP_Doc
_lhsOppL [PP_Doc]
_lhsOppLI [(PP_Doc, Attributes)]
_lhsOppNtL PP_Doc
_lhsOppR PP_Doc
_lhsOppSF PP_Doc
_lhsOppW Map Identifier Attributes
_lhsOsynMap') <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_Nonterminals_s26 -> T_Nonterminals_v25
inv_Nonterminals_s26 T_Nonterminals_s26
sem T_Nonterminals_vIn25
arg25)
forall (m :: * -> *) a. Monad m => a -> m a
return (Set Identifier
-> Map Identifier Attributes
-> PP_Doc
-> [PP_Doc]
-> PP_Doc
-> PP_Doc
-> [PP_Doc]
-> PP_Doc
-> [PP_Doc]
-> [(PP_Doc, Attributes)]
-> PP_Doc
-> PP_Doc
-> PP_Doc
-> Map Identifier Attributes
-> Syn_Nonterminals
Syn_Nonterminals Set Identifier
_lhsOextendedNTs Map Identifier Attributes
_lhsOinhMap' PP_Doc
_lhsOppA [PP_Doc]
_lhsOppAI PP_Doc
_lhsOppCata PP_Doc
_lhsOppD [PP_Doc]
_lhsOppDI PP_Doc
_lhsOppL [PP_Doc]
_lhsOppLI [(PP_Doc, Attributes)]
_lhsOppNtL PP_Doc
_lhsOppR PP_Doc
_lhsOppSF PP_Doc
_lhsOppW Map Identifier Attributes
_lhsOsynMap')
)
{-# NOINLINE sem_Nonterminals #-}
sem_Nonterminals :: Nonterminals -> T_Nonterminals
sem_Nonterminals :: Nonterminals -> T_Nonterminals
sem_Nonterminals Nonterminals
list = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
Prelude.foldr T_Nonterminal -> T_Nonterminals -> T_Nonterminals
sem_Nonterminals_Cons T_Nonterminals
sem_Nonterminals_Nil (forall a b. (a -> b) -> [a] -> [b]
Prelude.map Nonterminal -> T_Nonterminal
sem_Nonterminal Nonterminals
list)
newtype T_Nonterminals = T_Nonterminals {
T_Nonterminals -> Identity T_Nonterminals_s26
attach_T_Nonterminals :: Identity (T_Nonterminals_s26 )
}
newtype T_Nonterminals_s26 = C_Nonterminals_s26 {
T_Nonterminals_s26 -> T_Nonterminals_v25
inv_Nonterminals_s26 :: (T_Nonterminals_v25 )
}
data T_Nonterminals_s27 = C_Nonterminals_s27
type T_Nonterminals_v25 = (T_Nonterminals_vIn25 ) -> (T_Nonterminals_vOut25 )
data T_Nonterminals_vIn25 = T_Nonterminals_vIn25 (Derivings) (Maybe String) (Map Identifier Attributes) ( Attributes ) (Set NontermIdent) ( DataTypes ) ([String]) (Bool) (Map Identifier Attributes) (TypeSyns)
data T_Nonterminals_vOut25 = T_Nonterminals_vOut25 (Set NontermIdent) (Map Identifier Attributes) (PP_Doc) ([PP_Doc]) (PP_Doc) (PP_Doc) ([PP_Doc]) (PP_Doc) ([PP_Doc]) ([(PP_Doc, Attributes)]) (PP_Doc) (PP_Doc) (PP_Doc) (Map Identifier Attributes)
{-# NOINLINE sem_Nonterminals_Cons #-}
sem_Nonterminals_Cons :: T_Nonterminal -> T_Nonterminals -> T_Nonterminals
sem_Nonterminals_Cons :: T_Nonterminal -> T_Nonterminals -> T_Nonterminals
sem_Nonterminals_Cons T_Nonterminal
arg_hd_ T_Nonterminals
arg_tl_ = Identity T_Nonterminals_s26 -> T_Nonterminals
T_Nonterminals (forall (m :: * -> *) a. Monad m => a -> m a
return T_Nonterminals_s26
st26) where
{-# NOINLINE st26 #-}
st26 :: T_Nonterminals_s26
st26 = let
v25 :: T_Nonterminals_v25
v25 :: T_Nonterminals_v25
v25 = \ (T_Nonterminals_vIn25 Derivings
_lhsIderivs Maybe String
_lhsIext Map Identifier Attributes
_lhsIinhMap Attributes
_lhsInewAtts Set Identifier
_lhsInewNTs DataTypes
_lhsInewProds [String]
_lhsIo_noGroup Bool
_lhsIo_rename Map Identifier Attributes
_lhsIsynMap TypeSyns
_lhsItSyns) -> ( let
_hdX23 :: T_Nonterminal_s23
_hdX23 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Nonterminal -> Identity T_Nonterminal_s23
attach_T_Nonterminal (T_Nonterminal
arg_hd_))
_tlX26 :: T_Nonterminals_s26
_tlX26 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Nonterminals -> Identity T_Nonterminals_s26
attach_T_Nonterminals (T_Nonterminals
arg_tl_))
(T_Nonterminal_vOut22 Set Identifier
_hdIextendedNTs Map Identifier Attributes
_hdIinhMap' PP_Doc
_hdIppA [PP_Doc]
_hdIppAI PP_Doc
_hdIppCata PP_Doc
_hdIppD [PP_Doc]
_hdIppDI PP_Doc
_hdIppL [PP_Doc]
_hdIppLI [(PP_Doc, Attributes)]
_hdIppNtL PP_Doc
_hdIppR PP_Doc
_hdIppSF PP_Doc
_hdIppW Map Identifier Attributes
_hdIsynMap') = T_Nonterminal_s23 -> T_Nonterminal_v22
inv_Nonterminal_s23 T_Nonterminal_s23
_hdX23 (Derivings
-> Maybe String
-> Map Identifier Attributes
-> Attributes
-> Set Identifier
-> DataTypes
-> [String]
-> Bool
-> Map Identifier Attributes
-> TypeSyns
-> T_Nonterminal_vIn22
T_Nonterminal_vIn22 Derivings
_hdOderivs Maybe String
_hdOext Map Identifier Attributes
_hdOinhMap Attributes
_hdOnewAtts Set Identifier
_hdOnewNTs DataTypes
_hdOnewProds [String]
_hdOo_noGroup Bool
_hdOo_rename Map Identifier Attributes
_hdOsynMap TypeSyns
_hdOtSyns)
(T_Nonterminals_vOut25 Set Identifier
_tlIextendedNTs Map Identifier Attributes
_tlIinhMap' PP_Doc
_tlIppA [PP_Doc]
_tlIppAI PP_Doc
_tlIppCata PP_Doc
_tlIppD [PP_Doc]
_tlIppDI PP_Doc
_tlIppL [PP_Doc]
_tlIppLI [(PP_Doc, Attributes)]
_tlIppNtL PP_Doc
_tlIppR PP_Doc
_tlIppSF PP_Doc
_tlIppW Map Identifier Attributes
_tlIsynMap') = T_Nonterminals_s26 -> T_Nonterminals_v25
inv_Nonterminals_s26 T_Nonterminals_s26
_tlX26 (Derivings
-> Maybe String
-> Map Identifier Attributes
-> Attributes
-> Set Identifier
-> DataTypes
-> [String]
-> Bool
-> Map Identifier Attributes
-> TypeSyns
-> T_Nonterminals_vIn25
T_Nonterminals_vIn25 Derivings
_tlOderivs Maybe String
_tlOext Map Identifier Attributes
_tlOinhMap Attributes
_tlOnewAtts Set Identifier
_tlOnewNTs DataTypes
_tlOnewProds [String]
_tlOo_noGroup Bool
_tlOo_rename Map Identifier Attributes
_tlOsynMap TypeSyns
_tlOtSyns)
_lhsOextendedNTs :: Set NontermIdent
_lhsOextendedNTs :: Set Identifier
_lhsOextendedNTs = Set Identifier -> Set Identifier -> Set Identifier
rule101 Set Identifier
_hdIextendedNTs Set Identifier
_tlIextendedNTs
_lhsOinhMap' :: Map Identifier Attributes
_lhsOinhMap' :: Map Identifier Attributes
_lhsOinhMap' = Map Identifier Attributes
-> Map Identifier Attributes -> Map Identifier Attributes
rule102 Map Identifier Attributes
_hdIinhMap' Map Identifier Attributes
_tlIinhMap'
_lhsOppA :: PP_Doc
_lhsOppA :: PP_Doc
_lhsOppA = PP_Doc -> PP_Doc -> PP_Doc
rule103 PP_Doc
_hdIppA PP_Doc
_tlIppA
_lhsOppAI :: [PP_Doc]
_lhsOppAI :: [PP_Doc]
_lhsOppAI = [PP_Doc] -> [PP_Doc] -> [PP_Doc]
rule104 [PP_Doc]
_hdIppAI [PP_Doc]
_tlIppAI
_lhsOppCata :: PP_Doc
_lhsOppCata :: PP_Doc
_lhsOppCata = PP_Doc -> PP_Doc -> PP_Doc
rule105 PP_Doc
_hdIppCata PP_Doc
_tlIppCata
_lhsOppD :: PP_Doc
_lhsOppD :: PP_Doc
_lhsOppD = PP_Doc -> PP_Doc -> PP_Doc
rule106 PP_Doc
_hdIppD PP_Doc
_tlIppD
_lhsOppDI :: [PP_Doc]
_lhsOppDI :: [PP_Doc]
_lhsOppDI = [PP_Doc] -> [PP_Doc] -> [PP_Doc]
rule107 [PP_Doc]
_hdIppDI [PP_Doc]
_tlIppDI
_lhsOppL :: PP_Doc
_lhsOppL :: PP_Doc
_lhsOppL = PP_Doc -> PP_Doc -> PP_Doc
rule108 PP_Doc
_hdIppL PP_Doc
_tlIppL
_lhsOppLI :: [PP_Doc]
_lhsOppLI :: [PP_Doc]
_lhsOppLI = [PP_Doc] -> [PP_Doc] -> [PP_Doc]
rule109 [PP_Doc]
_hdIppLI [PP_Doc]
_tlIppLI
_lhsOppNtL :: [(PP_Doc, Attributes)]
_lhsOppNtL :: [(PP_Doc, Attributes)]
_lhsOppNtL = [(PP_Doc, Attributes)]
-> [(PP_Doc, Attributes)] -> [(PP_Doc, Attributes)]
rule110 [(PP_Doc, Attributes)]
_hdIppNtL [(PP_Doc, Attributes)]
_tlIppNtL
_lhsOppR :: PP_Doc
_lhsOppR :: PP_Doc
_lhsOppR = PP_Doc -> PP_Doc -> PP_Doc
rule111 PP_Doc
_hdIppR PP_Doc
_tlIppR
_lhsOppSF :: PP_Doc
_lhsOppSF :: PP_Doc
_lhsOppSF = PP_Doc -> PP_Doc -> PP_Doc
rule112 PP_Doc
_hdIppSF PP_Doc
_tlIppSF
_lhsOppW :: PP_Doc
_lhsOppW :: PP_Doc
_lhsOppW = PP_Doc -> PP_Doc -> PP_Doc
rule113 PP_Doc
_hdIppW PP_Doc
_tlIppW
_lhsOsynMap' :: Map Identifier Attributes
_lhsOsynMap' :: Map Identifier Attributes
_lhsOsynMap' = Map Identifier Attributes
-> Map Identifier Attributes -> Map Identifier Attributes
rule114 Map Identifier Attributes
_hdIsynMap' Map Identifier Attributes
_tlIsynMap'
_hdOderivs :: Derivings
_hdOderivs = Derivings -> Derivings
rule115 Derivings
_lhsIderivs
_hdOext :: Maybe String
_hdOext = Maybe String -> Maybe String
rule116 Maybe String
_lhsIext
_hdOinhMap :: Map Identifier Attributes
_hdOinhMap = Map Identifier Attributes -> Map Identifier Attributes
rule117 Map Identifier Attributes
_lhsIinhMap
_hdOnewAtts :: Attributes
_hdOnewAtts = Attributes -> Attributes
rule118 Attributes
_lhsInewAtts
_hdOnewNTs :: Set Identifier
_hdOnewNTs = Set Identifier -> Set Identifier
rule119 Set Identifier
_lhsInewNTs
_hdOnewProds :: DataTypes
_hdOnewProds = DataTypes -> DataTypes
rule120 DataTypes
_lhsInewProds
_hdOo_noGroup :: [String]
_hdOo_noGroup = [String] -> [String]
rule121 [String]
_lhsIo_noGroup
_hdOo_rename :: Bool
_hdOo_rename = Bool -> Bool
rule122 Bool
_lhsIo_rename
_hdOsynMap :: Map Identifier Attributes
_hdOsynMap = Map Identifier Attributes -> Map Identifier Attributes
rule123 Map Identifier Attributes
_lhsIsynMap
_hdOtSyns :: TypeSyns
_hdOtSyns = TypeSyns -> TypeSyns
rule124 TypeSyns
_lhsItSyns
_tlOderivs :: Derivings
_tlOderivs = Derivings -> Derivings
rule125 Derivings
_lhsIderivs
_tlOext :: Maybe String
_tlOext = Maybe String -> Maybe String
rule126 Maybe String
_lhsIext
_tlOinhMap :: Map Identifier Attributes
_tlOinhMap = Map Identifier Attributes -> Map Identifier Attributes
rule127 Map Identifier Attributes
_lhsIinhMap
_tlOnewAtts :: Attributes
_tlOnewAtts = Attributes -> Attributes
rule128 Attributes
_lhsInewAtts
_tlOnewNTs :: Set Identifier
_tlOnewNTs = Set Identifier -> Set Identifier
rule129 Set Identifier
_lhsInewNTs
_tlOnewProds :: DataTypes
_tlOnewProds = DataTypes -> DataTypes
rule130 DataTypes
_lhsInewProds
_tlOo_noGroup :: [String]
_tlOo_noGroup = [String] -> [String]
rule131 [String]
_lhsIo_noGroup
_tlOo_rename :: Bool
_tlOo_rename = Bool -> Bool
rule132 Bool
_lhsIo_rename
_tlOsynMap :: Map Identifier Attributes
_tlOsynMap = Map Identifier Attributes -> Map Identifier Attributes
rule133 Map Identifier Attributes
_lhsIsynMap
_tlOtSyns :: TypeSyns
_tlOtSyns = TypeSyns -> TypeSyns
rule134 TypeSyns
_lhsItSyns
__result_ :: T_Nonterminals_vOut25
__result_ = Set Identifier
-> Map Identifier Attributes
-> PP_Doc
-> [PP_Doc]
-> PP_Doc
-> PP_Doc
-> [PP_Doc]
-> PP_Doc
-> [PP_Doc]
-> [(PP_Doc, Attributes)]
-> PP_Doc
-> PP_Doc
-> PP_Doc
-> Map Identifier Attributes
-> T_Nonterminals_vOut25
T_Nonterminals_vOut25 Set Identifier
_lhsOextendedNTs Map Identifier Attributes
_lhsOinhMap' PP_Doc
_lhsOppA [PP_Doc]
_lhsOppAI PP_Doc
_lhsOppCata PP_Doc
_lhsOppD [PP_Doc]
_lhsOppDI PP_Doc
_lhsOppL [PP_Doc]
_lhsOppLI [(PP_Doc, Attributes)]
_lhsOppNtL PP_Doc
_lhsOppR PP_Doc
_lhsOppSF PP_Doc
_lhsOppW Map Identifier Attributes
_lhsOsynMap'
in T_Nonterminals_vOut25
__result_ )
in T_Nonterminals_v25 -> T_Nonterminals_s26
C_Nonterminals_s26 T_Nonterminals_v25
v25
{-# INLINE rule101 #-}
rule101 :: Set Identifier -> Set Identifier -> Set Identifier
rule101 = \ ((Set Identifier
_hdIextendedNTs) :: Set NontermIdent) ((Set Identifier
_tlIextendedNTs) :: Set NontermIdent) ->
Set Identifier
_hdIextendedNTs forall a. Ord a => Set a -> Set a -> Set a
`Set.union` Set Identifier
_tlIextendedNTs
{-# INLINE rule102 #-}
rule102 :: Map Identifier Attributes
-> Map Identifier Attributes -> Map Identifier Attributes
rule102 = \ ((Map Identifier Attributes
_hdIinhMap') :: Map Identifier Attributes) ((Map Identifier Attributes
_tlIinhMap') :: Map Identifier Attributes) ->
Map Identifier Attributes
_hdIinhMap' forall k a. Ord k => Map k a -> Map k a -> Map k a
`Map.union` Map Identifier Attributes
_tlIinhMap'
{-# INLINE rule103 #-}
rule103 :: PP_Doc -> PP_Doc -> PP_Doc
rule103 = \ ((PP_Doc
_hdIppA) :: PP_Doc) ((PP_Doc
_tlIppA) :: PP_Doc) ->
PP_Doc
_hdIppA forall a b. (PP a, PP b) => a -> b -> PP_Doc
>-< PP_Doc
_tlIppA
{-# INLINE rule104 #-}
rule104 :: [PP_Doc] -> [PP_Doc] -> [PP_Doc]
rule104 = \ (([PP_Doc]
_hdIppAI) :: [PP_Doc]) (([PP_Doc]
_tlIppAI) :: [PP_Doc]) ->
[PP_Doc]
_hdIppAI forall a. [a] -> [a] -> [a]
++ [PP_Doc]
_tlIppAI
{-# INLINE rule105 #-}
rule105 :: PP_Doc -> PP_Doc -> PP_Doc
rule105 = \ ((PP_Doc
_hdIppCata) :: PP_Doc) ((PP_Doc
_tlIppCata) :: PP_Doc) ->
PP_Doc
_hdIppCata forall a b. (PP a, PP b) => a -> b -> PP_Doc
>-< PP_Doc
_tlIppCata
{-# INLINE rule106 #-}
rule106 :: PP_Doc -> PP_Doc -> PP_Doc
rule106 = \ ((PP_Doc
_hdIppD) :: PP_Doc) ((PP_Doc
_tlIppD) :: PP_Doc) ->
PP_Doc
_hdIppD forall a b. (PP a, PP b) => a -> b -> PP_Doc
>-< PP_Doc
_tlIppD
{-# INLINE rule107 #-}
rule107 :: [PP_Doc] -> [PP_Doc] -> [PP_Doc]
rule107 = \ (([PP_Doc]
_hdIppDI) :: [PP_Doc]) (([PP_Doc]
_tlIppDI) :: [PP_Doc]) ->
[PP_Doc]
_hdIppDI forall a. [a] -> [a] -> [a]
++ [PP_Doc]
_tlIppDI
{-# INLINE rule108 #-}
rule108 :: PP_Doc -> PP_Doc -> PP_Doc
rule108 = \ ((PP_Doc
_hdIppL) :: PP_Doc) ((PP_Doc
_tlIppL) :: PP_Doc) ->
PP_Doc
_hdIppL forall a b. (PP a, PP b) => a -> b -> PP_Doc
>-< PP_Doc
_tlIppL
{-# INLINE rule109 #-}
rule109 :: [PP_Doc] -> [PP_Doc] -> [PP_Doc]
rule109 = \ (([PP_Doc]
_hdIppLI) :: [PP_Doc]) (([PP_Doc]
_tlIppLI) :: [PP_Doc]) ->
[PP_Doc]
_hdIppLI forall a. [a] -> [a] -> [a]
++ [PP_Doc]
_tlIppLI
{-# INLINE rule110 #-}
rule110 :: [(PP_Doc, Attributes)]
-> [(PP_Doc, Attributes)] -> [(PP_Doc, Attributes)]
rule110 = \ (([(PP_Doc, Attributes)]
_hdIppNtL) :: [(PP_Doc, Attributes)]) (([(PP_Doc, Attributes)]
_tlIppNtL) :: [(PP_Doc, Attributes)]) ->
[(PP_Doc, Attributes)]
_hdIppNtL forall a. [a] -> [a] -> [a]
++ [(PP_Doc, Attributes)]
_tlIppNtL
{-# INLINE rule111 #-}
rule111 :: PP_Doc -> PP_Doc -> PP_Doc
rule111 = \ ((PP_Doc
_hdIppR) :: PP_Doc) ((PP_Doc
_tlIppR) :: PP_Doc) ->
PP_Doc
_hdIppR forall a b. (PP a, PP b) => a -> b -> PP_Doc
>-< PP_Doc
_tlIppR
{-# INLINE rule112 #-}
rule112 :: PP_Doc -> PP_Doc -> PP_Doc
rule112 = \ ((PP_Doc
_hdIppSF) :: PP_Doc) ((PP_Doc
_tlIppSF) :: PP_Doc) ->
PP_Doc
_hdIppSF forall a b. (PP a, PP b) => a -> b -> PP_Doc
>-< PP_Doc
_tlIppSF
{-# INLINE rule113 #-}
rule113 :: PP_Doc -> PP_Doc -> PP_Doc
rule113 = \ ((PP_Doc
_hdIppW) :: PP_Doc) ((PP_Doc
_tlIppW) :: PP_Doc) ->
PP_Doc
_hdIppW forall a b. (PP a, PP b) => a -> b -> PP_Doc
>-< PP_Doc
_tlIppW
{-# INLINE rule114 #-}
rule114 :: Map Identifier Attributes
-> Map Identifier Attributes -> Map Identifier Attributes
rule114 = \ ((Map Identifier Attributes
_hdIsynMap') :: Map Identifier Attributes) ((Map Identifier Attributes
_tlIsynMap') :: Map Identifier Attributes) ->
Map Identifier Attributes
_hdIsynMap' forall k a. Ord k => Map k a -> Map k a -> Map k a
`Map.union` Map Identifier Attributes
_tlIsynMap'
{-# INLINE rule115 #-}
rule115 :: Derivings -> Derivings
rule115 = \ ((Derivings
_lhsIderivs) :: Derivings) ->
Derivings
_lhsIderivs
{-# INLINE rule116 #-}
rule116 :: Maybe String -> Maybe String
rule116 = \ ((Maybe String
_lhsIext) :: Maybe String) ->
Maybe String
_lhsIext
{-# INLINE rule117 #-}
rule117 :: Map Identifier Attributes -> Map Identifier Attributes
rule117 = \ ((Map Identifier Attributes
_lhsIinhMap) :: Map Identifier Attributes) ->
Map Identifier Attributes
_lhsIinhMap
{-# INLINE rule118 #-}
rule118 :: Attributes -> Attributes
rule118 = \ ((Attributes
_lhsInewAtts) :: Attributes ) ->
Attributes
_lhsInewAtts
{-# INLINE rule119 #-}
rule119 :: Set Identifier -> Set Identifier
rule119 = \ ((Set Identifier
_lhsInewNTs) :: Set NontermIdent) ->
Set Identifier
_lhsInewNTs
{-# INLINE rule120 #-}
rule120 :: DataTypes -> DataTypes
rule120 = \ ((DataTypes
_lhsInewProds) :: DataTypes ) ->
DataTypes
_lhsInewProds
{-# INLINE rule121 #-}
rule121 :: [String] -> [String]
rule121 = \ (([String]
_lhsIo_noGroup) :: [String]) ->
[String]
_lhsIo_noGroup
{-# INLINE rule122 #-}
rule122 :: Bool -> Bool
rule122 = \ ((Bool
_lhsIo_rename) :: Bool) ->
Bool
_lhsIo_rename
{-# INLINE rule123 #-}
rule123 :: Map Identifier Attributes -> Map Identifier Attributes
rule123 = \ ((Map Identifier Attributes
_lhsIsynMap) :: Map Identifier Attributes) ->
Map Identifier Attributes
_lhsIsynMap
{-# INLINE rule124 #-}
rule124 :: TypeSyns -> TypeSyns
rule124 = \ ((TypeSyns
_lhsItSyns) :: TypeSyns) ->
TypeSyns
_lhsItSyns
{-# INLINE rule125 #-}
rule125 :: Derivings -> Derivings
rule125 = \ ((Derivings
_lhsIderivs) :: Derivings) ->
Derivings
_lhsIderivs
{-# INLINE rule126 #-}
rule126 :: Maybe String -> Maybe String
rule126 = \ ((Maybe String
_lhsIext) :: Maybe String) ->
Maybe String
_lhsIext
{-# INLINE rule127 #-}
rule127 :: Map Identifier Attributes -> Map Identifier Attributes
rule127 = \ ((Map Identifier Attributes
_lhsIinhMap) :: Map Identifier Attributes) ->
Map Identifier Attributes
_lhsIinhMap
{-# INLINE rule128 #-}
rule128 :: Attributes -> Attributes
rule128 = \ ((Attributes
_lhsInewAtts) :: Attributes ) ->
Attributes
_lhsInewAtts
{-# INLINE rule129 #-}
rule129 :: Set Identifier -> Set Identifier
rule129 = \ ((Set Identifier
_lhsInewNTs) :: Set NontermIdent) ->
Set Identifier
_lhsInewNTs
{-# INLINE rule130 #-}
rule130 :: DataTypes -> DataTypes
rule130 = \ ((DataTypes
_lhsInewProds) :: DataTypes ) ->
DataTypes
_lhsInewProds
{-# INLINE rule131 #-}
rule131 :: [String] -> [String]
rule131 = \ (([String]
_lhsIo_noGroup) :: [String]) ->
[String]
_lhsIo_noGroup
{-# INLINE rule132 #-}
rule132 :: Bool -> Bool
rule132 = \ ((Bool
_lhsIo_rename) :: Bool) ->
Bool
_lhsIo_rename
{-# INLINE rule133 #-}
rule133 :: Map Identifier Attributes -> Map Identifier Attributes
rule133 = \ ((Map Identifier Attributes
_lhsIsynMap) :: Map Identifier Attributes) ->
Map Identifier Attributes
_lhsIsynMap
{-# INLINE rule134 #-}
rule134 :: TypeSyns -> TypeSyns
rule134 = \ ((TypeSyns
_lhsItSyns) :: TypeSyns) ->
TypeSyns
_lhsItSyns
{-# NOINLINE sem_Nonterminals_Nil #-}
sem_Nonterminals_Nil :: T_Nonterminals
sem_Nonterminals_Nil :: T_Nonterminals
sem_Nonterminals_Nil = Identity T_Nonterminals_s26 -> T_Nonterminals
T_Nonterminals (forall (m :: * -> *) a. Monad m => a -> m a
return T_Nonterminals_s26
st26) where
{-# NOINLINE st26 #-}
st26 :: T_Nonterminals_s26
st26 = let
v25 :: T_Nonterminals_v25
v25 :: T_Nonterminals_v25
v25 = \ (T_Nonterminals_vIn25 Derivings
_lhsIderivs Maybe String
_lhsIext Map Identifier Attributes
_lhsIinhMap Attributes
_lhsInewAtts Set Identifier
_lhsInewNTs DataTypes
_lhsInewProds [String]
_lhsIo_noGroup Bool
_lhsIo_rename Map Identifier Attributes
_lhsIsynMap TypeSyns
_lhsItSyns) -> ( let
_lhsOextendedNTs :: Set NontermIdent
_lhsOextendedNTs :: Set Identifier
_lhsOextendedNTs = forall {a}. () -> Set a
rule135 ()
_lhsOinhMap' :: Map Identifier Attributes
_lhsOinhMap' :: Map Identifier Attributes
_lhsOinhMap' = forall {k} {a}. () -> Map k a
rule136 ()
_lhsOppA :: PP_Doc
_lhsOppA :: PP_Doc
_lhsOppA = () -> PP_Doc
rule137 ()
_lhsOppAI :: [PP_Doc]
_lhsOppAI :: [PP_Doc]
_lhsOppAI = forall {a}. () -> [a]
rule138 ()
_lhsOppCata :: PP_Doc
_lhsOppCata :: PP_Doc
_lhsOppCata = () -> PP_Doc
rule139 ()
_lhsOppD :: PP_Doc
_lhsOppD :: PP_Doc
_lhsOppD = () -> PP_Doc
rule140 ()
_lhsOppDI :: [PP_Doc]
_lhsOppDI :: [PP_Doc]
_lhsOppDI = forall {a}. () -> [a]
rule141 ()
_lhsOppL :: PP_Doc
_lhsOppL :: PP_Doc
_lhsOppL = () -> PP_Doc
rule142 ()
_lhsOppLI :: [PP_Doc]
_lhsOppLI :: [PP_Doc]
_lhsOppLI = forall {a}. () -> [a]
rule143 ()
_lhsOppNtL :: [(PP_Doc, Attributes)]
_lhsOppNtL :: [(PP_Doc, Attributes)]
_lhsOppNtL = forall {a}. () -> [a]
rule144 ()
_lhsOppR :: PP_Doc
_lhsOppR :: PP_Doc
_lhsOppR = () -> PP_Doc
rule145 ()
_lhsOppSF :: PP_Doc
_lhsOppSF :: PP_Doc
_lhsOppSF = () -> PP_Doc
rule146 ()
_lhsOppW :: PP_Doc
_lhsOppW :: PP_Doc
_lhsOppW = () -> PP_Doc
rule147 ()
_lhsOsynMap' :: Map Identifier Attributes
_lhsOsynMap' :: Map Identifier Attributes
_lhsOsynMap' = forall {k} {a}. () -> Map k a
rule148 ()
__result_ :: T_Nonterminals_vOut25
__result_ = Set Identifier
-> Map Identifier Attributes
-> PP_Doc
-> [PP_Doc]
-> PP_Doc
-> PP_Doc
-> [PP_Doc]
-> PP_Doc
-> [PP_Doc]
-> [(PP_Doc, Attributes)]
-> PP_Doc
-> PP_Doc
-> PP_Doc
-> Map Identifier Attributes
-> T_Nonterminals_vOut25
T_Nonterminals_vOut25 Set Identifier
_lhsOextendedNTs Map Identifier Attributes
_lhsOinhMap' PP_Doc
_lhsOppA [PP_Doc]
_lhsOppAI PP_Doc
_lhsOppCata PP_Doc
_lhsOppD [PP_Doc]
_lhsOppDI PP_Doc
_lhsOppL [PP_Doc]
_lhsOppLI [(PP_Doc, Attributes)]
_lhsOppNtL PP_Doc
_lhsOppR PP_Doc
_lhsOppSF PP_Doc
_lhsOppW Map Identifier Attributes
_lhsOsynMap'
in T_Nonterminals_vOut25
__result_ )
in T_Nonterminals_v25 -> T_Nonterminals_s26
C_Nonterminals_s26 T_Nonterminals_v25
v25
{-# INLINE rule135 #-}
rule135 :: () -> Set a
rule135 = \ (()
_ :: ()) ->
forall a. Set a
Set.empty
{-# INLINE rule136 #-}
rule136 :: () -> Map k a
rule136 = \ (()
_ :: ()) ->
forall k a. Map k a
Map.empty
{-# INLINE rule137 #-}
rule137 :: () -> PP_Doc
rule137 = \ (()
_ :: ()) ->
PP_Doc
empty
{-# INLINE rule138 #-}
rule138 :: () -> [a]
rule138 = \ (()
_ :: ()) ->
[]
{-# INLINE rule139 #-}
rule139 :: () -> PP_Doc
rule139 = \ (()
_ :: ()) ->
PP_Doc
empty
{-# INLINE rule140 #-}
rule140 :: () -> PP_Doc
rule140 = \ (()
_ :: ()) ->
PP_Doc
empty
{-# INLINE rule141 #-}
rule141 :: () -> [a]
rule141 = \ (()
_ :: ()) ->
[]
{-# INLINE rule142 #-}
rule142 :: () -> PP_Doc
rule142 = \ (()
_ :: ()) ->
PP_Doc
empty
{-# INLINE rule143 #-}
rule143 :: () -> [a]
rule143 = \ (()
_ :: ()) ->
[]
{-# INLINE rule144 #-}
rule144 :: () -> [a]
rule144 = \ (()
_ :: ()) ->
[]
{-# INLINE rule145 #-}
rule145 :: () -> PP_Doc
rule145 = \ (()
_ :: ()) ->
PP_Doc
empty
{-# INLINE rule146 #-}
rule146 :: () -> PP_Doc
rule146 = \ (()
_ :: ()) ->
PP_Doc
empty
{-# INLINE rule147 #-}
rule147 :: () -> PP_Doc
rule147 = \ (()
_ :: ()) ->
PP_Doc
empty
{-# INLINE rule148 #-}
rule148 :: () -> Map k a
rule148 = \ (()
_ :: ()) ->
forall k a. Map k a
Map.empty
data Inh_Pattern = Inh_Pattern { }
data Syn_Pattern = Syn_Pattern { Syn_Pattern -> Pattern
copy_Syn_Pattern :: (Pattern), Syn_Pattern -> (Identifier, Identifier)
info_Syn_Pattern :: ((Identifier, Identifier)) }
{-# INLINABLE wrap_Pattern #-}
wrap_Pattern :: T_Pattern -> Inh_Pattern -> (Syn_Pattern )
wrap_Pattern :: T_Pattern -> Inh_Pattern -> Syn_Pattern
wrap_Pattern (T_Pattern Identity T_Pattern_s29
act) (Inh_Pattern
Inh_Pattern ) =
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
do T_Pattern_s29
sem <- Identity T_Pattern_s29
act
let arg28 :: T_Pattern_vIn28
arg28 = T_Pattern_vIn28
T_Pattern_vIn28
(T_Pattern_vOut28 Pattern
_lhsOcopy (Identifier, Identifier)
_lhsOinfo) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_Pattern_s29 -> T_Pattern_v28
inv_Pattern_s29 T_Pattern_s29
sem T_Pattern_vIn28
arg28)
forall (m :: * -> *) a. Monad m => a -> m a
return (Pattern -> (Identifier, Identifier) -> Syn_Pattern
Syn_Pattern Pattern
_lhsOcopy (Identifier, Identifier)
_lhsOinfo)
)
{-# NOINLINE sem_Pattern #-}
sem_Pattern :: Pattern -> T_Pattern
sem_Pattern :: Pattern -> T_Pattern
sem_Pattern ( Constr Identifier
name_ Patterns
pats_ ) = Identifier -> T_Patterns -> T_Pattern
sem_Pattern_Constr Identifier
name_ ( Patterns -> T_Patterns
sem_Patterns Patterns
pats_ )
sem_Pattern ( Product Pos
pos_ Patterns
pats_ ) = Pos -> T_Patterns -> T_Pattern
sem_Pattern_Product Pos
pos_ ( Patterns -> T_Patterns
sem_Patterns Patterns
pats_ )
sem_Pattern ( Alias Identifier
field_ Identifier
attr_ Pattern
pat_ ) = Identifier -> Identifier -> T_Pattern -> T_Pattern
sem_Pattern_Alias Identifier
field_ Identifier
attr_ ( Pattern -> T_Pattern
sem_Pattern Pattern
pat_ )
sem_Pattern ( Irrefutable Pattern
pat_ ) = T_Pattern -> T_Pattern
sem_Pattern_Irrefutable ( Pattern -> T_Pattern
sem_Pattern Pattern
pat_ )
sem_Pattern ( Underscore Pos
pos_ ) = Pos -> T_Pattern
sem_Pattern_Underscore Pos
pos_
newtype T_Pattern = T_Pattern {
T_Pattern -> Identity T_Pattern_s29
attach_T_Pattern :: Identity (T_Pattern_s29 )
}
newtype T_Pattern_s29 = C_Pattern_s29 {
T_Pattern_s29 -> T_Pattern_v28
inv_Pattern_s29 :: (T_Pattern_v28 )
}
data T_Pattern_s30 = C_Pattern_s30
type T_Pattern_v28 = (T_Pattern_vIn28 ) -> (T_Pattern_vOut28 )
data T_Pattern_vIn28 = T_Pattern_vIn28
data T_Pattern_vOut28 = T_Pattern_vOut28 (Pattern) ((Identifier, Identifier))
{-# NOINLINE sem_Pattern_Constr #-}
sem_Pattern_Constr :: (ConstructorIdent) -> T_Patterns -> T_Pattern
sem_Pattern_Constr :: Identifier -> T_Patterns -> T_Pattern
sem_Pattern_Constr Identifier
arg_name_ T_Patterns
arg_pats_ = Identity T_Pattern_s29 -> T_Pattern
T_Pattern (forall (m :: * -> *) a. Monad m => a -> m a
return T_Pattern_s29
st29) where
{-# NOINLINE st29 #-}
st29 :: T_Pattern_s29
st29 = let
v28 :: T_Pattern_v28
v28 :: T_Pattern_v28
v28 = \ (T_Pattern_vIn28
T_Pattern_vIn28 ) -> ( let
_patsX32 :: T_Patterns_s32
_patsX32 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Patterns -> Identity T_Patterns_s32
attach_T_Patterns (T_Patterns
arg_pats_))
(T_Patterns_vOut31 Patterns
_patsIcopy) = T_Patterns_s32 -> T_Patterns_v31
inv_Patterns_s32 T_Patterns_s32
_patsX32 (T_Patterns_vIn31
T_Patterns_vIn31 )
_lhsOinfo :: (Identifier, Identifier)
_lhsOinfo :: (Identifier, Identifier)
_lhsOinfo = forall {a}. () -> a
rule149 ()
_copy :: Pattern
_copy = Patterns -> Identifier -> Pattern
rule150 Patterns
_patsIcopy Identifier
arg_name_
_lhsOcopy :: Pattern
_lhsOcopy :: Pattern
_lhsOcopy = forall {p}. p -> p
rule151 Pattern
_copy
__result_ :: T_Pattern_vOut28
__result_ = Pattern -> (Identifier, Identifier) -> T_Pattern_vOut28
T_Pattern_vOut28 Pattern
_lhsOcopy (Identifier, Identifier)
_lhsOinfo
in T_Pattern_vOut28
__result_ )
in T_Pattern_v28 -> T_Pattern_s29
C_Pattern_s29 T_Pattern_v28
v28
{-# INLINE rule149 #-}
{-# LINE 383 "src-ag/AG2AspectAG.ag" #-}
rule149 = \ (_ :: ()) ->
{-# LINE 383 "src-ag/AG2AspectAG.ag" #-}
error "Pattern Constr undefined!!"
{-# LINE 1858 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule150 #-}
rule150 = \ ((_patsIcopy) :: Patterns) name_ ->
Constr name_ _patsIcopy
{-# INLINE rule151 #-}
rule151 = \ _copy ->
_copy
{-# NOINLINE sem_Pattern_Product #-}
sem_Pattern_Product :: (Pos) -> T_Patterns -> T_Pattern
sem_Pattern_Product :: Pos -> T_Patterns -> T_Pattern
sem_Pattern_Product Pos
arg_pos_ T_Patterns
arg_pats_ = Identity T_Pattern_s29 -> T_Pattern
T_Pattern (forall (m :: * -> *) a. Monad m => a -> m a
return T_Pattern_s29
st29) where
{-# NOINLINE st29 #-}
st29 :: T_Pattern_s29
st29 = let
v28 :: T_Pattern_v28
v28 :: T_Pattern_v28
v28 = \ (T_Pattern_vIn28
T_Pattern_vIn28 ) -> ( let
_patsX32 :: T_Patterns_s32
_patsX32 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Patterns -> Identity T_Patterns_s32
attach_T_Patterns (T_Patterns
arg_pats_))
(T_Patterns_vOut31 Patterns
_patsIcopy) = T_Patterns_s32 -> T_Patterns_v31
inv_Patterns_s32 T_Patterns_s32
_patsX32 (T_Patterns_vIn31
T_Patterns_vIn31 )
_lhsOinfo :: (Identifier, Identifier)
_lhsOinfo :: (Identifier, Identifier)
_lhsOinfo = forall {a}. () -> a
rule152 ()
_copy :: Pattern
_copy = Patterns -> Pos -> Pattern
rule153 Patterns
_patsIcopy Pos
arg_pos_
_lhsOcopy :: Pattern
_lhsOcopy :: Pattern
_lhsOcopy = forall {p}. p -> p
rule154 Pattern
_copy
__result_ :: T_Pattern_vOut28
__result_ = Pattern -> (Identifier, Identifier) -> T_Pattern_vOut28
T_Pattern_vOut28 Pattern
_lhsOcopy (Identifier, Identifier)
_lhsOinfo
in T_Pattern_vOut28
__result_ )
in T_Pattern_v28 -> T_Pattern_s29
C_Pattern_s29 T_Pattern_v28
v28
{-# INLINE rule152 #-}
{-# LINE 384 "src-ag/AG2AspectAG.ag" #-}
rule152 = \ (_ :: ()) ->
{-# LINE 384 "src-ag/AG2AspectAG.ag" #-}
error "Pattern Product undefined!!"
{-# LINE 1887 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule153 #-}
rule153 = \ ((_patsIcopy) :: Patterns) pos_ ->
Product pos_ _patsIcopy
{-# INLINE rule154 #-}
rule154 = \ _copy ->
_copy
{-# NOINLINE sem_Pattern_Alias #-}
sem_Pattern_Alias :: (Identifier) -> (Identifier) -> T_Pattern -> T_Pattern
sem_Pattern_Alias :: Identifier -> Identifier -> T_Pattern -> T_Pattern
sem_Pattern_Alias Identifier
arg_field_ Identifier
arg_attr_ T_Pattern
arg_pat_ = Identity T_Pattern_s29 -> T_Pattern
T_Pattern (forall (m :: * -> *) a. Monad m => a -> m a
return T_Pattern_s29
st29) where
{-# NOINLINE st29 #-}
st29 :: T_Pattern_s29
st29 = let
v28 :: T_Pattern_v28
v28 :: T_Pattern_v28
v28 = \ (T_Pattern_vIn28
T_Pattern_vIn28 ) -> ( let
_patX29 :: T_Pattern_s29
_patX29 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Pattern -> Identity T_Pattern_s29
attach_T_Pattern (T_Pattern
arg_pat_))
(T_Pattern_vOut28 Pattern
_patIcopy (Identifier, Identifier)
_patIinfo) = T_Pattern_s29 -> T_Pattern_v28
inv_Pattern_s29 T_Pattern_s29
_patX29 (T_Pattern_vIn28
T_Pattern_vIn28 )
_lhsOinfo :: (Identifier, Identifier)
_lhsOinfo :: (Identifier, Identifier)
_lhsOinfo = forall {b} {a}. b -> a -> (a, b)
rule155 Identifier
arg_attr_ Identifier
arg_field_
_copy :: Pattern
_copy = Pattern -> Identifier -> Identifier -> Pattern
rule156 Pattern
_patIcopy Identifier
arg_attr_ Identifier
arg_field_
_lhsOcopy :: Pattern
_lhsOcopy :: Pattern
_lhsOcopy = forall {p}. p -> p
rule157 Pattern
_copy
__result_ :: T_Pattern_vOut28
__result_ = Pattern -> (Identifier, Identifier) -> T_Pattern_vOut28
T_Pattern_vOut28 Pattern
_lhsOcopy (Identifier, Identifier)
_lhsOinfo
in T_Pattern_vOut28
__result_ )
in T_Pattern_v28 -> T_Pattern_s29
C_Pattern_s29 T_Pattern_v28
v28
{-# INLINE rule155 #-}
{-# LINE 382 "src-ag/AG2AspectAG.ag" #-}
rule155 = \ attr_ field_ ->
{-# LINE 382 "src-ag/AG2AspectAG.ag" #-}
(field_, attr_)
{-# LINE 1916 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule156 #-}
rule156 = \ ((_patIcopy) :: Pattern) attr_ field_ ->
Alias field_ attr_ _patIcopy
{-# INLINE rule157 #-}
rule157 = \ _copy ->
_copy
{-# NOINLINE sem_Pattern_Irrefutable #-}
sem_Pattern_Irrefutable :: T_Pattern -> T_Pattern
sem_Pattern_Irrefutable :: T_Pattern -> T_Pattern
sem_Pattern_Irrefutable T_Pattern
arg_pat_ = Identity T_Pattern_s29 -> T_Pattern
T_Pattern (forall (m :: * -> *) a. Monad m => a -> m a
return T_Pattern_s29
st29) where
{-# NOINLINE st29 #-}
st29 :: T_Pattern_s29
st29 = let
v28 :: T_Pattern_v28
v28 :: T_Pattern_v28
v28 = \ (T_Pattern_vIn28
T_Pattern_vIn28 ) -> ( let
_patX29 :: T_Pattern_s29
_patX29 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Pattern -> Identity T_Pattern_s29
attach_T_Pattern (T_Pattern
arg_pat_))
(T_Pattern_vOut28 Pattern
_patIcopy (Identifier, Identifier)
_patIinfo) = T_Pattern_s29 -> T_Pattern_v28
inv_Pattern_s29 T_Pattern_s29
_patX29 (T_Pattern_vIn28
T_Pattern_vIn28 )
_copy :: Pattern
_copy = Pattern -> Pattern
rule158 Pattern
_patIcopy
_lhsOcopy :: Pattern
_lhsOcopy :: Pattern
_lhsOcopy = forall {p}. p -> p
rule159 Pattern
_copy
_lhsOinfo :: (Identifier, Identifier)
_lhsOinfo :: (Identifier, Identifier)
_lhsOinfo = (Identifier, Identifier) -> (Identifier, Identifier)
rule160 (Identifier, Identifier)
_patIinfo
__result_ :: T_Pattern_vOut28
__result_ = Pattern -> (Identifier, Identifier) -> T_Pattern_vOut28
T_Pattern_vOut28 Pattern
_lhsOcopy (Identifier, Identifier)
_lhsOinfo
in T_Pattern_vOut28
__result_ )
in T_Pattern_v28 -> T_Pattern_s29
C_Pattern_s29 T_Pattern_v28
v28
{-# INLINE rule158 #-}
rule158 :: Pattern -> Pattern
rule158 = \ ((Pattern
_patIcopy) :: Pattern) ->
Pattern -> Pattern
Irrefutable Pattern
_patIcopy
{-# INLINE rule159 #-}
rule159 :: p -> p
rule159 = \ p
_copy ->
p
_copy
{-# INLINE rule160 #-}
rule160 :: (Identifier, Identifier) -> (Identifier, Identifier)
rule160 = \ (((Identifier, Identifier)
_patIinfo) :: (Identifier, Identifier)) ->
(Identifier, Identifier)
_patIinfo
{-# NOINLINE sem_Pattern_Underscore #-}
sem_Pattern_Underscore :: (Pos) -> T_Pattern
sem_Pattern_Underscore :: Pos -> T_Pattern
sem_Pattern_Underscore Pos
arg_pos_ = Identity T_Pattern_s29 -> T_Pattern
T_Pattern (forall (m :: * -> *) a. Monad m => a -> m a
return T_Pattern_s29
st29) where
{-# NOINLINE st29 #-}
st29 :: T_Pattern_s29
st29 = let
v28 :: T_Pattern_v28
v28 :: T_Pattern_v28
v28 = \ (T_Pattern_vIn28
T_Pattern_vIn28 ) -> ( let
_lhsOinfo :: (Identifier, Identifier)
_lhsOinfo :: (Identifier, Identifier)
_lhsOinfo = forall {a}. () -> a
rule161 ()
_copy :: Pattern
_copy = Pos -> Pattern
rule162 Pos
arg_pos_
_lhsOcopy :: Pattern
_lhsOcopy :: Pattern
_lhsOcopy = forall {p}. p -> p
rule163 Pattern
_copy
__result_ :: T_Pattern_vOut28
__result_ = Pattern -> (Identifier, Identifier) -> T_Pattern_vOut28
T_Pattern_vOut28 Pattern
_lhsOcopy (Identifier, Identifier)
_lhsOinfo
in T_Pattern_vOut28
__result_ )
in T_Pattern_v28 -> T_Pattern_s29
C_Pattern_s29 T_Pattern_v28
v28
{-# INLINE rule161 #-}
{-# LINE 385 "src-ag/AG2AspectAG.ag" #-}
rule161 = \ (_ :: ()) ->
{-# LINE 385 "src-ag/AG2AspectAG.ag" #-}
error "Pattern Underscore undefined!!"
{-# LINE 1969 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule162 #-}
rule162 = \ pos_ ->
Underscore pos_
{-# INLINE rule163 #-}
rule163 = \ _copy ->
_copy
data Inh_Patterns = Inh_Patterns { }
data Syn_Patterns = Syn_Patterns { Syn_Patterns -> Patterns
copy_Syn_Patterns :: (Patterns) }
{-# INLINABLE wrap_Patterns #-}
wrap_Patterns :: T_Patterns -> Inh_Patterns -> (Syn_Patterns )
wrap_Patterns :: T_Patterns -> Inh_Patterns -> Syn_Patterns
wrap_Patterns (T_Patterns Identity T_Patterns_s32
act) (Inh_Patterns
Inh_Patterns ) =
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
do T_Patterns_s32
sem <- Identity T_Patterns_s32
act
let arg31 :: T_Patterns_vIn31
arg31 = T_Patterns_vIn31
T_Patterns_vIn31
(T_Patterns_vOut31 Patterns
_lhsOcopy) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_Patterns_s32 -> T_Patterns_v31
inv_Patterns_s32 T_Patterns_s32
sem T_Patterns_vIn31
arg31)
forall (m :: * -> *) a. Monad m => a -> m a
return (Patterns -> Syn_Patterns
Syn_Patterns Patterns
_lhsOcopy)
)
{-# NOINLINE sem_Patterns #-}
sem_Patterns :: Patterns -> T_Patterns
sem_Patterns :: Patterns -> T_Patterns
sem_Patterns Patterns
list = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
Prelude.foldr T_Pattern -> T_Patterns -> T_Patterns
sem_Patterns_Cons T_Patterns
sem_Patterns_Nil (forall a b. (a -> b) -> [a] -> [b]
Prelude.map Pattern -> T_Pattern
sem_Pattern Patterns
list)
newtype T_Patterns = T_Patterns {
T_Patterns -> Identity T_Patterns_s32
attach_T_Patterns :: Identity (T_Patterns_s32 )
}
newtype T_Patterns_s32 = C_Patterns_s32 {
T_Patterns_s32 -> T_Patterns_v31
inv_Patterns_s32 :: (T_Patterns_v31 )
}
data T_Patterns_s33 = C_Patterns_s33
type T_Patterns_v31 = (T_Patterns_vIn31 ) -> (T_Patterns_vOut31 )
data T_Patterns_vIn31 = T_Patterns_vIn31
data T_Patterns_vOut31 = T_Patterns_vOut31 (Patterns)
{-# NOINLINE sem_Patterns_Cons #-}
sem_Patterns_Cons :: T_Pattern -> T_Patterns -> T_Patterns
sem_Patterns_Cons :: T_Pattern -> T_Patterns -> T_Patterns
sem_Patterns_Cons T_Pattern
arg_hd_ T_Patterns
arg_tl_ = Identity T_Patterns_s32 -> T_Patterns
T_Patterns (forall (m :: * -> *) a. Monad m => a -> m a
return T_Patterns_s32
st32) where
{-# NOINLINE st32 #-}
st32 :: T_Patterns_s32
st32 = let
v31 :: T_Patterns_v31
v31 :: T_Patterns_v31
v31 = \ (T_Patterns_vIn31
T_Patterns_vIn31 ) -> ( let
_hdX29 :: T_Pattern_s29
_hdX29 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Pattern -> Identity T_Pattern_s29
attach_T_Pattern (T_Pattern
arg_hd_))
_tlX32 :: T_Patterns_s32
_tlX32 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Patterns -> Identity T_Patterns_s32
attach_T_Patterns (T_Patterns
arg_tl_))
(T_Pattern_vOut28 Pattern
_hdIcopy (Identifier, Identifier)
_hdIinfo) = T_Pattern_s29 -> T_Pattern_v28
inv_Pattern_s29 T_Pattern_s29
_hdX29 (T_Pattern_vIn28
T_Pattern_vIn28 )
(T_Patterns_vOut31 Patterns
_tlIcopy) = T_Patterns_s32 -> T_Patterns_v31
inv_Patterns_s32 T_Patterns_s32
_tlX32 (T_Patterns_vIn31
T_Patterns_vIn31 )
_copy :: Patterns
_copy = Pattern -> Patterns -> Patterns
rule164 Pattern
_hdIcopy Patterns
_tlIcopy
_lhsOcopy :: Patterns
_lhsOcopy :: Patterns
_lhsOcopy = forall {p}. p -> p
rule165 Patterns
_copy
__result_ :: T_Patterns_vOut31
__result_ = Patterns -> T_Patterns_vOut31
T_Patterns_vOut31 Patterns
_lhsOcopy
in T_Patterns_vOut31
__result_ )
in T_Patterns_v31 -> T_Patterns_s32
C_Patterns_s32 T_Patterns_v31
v31
{-# INLINE rule164 #-}
rule164 :: Pattern -> Patterns -> Patterns
rule164 = \ ((Pattern
_hdIcopy) :: Pattern) ((Patterns
_tlIcopy) :: Patterns) ->
(:) Pattern
_hdIcopy Patterns
_tlIcopy
{-# INLINE rule165 #-}
rule165 :: p -> p
rule165 = \ p
_copy ->
p
_copy
{-# NOINLINE sem_Patterns_Nil #-}
sem_Patterns_Nil :: T_Patterns
sem_Patterns_Nil :: T_Patterns
sem_Patterns_Nil = Identity T_Patterns_s32 -> T_Patterns
T_Patterns (forall (m :: * -> *) a. Monad m => a -> m a
return T_Patterns_s32
st32) where
{-# NOINLINE st32 #-}
st32 :: T_Patterns_s32
st32 = let
v31 :: T_Patterns_v31
v31 :: T_Patterns_v31
v31 = \ (T_Patterns_vIn31
T_Patterns_vIn31 ) -> ( let
_copy :: [a]
_copy = forall {a}. () -> [a]
rule166 ()
_lhsOcopy :: Patterns
_lhsOcopy :: Patterns
_lhsOcopy = forall {p}. p -> p
rule167 forall a. [a]
_copy
__result_ :: T_Patterns_vOut31
__result_ = Patterns -> T_Patterns_vOut31
T_Patterns_vOut31 Patterns
_lhsOcopy
in T_Patterns_vOut31
__result_ )
in T_Patterns_v31 -> T_Patterns_s32
C_Patterns_s32 T_Patterns_v31
v31
{-# INLINE rule166 #-}
rule166 :: () -> [a]
rule166 = \ (()
_ :: ()) ->
[]
{-# INLINE rule167 #-}
rule167 :: p -> p
rule167 = \ p
_copy ->
p
_copy
data Inh_Production = Inh_Production { Inh_Production -> Maybe String
ext_Inh_Production :: (Maybe String), Inh_Production -> Attributes
inh_Inh_Production :: ( Attributes ), Inh_Production -> Map Identifier Attributes
inhMap_Inh_Production :: (Map Identifier Attributes), Inh_Production -> [String]
inhNoGroup_Inh_Production :: ([String]), Inh_Production -> Attributes
newAtts_Inh_Production :: ( Attributes ), Inh_Production -> Bool
newNT_Inh_Production :: (Bool), Inh_Production -> Map Identifier FieldMap
newProds_Inh_Production :: ( Map.Map ConstructorIdent FieldMap ), Inh_Production -> [String]
o_noGroup_Inh_Production :: ([String]), Inh_Production -> Bool
o_rename_Inh_Production :: (Bool), Inh_Production -> PP_Doc
ppNt_Inh_Production :: (PP_Doc), Inh_Production -> Attributes
syn_Inh_Production :: ( Attributes ), Inh_Production -> Map Identifier Attributes
synMap_Inh_Production :: (Map Identifier Attributes), Inh_Production -> [String]
synNoGroup_Inh_Production :: ([String]) }
data Syn_Production = Syn_Production { Syn_Production -> Bool
hasMoreProds_Syn_Production :: ( Bool ), Syn_Production -> PP_Doc
ppA_Syn_Production :: (PP_Doc), Syn_Production -> PP_Doc
ppCata_Syn_Production :: (PP_Doc), Syn_Production -> PP_Doc
ppD_Syn_Production :: (PP_Doc), Syn_Production -> [PP_Doc]
ppDI_Syn_Production :: ([PP_Doc]), Syn_Production -> PP_Doc
ppL_Syn_Production :: (PP_Doc), Syn_Production -> [PP_Doc]
ppLI_Syn_Production :: ([PP_Doc]), Syn_Production -> PP_Doc
ppR_Syn_Production :: (PP_Doc), Syn_Production -> [PP_Doc]
ppRA_Syn_Production :: ([PP_Doc]), Syn_Production -> PP_Doc
ppSF_Syn_Production :: (PP_Doc), Syn_Production -> PP_Doc
ppSPF_Syn_Production :: (PP_Doc), Syn_Production -> Attributes
prdInh_Syn_Production :: (Attributes) }
{-# INLINABLE wrap_Production #-}
wrap_Production :: T_Production -> Inh_Production -> (Syn_Production )
wrap_Production :: T_Production -> Inh_Production -> Syn_Production
wrap_Production (T_Production Identity T_Production_s35
act) (Inh_Production Maybe String
_lhsIext Attributes
_lhsIinh Map Identifier Attributes
_lhsIinhMap [String]
_lhsIinhNoGroup Attributes
_lhsInewAtts Bool
_lhsInewNT Map Identifier FieldMap
_lhsInewProds [String]
_lhsIo_noGroup Bool
_lhsIo_rename PP_Doc
_lhsIppNt Attributes
_lhsIsyn Map Identifier Attributes
_lhsIsynMap [String]
_lhsIsynNoGroup) =
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
do T_Production_s35
sem <- Identity T_Production_s35
act
let arg34 :: T_Production_vIn34
arg34 = Maybe String
-> Attributes
-> Map Identifier Attributes
-> [String]
-> Attributes
-> Bool
-> Map Identifier FieldMap
-> [String]
-> Bool
-> PP_Doc
-> Attributes
-> Map Identifier Attributes
-> [String]
-> T_Production_vIn34
T_Production_vIn34 Maybe String
_lhsIext Attributes
_lhsIinh Map Identifier Attributes
_lhsIinhMap [String]
_lhsIinhNoGroup Attributes
_lhsInewAtts Bool
_lhsInewNT Map Identifier FieldMap
_lhsInewProds [String]
_lhsIo_noGroup Bool
_lhsIo_rename PP_Doc
_lhsIppNt Attributes
_lhsIsyn Map Identifier Attributes
_lhsIsynMap [String]
_lhsIsynNoGroup
(T_Production_vOut34 Bool
_lhsOhasMoreProds PP_Doc
_lhsOppA PP_Doc
_lhsOppCata PP_Doc
_lhsOppD [PP_Doc]
_lhsOppDI PP_Doc
_lhsOppL [PP_Doc]
_lhsOppLI PP_Doc
_lhsOppR [PP_Doc]
_lhsOppRA PP_Doc
_lhsOppSF PP_Doc
_lhsOppSPF Attributes
_lhsOprdInh) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_Production_s35 -> T_Production_v34
inv_Production_s35 T_Production_s35
sem T_Production_vIn34
arg34)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
-> PP_Doc
-> PP_Doc
-> PP_Doc
-> [PP_Doc]
-> PP_Doc
-> [PP_Doc]
-> PP_Doc
-> [PP_Doc]
-> PP_Doc
-> PP_Doc
-> Attributes
-> Syn_Production
Syn_Production Bool
_lhsOhasMoreProds PP_Doc
_lhsOppA PP_Doc
_lhsOppCata PP_Doc
_lhsOppD [PP_Doc]
_lhsOppDI PP_Doc
_lhsOppL [PP_Doc]
_lhsOppLI PP_Doc
_lhsOppR [PP_Doc]
_lhsOppRA PP_Doc
_lhsOppSF PP_Doc
_lhsOppSPF Attributes
_lhsOprdInh)
)
{-# INLINE sem_Production #-}
sem_Production :: Production -> T_Production
sem_Production :: Production -> T_Production
sem_Production ( Production Identifier
con_ [Identifier]
params_ [Type]
constraints_ Children
children_ Rules
rules_ TypeSigs
typeSigs_ Maybe Macro
macro_ ) = Identifier
-> [Identifier]
-> [Type]
-> T_Children
-> T_Rules
-> T_TypeSigs
-> Maybe Macro
-> T_Production
sem_Production_Production Identifier
con_ [Identifier]
params_ [Type]
constraints_ ( Children -> T_Children
sem_Children Children
children_ ) ( Rules -> T_Rules
sem_Rules Rules
rules_ ) ( TypeSigs -> T_TypeSigs
sem_TypeSigs TypeSigs
typeSigs_ ) Maybe Macro
macro_
newtype T_Production = T_Production {
T_Production -> Identity T_Production_s35
attach_T_Production :: Identity (T_Production_s35 )
}
newtype T_Production_s35 = C_Production_s35 {
T_Production_s35 -> T_Production_v34
inv_Production_s35 :: (T_Production_v34 )
}
data T_Production_s36 = C_Production_s36
type T_Production_v34 = (T_Production_vIn34 ) -> (T_Production_vOut34 )
data T_Production_vIn34 = T_Production_vIn34 (Maybe String) ( Attributes ) (Map Identifier Attributes) ([String]) ( Attributes ) (Bool) ( Map.Map ConstructorIdent FieldMap ) ([String]) (Bool) (PP_Doc) ( Attributes ) (Map Identifier Attributes) ([String])
data T_Production_vOut34 = T_Production_vOut34 ( Bool ) (PP_Doc) (PP_Doc) (PP_Doc) ([PP_Doc]) (PP_Doc) ([PP_Doc]) (PP_Doc) ([PP_Doc]) (PP_Doc) (PP_Doc) (Attributes)
{-# NOINLINE sem_Production_Production #-}
sem_Production_Production :: (ConstructorIdent) -> ([Identifier]) -> ([Type]) -> T_Children -> T_Rules -> T_TypeSigs -> (MaybeMacro) -> T_Production
sem_Production_Production :: Identifier
-> [Identifier]
-> [Type]
-> T_Children
-> T_Rules
-> T_TypeSigs
-> Maybe Macro
-> T_Production
sem_Production_Production Identifier
arg_con_ [Identifier]
_ [Type]
_ T_Children
arg_children_ T_Rules
arg_rules_ T_TypeSigs
arg_typeSigs_ Maybe Macro
arg_macro_ = Identity T_Production_s35 -> T_Production
T_Production (forall (m :: * -> *) a. Monad m => a -> m a
return T_Production_s35
st35) where
{-# NOINLINE st35 #-}
st35 :: T_Production_s35
st35 = let
v34 :: T_Production_v34
v34 :: T_Production_v34
v34 = \ (T_Production_vIn34 Maybe String
_lhsIext Attributes
_lhsIinh Map Identifier Attributes
_lhsIinhMap [String]
_lhsIinhNoGroup Attributes
_lhsInewAtts Bool
_lhsInewNT Map Identifier FieldMap
_lhsInewProds [String]
_lhsIo_noGroup Bool
_lhsIo_rename PP_Doc
_lhsIppNt Attributes
_lhsIsyn Map Identifier Attributes
_lhsIsynMap [String]
_lhsIsynNoGroup) -> ( let
_childrenX5 :: T_Children_s5
_childrenX5 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Children -> Identity T_Children_s5
attach_T_Children (T_Children
arg_children_))
_rulesX44 :: T_Rules_s44
_rulesX44 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Rules -> Identity T_Rules_s44
attach_T_Rules (T_Rules
arg_rules_))
_typeSigsX50 :: T_TypeSigs_s50
_typeSigsX50 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_TypeSigs -> Identity T_TypeSigs_s50
attach_T_TypeSigs (T_TypeSigs
arg_typeSigs_))
(T_Children_vOut4 FieldMap
_childrenIidCL [(Identifier, (PP_Doc, PP_Doc))]
_childrenIppCSF [PP_Doc]
_childrenIppDL PP_Doc
_childrenIppL [PP_Doc]
_childrenIppLI PP_Doc
_childrenIppR Attributes
_childrenIprdInh) = T_Children_s5 -> T_Children_v4
inv_Children_s5 T_Children_s5
_childrenX5 (Maybe String
-> Map Identifier Attributes
-> [String]
-> Attributes
-> [String]
-> Bool
-> PP_Doc
-> PP_Doc
-> Map Identifier Attributes
-> [String]
-> T_Children_vIn4
T_Children_vIn4 Maybe String
_childrenOext Map Identifier Attributes
_childrenOinhMap [String]
_childrenOinhNoGroup Attributes
_childrenOnewAtts [String]
_childrenOo_noGroup Bool
_childrenOo_rename PP_Doc
_childrenOppNt PP_Doc
_childrenOppProd Map Identifier Attributes
_childrenOsynMap [String]
_childrenOsynNoGroup)
(T_Rules_vOut43 [Identifier]
_rulesIlocals [PPRule]
_rulesIppRL) = T_Rules_s44 -> T_Rules_v43
inv_Rules_s44 T_Rules_s44
_rulesX44 (Maybe String
-> [String]
-> Attributes
-> Bool
-> [String]
-> PP_Doc
-> PP_Doc
-> [String]
-> T_Rules_vIn43
T_Rules_vIn43 Maybe String
_rulesOext [String]
_rulesOinhNoGroup Attributes
_rulesOnewAtts Bool
_rulesOnewProd [String]
_rulesOo_noGroup PP_Doc
_rulesOppNt PP_Doc
_rulesOppProd [String]
_rulesOsynNoGroup)
(T_TypeSigs_vOut49
T_TypeSigs_vOut49 ) = T_TypeSigs_s50 -> T_TypeSigs_v49
inv_TypeSigs_s50 T_TypeSigs_s50
_typeSigsX50 (T_TypeSigs_vIn49
T_TypeSigs_vIn49 )
_lhsOhasMoreProds :: Bool
_lhsOhasMoreProds :: Bool
_lhsOhasMoreProds = Map Identifier FieldMap -> Identifier -> Bool
rule168 Map Identifier FieldMap
_lhsInewProds Identifier
arg_con_
_ppProd :: PP_Doc
_ppProd = Identifier -> PP_Doc
rule169 Identifier
arg_con_
_prodName :: PP_Doc
_prodName = PP_Doc -> PP_Doc -> PP_Doc
rule170 PP_Doc
_lhsIppNt PP_Doc
_ppProd
_conName :: PP_Doc
_conName = forall {p}. Bool -> p -> p -> p
rule171 Bool
_lhsIo_rename PP_Doc
_ppProd PP_Doc
_prodName
_childrenOppProd :: PP_Doc
_childrenOppProd = forall {p}. p -> p
rule172 PP_Doc
_ppProd
_rulesOppProd :: PP_Doc
_rulesOppProd = forall {p}. p -> p
rule173 PP_Doc
_ppProd
_lhsOppD :: PP_Doc
_lhsOppD :: PP_Doc
_lhsOppD = [PP_Doc] -> PP_Doc -> PP_Doc
rule174 [PP_Doc]
_childrenIppDL PP_Doc
_conName
_lhsOppL :: PP_Doc
_lhsOppL :: PP_Doc
_lhsOppL = PP_Doc -> Map Identifier FieldMap -> Identifier -> PP_Doc
rule175 PP_Doc
_childrenIppL Map Identifier FieldMap
_lhsInewProds Identifier
arg_con_
_lhsOppLI :: [PP_Doc]
_lhsOppLI :: [PP_Doc]
_lhsOppLI = [PP_Doc] -> Map Identifier FieldMap -> Identifier -> [PP_Doc]
rule176 [PP_Doc]
_childrenIppLI Map Identifier FieldMap
_lhsInewProds Identifier
arg_con_
_lhsOppA :: PP_Doc
_lhsOppA :: PP_Doc
_lhsOppA = PP_Doc -> [Identifier] -> PP_Doc
rule177 PP_Doc
_prodName [Identifier]
_rulesIlocals
_newProd :: Bool
_newProd = Map Identifier FieldMap -> Identifier -> Bool
rule178 Map Identifier FieldMap
_lhsInewProds Identifier
arg_con_
(PP_Doc
_ppR,[PP_Doc]
_ppRA) = FieldMap
-> PP_Doc
-> [String]
-> Attributes
-> Bool
-> PP_Doc
-> [String]
-> Bool
-> PP_Doc
-> [Identifier]
-> [PPRule]
-> Identifier
-> (PP_Doc, [PP_Doc])
rule179 FieldMap
_childrenIidCL PP_Doc
_childrenIppR [String]
_lhsIinhNoGroup Attributes
_lhsInewAtts Bool
_lhsInewNT PP_Doc
_lhsIppNt [String]
_lhsIsynNoGroup Bool
_newProd PP_Doc
_prodName [Identifier]
_rulesIlocals [PPRule]
_rulesIppRL Identifier
arg_con_
_lhsOppCata :: PP_Doc
_lhsOppCata :: PP_Doc
_lhsOppCata = Maybe String
-> Bool -> Bool -> [PP_Doc] -> PP_Doc -> Maybe Macro -> PP_Doc
rule180 Maybe String
_lhsIext Bool
_lhsInewNT Bool
_newProd [PP_Doc]
_ppRA PP_Doc
_prodName Maybe Macro
arg_macro_
_lhsOppSF :: PP_Doc
_lhsOppSF :: PP_Doc
_lhsOppSF = [(Identifier, (PP_Doc, PP_Doc))]
-> PP_Doc -> PP_Doc -> PP_Doc -> Identifier -> PP_Doc
rule181 [(Identifier, (PP_Doc, PP_Doc))]
_childrenIppCSF PP_Doc
_conName PP_Doc
_lhsIppNt PP_Doc
_prodName Identifier
arg_con_
_lhsOppSPF :: PP_Doc
_lhsOppSPF :: PP_Doc
_lhsOppSPF = [(Identifier, (PP_Doc, PP_Doc))]
-> PP_Doc -> PP_Doc -> Identifier -> PP_Doc
rule182 [(Identifier, (PP_Doc, PP_Doc))]
_childrenIppCSF PP_Doc
_lhsIppNt PP_Doc
_prodName Identifier
arg_con_
_lhsOppDI :: [PP_Doc]
_lhsOppDI :: [PP_Doc]
_lhsOppDI = forall {a}. () -> [a]
rule183 ()
_lhsOppR :: PP_Doc
_lhsOppR :: PP_Doc
_lhsOppR = forall {p}. p -> p
rule184 PP_Doc
_ppR
_lhsOppRA :: [PP_Doc]
_lhsOppRA :: [PP_Doc]
_lhsOppRA = forall {p}. p -> p
rule185 [PP_Doc]
_ppRA
_lhsOprdInh :: Attributes
_lhsOprdInh :: Attributes
_lhsOprdInh = Attributes -> Attributes
rule186 Attributes
_childrenIprdInh
_childrenOext :: Maybe String
_childrenOext = Maybe String -> Maybe String
rule187 Maybe String
_lhsIext
_childrenOinhMap :: Map Identifier Attributes
_childrenOinhMap = Map Identifier Attributes -> Map Identifier Attributes
rule188 Map Identifier Attributes
_lhsIinhMap
_childrenOinhNoGroup :: [String]
_childrenOinhNoGroup = [String] -> [String]
rule189 [String]
_lhsIinhNoGroup
_childrenOnewAtts :: Attributes
_childrenOnewAtts = Attributes -> Attributes
rule190 Attributes
_lhsInewAtts
_childrenOo_noGroup :: [String]
_childrenOo_noGroup = [String] -> [String]
rule191 [String]
_lhsIo_noGroup
_childrenOo_rename :: Bool
_childrenOo_rename = Bool -> Bool
rule192 Bool
_lhsIo_rename
_childrenOppNt :: PP_Doc
_childrenOppNt = PP_Doc -> PP_Doc
rule193 PP_Doc
_lhsIppNt
_childrenOsynMap :: Map Identifier Attributes
_childrenOsynMap = Map Identifier Attributes -> Map Identifier Attributes
rule194 Map Identifier Attributes
_lhsIsynMap
_childrenOsynNoGroup :: [String]
_childrenOsynNoGroup = [String] -> [String]
rule195 [String]
_lhsIsynNoGroup
_rulesOext :: Maybe String
_rulesOext = Maybe String -> Maybe String
rule196 Maybe String
_lhsIext
_rulesOinhNoGroup :: [String]
_rulesOinhNoGroup = [String] -> [String]
rule197 [String]
_lhsIinhNoGroup
_rulesOnewAtts :: Attributes
_rulesOnewAtts = Attributes -> Attributes
rule198 Attributes
_lhsInewAtts
_rulesOnewProd :: Bool
_rulesOnewProd = forall {p}. p -> p
rule199 Bool
_newProd
_rulesOo_noGroup :: [String]
_rulesOo_noGroup = [String] -> [String]
rule200 [String]
_lhsIo_noGroup
_rulesOppNt :: PP_Doc
_rulesOppNt = PP_Doc -> PP_Doc
rule201 PP_Doc
_lhsIppNt
_rulesOsynNoGroup :: [String]
_rulesOsynNoGroup = [String] -> [String]
rule202 [String]
_lhsIsynNoGroup
__result_ :: T_Production_vOut34
__result_ = Bool
-> PP_Doc
-> PP_Doc
-> PP_Doc
-> [PP_Doc]
-> PP_Doc
-> [PP_Doc]
-> PP_Doc
-> [PP_Doc]
-> PP_Doc
-> PP_Doc
-> Attributes
-> T_Production_vOut34
T_Production_vOut34 Bool
_lhsOhasMoreProds PP_Doc
_lhsOppA PP_Doc
_lhsOppCata PP_Doc
_lhsOppD [PP_Doc]
_lhsOppDI PP_Doc
_lhsOppL [PP_Doc]
_lhsOppLI PP_Doc
_lhsOppR [PP_Doc]
_lhsOppRA PP_Doc
_lhsOppSF PP_Doc
_lhsOppSPF Attributes
_lhsOprdInh
in T_Production_vOut34
__result_ )
in T_Production_v34 -> T_Production_s35
C_Production_s35 T_Production_v34
v34
{-# INLINE rule168 #-}
{-# LINE 103 "src-ag/AG2AspectAG.ag" #-}
rule168 = \ ((_lhsInewProds) :: Map.Map ConstructorIdent FieldMap ) con_ ->
{-# LINE 103 "src-ag/AG2AspectAG.ag" #-}
not $ Map.member con_ _lhsInewProds
{-# LINE 2148 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule169 #-}
{-# LINE 176 "src-ag/AG2AspectAG.ag" #-}
rule169 = \ con_ ->
{-# LINE 176 "src-ag/AG2AspectAG.ag" #-}
pp con_
{-# LINE 2154 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule170 #-}
{-# LINE 177 "src-ag/AG2AspectAG.ag" #-}
rule170 = \ ((_lhsIppNt) :: PP_Doc) _ppProd ->
{-# LINE 177 "src-ag/AG2AspectAG.ag" #-}
ppName [_lhsIppNt, _ppProd ]
{-# LINE 2160 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule171 #-}
{-# LINE 178 "src-ag/AG2AspectAG.ag" #-}
rule171 = \ ((_lhsIo_rename) :: Bool) _ppProd _prodName ->
{-# LINE 178 "src-ag/AG2AspectAG.ag" #-}
if _lhsIo_rename
then _prodName
else _ppProd
{-# LINE 2168 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule172 #-}
{-# LINE 195 "src-ag/AG2AspectAG.ag" #-}
rule172 = \ _ppProd ->
{-# LINE 195 "src-ag/AG2AspectAG.ag" #-}
_ppProd
{-# LINE 2174 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule173 #-}
{-# LINE 196 "src-ag/AG2AspectAG.ag" #-}
rule173 = \ _ppProd ->
{-# LINE 196 "src-ag/AG2AspectAG.ag" #-}
_ppProd
{-# LINE 2180 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule174 #-}
{-# LINE 228 "src-ag/AG2AspectAG.ag" #-}
rule174 = \ ((_childrenIppDL) :: [PP_Doc]) _conName ->
{-# LINE 228 "src-ag/AG2AspectAG.ag" #-}
_conName >|< ppListSep " {" "}" ", " _childrenIppDL
{-# LINE 2186 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule175 #-}
{-# LINE 275 "src-ag/AG2AspectAG.ag" #-}
rule175 = \ ((_childrenIppL) :: PP_Doc) ((_lhsInewProds) :: Map.Map ConstructorIdent FieldMap ) con_ ->
{-# LINE 275 "src-ag/AG2AspectAG.ag" #-}
if (Map.member con_ _lhsInewProds)
then _childrenIppL
else empty
{-# LINE 2194 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule176 #-}
{-# LINE 279 "src-ag/AG2AspectAG.ag" #-}
rule176 = \ ((_childrenIppLI) :: [PP_Doc]) ((_lhsInewProds) :: Map.Map ConstructorIdent FieldMap ) con_ ->
{-# LINE 279 "src-ag/AG2AspectAG.ag" #-}
if (not $ Map.member con_ _lhsInewProds)
then _childrenIppLI
else []
{-# LINE 2202 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule177 #-}
{-# LINE 332 "src-ag/AG2AspectAG.ag" #-}
rule177 = \ _prodName ((_rulesIlocals) :: [Identifier]) ->
{-# LINE 332 "src-ag/AG2AspectAG.ag" #-}
defLocalAtts _prodName (length _rulesIlocals) 1 $ sort _rulesIlocals
{-# LINE 2208 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule178 #-}
{-# LINE 428 "src-ag/AG2AspectAG.ag" #-}
rule178 = \ ((_lhsInewProds) :: Map.Map ConstructorIdent FieldMap ) con_ ->
{-# LINE 428 "src-ag/AG2AspectAG.ag" #-}
Map.member con_ _lhsInewProds
{-# LINE 2214 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule179 #-}
{-# LINE 430 "src-ag/AG2AspectAG.ag" #-}
rule179 = \ ((_childrenIidCL) :: [(Identifier,Type)]) ((_childrenIppR) :: PP_Doc) ((_lhsIinhNoGroup) :: [String]) ((_lhsInewAtts) :: Attributes ) ((_lhsInewNT) :: Bool) ((_lhsIppNt) :: PP_Doc) ((_lhsIsynNoGroup) :: [String]) _newProd _prodName ((_rulesIlocals) :: [Identifier]) ((_rulesIppRL) :: [ PPRule ]) con_ ->
{-# LINE 430 "src-ag/AG2AspectAG.ag" #-}
let (instR, instRA) = defInstRules _lhsIppNt con_ _lhsInewNT _newProd
_childrenIppR _rulesIppRL _childrenIidCL _rulesIlocals
(locR, locRA) = defLocRule _lhsIppNt con_ _lhsInewNT _newProd
_childrenIppR _rulesIppRL _lhsIinhNoGroup _lhsIsynNoGroup _childrenIidCL _rulesIlocals
(inhGR, inhGRA) = defInhGRule _lhsIppNt _prodName _lhsInewNT _newProd
_childrenIppR _rulesIppRL _lhsIinhNoGroup _lhsIsynNoGroup _childrenIidCL _rulesIlocals
(synGR, synGRA) = defSynGRule _lhsIppNt con_ _lhsInewNT _newProd
_childrenIppR _rulesIppRL _lhsIinhNoGroup _lhsIsynNoGroup _childrenIidCL _rulesIlocals
(inhR, inhRA) = defInhRules _lhsIppNt _prodName _lhsInewNT _newProd _lhsInewAtts
_childrenIppR _rulesIppRL _lhsIinhNoGroup _lhsIsynNoGroup _childrenIidCL _rulesIlocals
(synR, synRA) = defSynRules _lhsIppNt con_ _lhsInewNT _newProd _lhsInewAtts
_childrenIppR _rulesIppRL _lhsIinhNoGroup _lhsIsynNoGroup _childrenIidCL _rulesIlocals
(inhMR, inhMRA) = modInhRules _lhsIppNt _prodName _lhsInewNT _newProd _lhsInewAtts
_childrenIppR _rulesIppRL _lhsIinhNoGroup _lhsIsynNoGroup _childrenIidCL _rulesIlocals
(synMR, synMRA) = modSynRules _lhsIppNt con_ _lhsInewNT _newProd _lhsInewAtts
_childrenIppR _rulesIppRL _lhsIinhNoGroup _lhsIsynNoGroup _childrenIidCL _rulesIlocals
in ( vlist [instR,locR,inhGR,synGR,inhR,synR,inhMR,synMR]
, instRA ++ locRA ++ inhGRA ++ synGRA ++ inhMRA ++ synMRA ++ inhRA ++ synRA)
{-# LINE 2237 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule180 #-}
{-# LINE 740 "src-ag/AG2AspectAG.ag" #-}
rule180 = \ ((_lhsIext) :: Maybe String) ((_lhsInewNT) :: Bool) _newProd _ppRA _prodName macro_ ->
{-# LINE 740 "src-ag/AG2AspectAG.ag" #-}
let extend = maybe []
( \ext -> if (_lhsInewNT || (not _lhsInewNT && _newProd ))
then []
else [ ext >|< ".atts_" >|< _prodName ])
_lhsIext
macro = case macro_ of
Nothing -> []
Just macro -> [ "agMacro " >|< ppMacro macro ]
atts = sortBy (\a b -> compare (show a) (show b)) _ppRA
in "atts_" >|< _prodName >|< " = " >|<
ppListSep "" "" " `ext` "
(atts ++ macro ++ extend ) >-<
"semP_" >|< _prodName >|< pp " = knit atts_" >|< _prodName
{-# LINE 2255 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule181 #-}
{-# LINE 804 "src-ag/AG2AspectAG.ag" #-}
rule181 = \ ((_childrenIppCSF) :: [(Identifier,(PP_Doc,PP_Doc))]) _conName ((_lhsIppNt) :: PP_Doc) _prodName con_ ->
{-# LINE 804 "src-ag/AG2AspectAG.ag" #-}
let chi = _childrenIppCSF
ppPattern = case (show con_) of
"Cons" -> ppParams (ppListSep "" "" " : ")
"Nil" -> pp "[]"
otherwise -> _conName >|< " " >|< (ppParams ppSpaced)
ppParams f = f $ map (((>|<) (pp "_")) . fst) chi
in "sem_" >|< _lhsIppNt >|< " (" >|< ppPattern >|< ") = sem_" >|< _prodName >|<
" (" >|< map (fst . snd) chi >|< "emptyRecord)"
{-# LINE 2268 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule182 #-}
{-# LINE 816 "src-ag/AG2AspectAG.ag" #-}
rule182 = \ ((_childrenIppCSF) :: [(Identifier,(PP_Doc,PP_Doc))]) ((_lhsIppNt) :: PP_Doc) _prodName con_ ->
{-# LINE 816 "src-ag/AG2AspectAG.ag" #-}
let chi = _childrenIppCSF
ppParams f = f $ map (((>|<) (pp "_")) . fst) chi
in "sem_" >|< _lhsIppNt >|< "_" >|< con_ >#< ppParams ppSpaced >|< " = semP_" >|< _prodName >|<
" (" >|< map (snd . snd) chi >|< "emptyRecord)"
{-# LINE 2277 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule183 #-}
rule183 = \ (_ :: ()) ->
[]
{-# INLINE rule184 #-}
rule184 = \ _ppR ->
_ppR
{-# INLINE rule185 #-}
rule185 = \ _ppRA ->
_ppRA
{-# INLINE rule186 #-}
rule186 = \ ((_childrenIprdInh) :: Attributes) ->
_childrenIprdInh
{-# INLINE rule187 #-}
rule187 = \ ((_lhsIext) :: Maybe String) ->
_lhsIext
{-# INLINE rule188 #-}
rule188 = \ ((_lhsIinhMap) :: Map Identifier Attributes) ->
_lhsIinhMap
{-# INLINE rule189 #-}
rule189 = \ ((_lhsIinhNoGroup) :: [String]) ->
_lhsIinhNoGroup
{-# INLINE rule190 #-}
rule190 = \ ((_lhsInewAtts) :: Attributes ) ->
_lhsInewAtts
{-# INLINE rule191 #-}
rule191 = \ ((_lhsIo_noGroup) :: [String]) ->
_lhsIo_noGroup
{-# INLINE rule192 #-}
rule192 = \ ((_lhsIo_rename) :: Bool) ->
_lhsIo_rename
{-# INLINE rule193 #-}
rule193 = \ ((_lhsIppNt) :: PP_Doc) ->
_lhsIppNt
{-# INLINE rule194 #-}
rule194 = \ ((_lhsIsynMap) :: Map Identifier Attributes) ->
_lhsIsynMap
{-# INLINE rule195 #-}
rule195 = \ ((_lhsIsynNoGroup) :: [String]) ->
_lhsIsynNoGroup
{-# INLINE rule196 #-}
rule196 = \ ((_lhsIext) :: Maybe String) ->
_lhsIext
{-# INLINE rule197 #-}
rule197 = \ ((_lhsIinhNoGroup) :: [String]) ->
_lhsIinhNoGroup
{-# INLINE rule198 #-}
rule198 = \ ((_lhsInewAtts) :: Attributes ) ->
_lhsInewAtts
{-# INLINE rule199 #-}
rule199 = \ _newProd ->
_newProd
{-# INLINE rule200 #-}
rule200 = \ ((_lhsIo_noGroup) :: [String]) ->
_lhsIo_noGroup
{-# INLINE rule201 #-}
rule201 = \ ((_lhsIppNt) :: PP_Doc) ->
_lhsIppNt
{-# INLINE rule202 #-}
rule202 = \ ((_lhsIsynNoGroup) :: [String]) ->
_lhsIsynNoGroup
data Inh_Productions = Inh_Productions { Inh_Productions -> Maybe String
ext_Inh_Productions :: (Maybe String), Inh_Productions -> Attributes
inh_Inh_Productions :: ( Attributes ), Inh_Productions -> Map Identifier Attributes
inhMap_Inh_Productions :: (Map Identifier Attributes), Inh_Productions -> [String]
inhNoGroup_Inh_Productions :: ([String]), Inh_Productions -> Attributes
newAtts_Inh_Productions :: ( Attributes ), Inh_Productions -> Bool
newNT_Inh_Productions :: (Bool), Inh_Productions -> Map Identifier FieldMap
newProds_Inh_Productions :: ( Map.Map ConstructorIdent FieldMap ), Inh_Productions -> [String]
o_noGroup_Inh_Productions :: ([String]), Inh_Productions -> Bool
o_rename_Inh_Productions :: (Bool), Inh_Productions -> PP_Doc
ppNt_Inh_Productions :: (PP_Doc), Inh_Productions -> Attributes
syn_Inh_Productions :: ( Attributes ), Inh_Productions -> Map Identifier Attributes
synMap_Inh_Productions :: (Map Identifier Attributes), Inh_Productions -> [String]
synNoGroup_Inh_Productions :: ([String]) }
data Syn_Productions = Syn_Productions { Syn_Productions -> Bool
hasMoreProds_Syn_Productions :: ( Bool ), Syn_Productions -> PP_Doc
ppA_Syn_Productions :: (PP_Doc), Syn_Productions -> PP_Doc
ppCata_Syn_Productions :: (PP_Doc), Syn_Productions -> [PP_Doc]
ppDL_Syn_Productions :: ([PP_Doc]), Syn_Productions -> PP_Doc
ppL_Syn_Productions :: (PP_Doc), Syn_Productions -> [PP_Doc]
ppLI_Syn_Productions :: ([PP_Doc]), Syn_Productions -> PP_Doc
ppR_Syn_Productions :: (PP_Doc), Syn_Productions -> [PP_Doc]
ppRA_Syn_Productions :: ([PP_Doc]), Syn_Productions -> PP_Doc
ppSF_Syn_Productions :: (PP_Doc), Syn_Productions -> PP_Doc
ppSPF_Syn_Productions :: (PP_Doc), Syn_Productions -> Attributes
prdInh_Syn_Productions :: (Attributes) }
{-# INLINABLE wrap_Productions #-}
wrap_Productions :: T_Productions -> Inh_Productions -> (Syn_Productions )
wrap_Productions :: T_Productions -> Inh_Productions -> Syn_Productions
wrap_Productions (T_Productions Identity T_Productions_s38
act) (Inh_Productions Maybe String
_lhsIext Attributes
_lhsIinh Map Identifier Attributes
_lhsIinhMap [String]
_lhsIinhNoGroup Attributes
_lhsInewAtts Bool
_lhsInewNT Map Identifier FieldMap
_lhsInewProds [String]
_lhsIo_noGroup Bool
_lhsIo_rename PP_Doc
_lhsIppNt Attributes
_lhsIsyn Map Identifier Attributes
_lhsIsynMap [String]
_lhsIsynNoGroup) =
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
do T_Productions_s38
sem <- Identity T_Productions_s38
act
let arg37 :: T_Productions_vIn37
arg37 = Maybe String
-> Attributes
-> Map Identifier Attributes
-> [String]
-> Attributes
-> Bool
-> Map Identifier FieldMap
-> [String]
-> Bool
-> PP_Doc
-> Attributes
-> Map Identifier Attributes
-> [String]
-> T_Productions_vIn37
T_Productions_vIn37 Maybe String
_lhsIext Attributes
_lhsIinh Map Identifier Attributes
_lhsIinhMap [String]
_lhsIinhNoGroup Attributes
_lhsInewAtts Bool
_lhsInewNT Map Identifier FieldMap
_lhsInewProds [String]
_lhsIo_noGroup Bool
_lhsIo_rename PP_Doc
_lhsIppNt Attributes
_lhsIsyn Map Identifier Attributes
_lhsIsynMap [String]
_lhsIsynNoGroup
(T_Productions_vOut37 Bool
_lhsOhasMoreProds PP_Doc
_lhsOppA PP_Doc
_lhsOppCata [PP_Doc]
_lhsOppDL PP_Doc
_lhsOppL [PP_Doc]
_lhsOppLI PP_Doc
_lhsOppR [PP_Doc]
_lhsOppRA PP_Doc
_lhsOppSF PP_Doc
_lhsOppSPF Attributes
_lhsOprdInh) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_Productions_s38 -> T_Productions_v37
inv_Productions_s38 T_Productions_s38
sem T_Productions_vIn37
arg37)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
-> PP_Doc
-> PP_Doc
-> [PP_Doc]
-> PP_Doc
-> [PP_Doc]
-> PP_Doc
-> [PP_Doc]
-> PP_Doc
-> PP_Doc
-> Attributes
-> Syn_Productions
Syn_Productions Bool
_lhsOhasMoreProds PP_Doc
_lhsOppA PP_Doc
_lhsOppCata [PP_Doc]
_lhsOppDL PP_Doc
_lhsOppL [PP_Doc]
_lhsOppLI PP_Doc
_lhsOppR [PP_Doc]
_lhsOppRA PP_Doc
_lhsOppSF PP_Doc
_lhsOppSPF Attributes
_lhsOprdInh)
)
{-# NOINLINE sem_Productions #-}
sem_Productions :: Productions -> T_Productions
sem_Productions :: Productions -> T_Productions
sem_Productions Productions
list = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
Prelude.foldr T_Production -> T_Productions -> T_Productions
sem_Productions_Cons T_Productions
sem_Productions_Nil (forall a b. (a -> b) -> [a] -> [b]
Prelude.map Production -> T_Production
sem_Production Productions
list)
newtype T_Productions = T_Productions {
T_Productions -> Identity T_Productions_s38
attach_T_Productions :: Identity (T_Productions_s38 )
}
newtype T_Productions_s38 = C_Productions_s38 {
T_Productions_s38 -> T_Productions_v37
inv_Productions_s38 :: (T_Productions_v37 )
}
data T_Productions_s39 = C_Productions_s39
type T_Productions_v37 = (T_Productions_vIn37 ) -> (T_Productions_vOut37 )
data T_Productions_vIn37 = T_Productions_vIn37 (Maybe String) ( Attributes ) (Map Identifier Attributes) ([String]) ( Attributes ) (Bool) ( Map.Map ConstructorIdent FieldMap ) ([String]) (Bool) (PP_Doc) ( Attributes ) (Map Identifier Attributes) ([String])
data T_Productions_vOut37 = T_Productions_vOut37 ( Bool ) (PP_Doc) (PP_Doc) ([PP_Doc]) (PP_Doc) ([PP_Doc]) (PP_Doc) ([PP_Doc]) (PP_Doc) (PP_Doc) (Attributes)
{-# NOINLINE sem_Productions_Cons #-}
sem_Productions_Cons :: T_Production -> T_Productions -> T_Productions
sem_Productions_Cons :: T_Production -> T_Productions -> T_Productions
sem_Productions_Cons T_Production
arg_hd_ T_Productions
arg_tl_ = Identity T_Productions_s38 -> T_Productions
T_Productions (forall (m :: * -> *) a. Monad m => a -> m a
return T_Productions_s38
st38) where
{-# NOINLINE st38 #-}
st38 :: T_Productions_s38
st38 = let
v37 :: T_Productions_v37
v37 :: T_Productions_v37
v37 = \ (T_Productions_vIn37 Maybe String
_lhsIext Attributes
_lhsIinh Map Identifier Attributes
_lhsIinhMap [String]
_lhsIinhNoGroup Attributes
_lhsInewAtts Bool
_lhsInewNT Map Identifier FieldMap
_lhsInewProds [String]
_lhsIo_noGroup Bool
_lhsIo_rename PP_Doc
_lhsIppNt Attributes
_lhsIsyn Map Identifier Attributes
_lhsIsynMap [String]
_lhsIsynNoGroup) -> ( let
_hdX35 :: T_Production_s35
_hdX35 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Production -> Identity T_Production_s35
attach_T_Production (T_Production
arg_hd_))
_tlX38 :: T_Productions_s38
_tlX38 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Productions -> Identity T_Productions_s38
attach_T_Productions (T_Productions
arg_tl_))
(T_Production_vOut34 Bool
_hdIhasMoreProds PP_Doc
_hdIppA PP_Doc
_hdIppCata PP_Doc
_hdIppD [PP_Doc]
_hdIppDI PP_Doc
_hdIppL [PP_Doc]
_hdIppLI PP_Doc
_hdIppR [PP_Doc]
_hdIppRA PP_Doc
_hdIppSF PP_Doc
_hdIppSPF Attributes
_hdIprdInh) = T_Production_s35 -> T_Production_v34
inv_Production_s35 T_Production_s35
_hdX35 (Maybe String
-> Attributes
-> Map Identifier Attributes
-> [String]
-> Attributes
-> Bool
-> Map Identifier FieldMap
-> [String]
-> Bool
-> PP_Doc
-> Attributes
-> Map Identifier Attributes
-> [String]
-> T_Production_vIn34
T_Production_vIn34 Maybe String
_hdOext Attributes
_hdOinh Map Identifier Attributes
_hdOinhMap [String]
_hdOinhNoGroup Attributes
_hdOnewAtts Bool
_hdOnewNT Map Identifier FieldMap
_hdOnewProds [String]
_hdOo_noGroup Bool
_hdOo_rename PP_Doc
_hdOppNt Attributes
_hdOsyn Map Identifier Attributes
_hdOsynMap [String]
_hdOsynNoGroup)
(T_Productions_vOut37 Bool
_tlIhasMoreProds PP_Doc
_tlIppA PP_Doc
_tlIppCata [PP_Doc]
_tlIppDL PP_Doc
_tlIppL [PP_Doc]
_tlIppLI PP_Doc
_tlIppR [PP_Doc]
_tlIppRA PP_Doc
_tlIppSF PP_Doc
_tlIppSPF Attributes
_tlIprdInh) = T_Productions_s38 -> T_Productions_v37
inv_Productions_s38 T_Productions_s38
_tlX38 (Maybe String
-> Attributes
-> Map Identifier Attributes
-> [String]
-> Attributes
-> Bool
-> Map Identifier FieldMap
-> [String]
-> Bool
-> PP_Doc
-> Attributes
-> Map Identifier Attributes
-> [String]
-> T_Productions_vIn37
T_Productions_vIn37 Maybe String
_tlOext Attributes
_tlOinh Map Identifier Attributes
_tlOinhMap [String]
_tlOinhNoGroup Attributes
_tlOnewAtts Bool
_tlOnewNT Map Identifier FieldMap
_tlOnewProds [String]
_tlOo_noGroup Bool
_tlOo_rename PP_Doc
_tlOppNt Attributes
_tlOsyn Map Identifier Attributes
_tlOsynMap [String]
_tlOsynNoGroup)
_hdOinhNoGroup :: [String]
_hdOinhNoGroup = Attributes -> [String] -> [String]
rule203 Attributes
_hdIprdInh [String]
_lhsIinhNoGroup
_lhsOppDL :: [PP_Doc]
_lhsOppDL :: [PP_Doc]
_lhsOppDL = PP_Doc -> [PP_Doc] -> [PP_Doc]
rule204 PP_Doc
_hdIppD [PP_Doc]
_tlIppDL
_lhsOhasMoreProds :: Bool
_lhsOhasMoreProds :: Bool
_lhsOhasMoreProds = Bool -> Bool -> Bool
rule205 Bool
_hdIhasMoreProds Bool
_tlIhasMoreProds
_lhsOppA :: PP_Doc
_lhsOppA :: PP_Doc
_lhsOppA = PP_Doc -> PP_Doc -> PP_Doc
rule206 PP_Doc
_hdIppA PP_Doc
_tlIppA
_lhsOppCata :: PP_Doc
_lhsOppCata :: PP_Doc
_lhsOppCata = PP_Doc -> PP_Doc -> PP_Doc
rule207 PP_Doc
_hdIppCata PP_Doc
_tlIppCata
_lhsOppL :: PP_Doc
_lhsOppL :: PP_Doc
_lhsOppL = PP_Doc -> PP_Doc -> PP_Doc
rule208 PP_Doc
_hdIppL PP_Doc
_tlIppL
_lhsOppLI :: [PP_Doc]
_lhsOppLI :: [PP_Doc]
_lhsOppLI = [PP_Doc] -> [PP_Doc] -> [PP_Doc]
rule209 [PP_Doc]
_hdIppLI [PP_Doc]
_tlIppLI
_lhsOppR :: PP_Doc
_lhsOppR :: PP_Doc
_lhsOppR = PP_Doc -> PP_Doc -> PP_Doc
rule210 PP_Doc
_hdIppR PP_Doc
_tlIppR
_lhsOppRA :: [PP_Doc]
_lhsOppRA :: [PP_Doc]
_lhsOppRA = [PP_Doc] -> [PP_Doc] -> [PP_Doc]
rule211 [PP_Doc]
_hdIppRA [PP_Doc]
_tlIppRA
_lhsOppSF :: PP_Doc
_lhsOppSF :: PP_Doc
_lhsOppSF = PP_Doc -> PP_Doc -> PP_Doc
rule212 PP_Doc
_hdIppSF PP_Doc
_tlIppSF
_lhsOppSPF :: PP_Doc
_lhsOppSPF :: PP_Doc
_lhsOppSPF = PP_Doc -> PP_Doc -> PP_Doc
rule213 PP_Doc
_hdIppSPF PP_Doc
_tlIppSPF
_lhsOprdInh :: Attributes
_lhsOprdInh :: Attributes
_lhsOprdInh = Attributes -> Attributes -> Attributes
rule214 Attributes
_hdIprdInh Attributes
_tlIprdInh
_hdOext :: Maybe String
_hdOext = Maybe String -> Maybe String
rule215 Maybe String
_lhsIext
_hdOinh :: Attributes
_hdOinh = Attributes -> Attributes
rule216 Attributes
_lhsIinh
_hdOinhMap :: Map Identifier Attributes
_hdOinhMap = Map Identifier Attributes -> Map Identifier Attributes
rule217 Map Identifier Attributes
_lhsIinhMap
_hdOnewAtts :: Attributes
_hdOnewAtts = Attributes -> Attributes
rule218 Attributes
_lhsInewAtts
_hdOnewNT :: Bool
_hdOnewNT = Bool -> Bool
rule219 Bool
_lhsInewNT
_hdOnewProds :: Map Identifier FieldMap
_hdOnewProds = Map Identifier FieldMap -> Map Identifier FieldMap
rule220 Map Identifier FieldMap
_lhsInewProds
_hdOo_noGroup :: [String]
_hdOo_noGroup = [String] -> [String]
rule221 [String]
_lhsIo_noGroup
_hdOo_rename :: Bool
_hdOo_rename = Bool -> Bool
rule222 Bool
_lhsIo_rename
_hdOppNt :: PP_Doc
_hdOppNt = PP_Doc -> PP_Doc
rule223 PP_Doc
_lhsIppNt
_hdOsyn :: Attributes
_hdOsyn = Attributes -> Attributes
rule224 Attributes
_lhsIsyn
_hdOsynMap :: Map Identifier Attributes
_hdOsynMap = Map Identifier Attributes -> Map Identifier Attributes
rule225 Map Identifier Attributes
_lhsIsynMap
_hdOsynNoGroup :: [String]
_hdOsynNoGroup = [String] -> [String]
rule226 [String]
_lhsIsynNoGroup
_tlOext :: Maybe String
_tlOext = Maybe String -> Maybe String
rule227 Maybe String
_lhsIext
_tlOinh :: Attributes
_tlOinh = Attributes -> Attributes
rule228 Attributes
_lhsIinh
_tlOinhMap :: Map Identifier Attributes
_tlOinhMap = Map Identifier Attributes -> Map Identifier Attributes
rule229 Map Identifier Attributes
_lhsIinhMap
_tlOinhNoGroup :: [String]
_tlOinhNoGroup = [String] -> [String]
rule230 [String]
_lhsIinhNoGroup
_tlOnewAtts :: Attributes
_tlOnewAtts = Attributes -> Attributes
rule231 Attributes
_lhsInewAtts
_tlOnewNT :: Bool
_tlOnewNT = Bool -> Bool
rule232 Bool
_lhsInewNT
_tlOnewProds :: Map Identifier FieldMap
_tlOnewProds = Map Identifier FieldMap -> Map Identifier FieldMap
rule233 Map Identifier FieldMap
_lhsInewProds
_tlOo_noGroup :: [String]
_tlOo_noGroup = [String] -> [String]
rule234 [String]
_lhsIo_noGroup
_tlOo_rename :: Bool
_tlOo_rename = Bool -> Bool
rule235 Bool
_lhsIo_rename
_tlOppNt :: PP_Doc
_tlOppNt = PP_Doc -> PP_Doc
rule236 PP_Doc
_lhsIppNt
_tlOsyn :: Attributes
_tlOsyn = Attributes -> Attributes
rule237 Attributes
_lhsIsyn
_tlOsynMap :: Map Identifier Attributes
_tlOsynMap = Map Identifier Attributes -> Map Identifier Attributes
rule238 Map Identifier Attributes
_lhsIsynMap
_tlOsynNoGroup :: [String]
_tlOsynNoGroup = [String] -> [String]
rule239 [String]
_lhsIsynNoGroup
__result_ :: T_Productions_vOut37
__result_ = Bool
-> PP_Doc
-> PP_Doc
-> [PP_Doc]
-> PP_Doc
-> [PP_Doc]
-> PP_Doc
-> [PP_Doc]
-> PP_Doc
-> PP_Doc
-> Attributes
-> T_Productions_vOut37
T_Productions_vOut37 Bool
_lhsOhasMoreProds PP_Doc
_lhsOppA PP_Doc
_lhsOppCata [PP_Doc]
_lhsOppDL PP_Doc
_lhsOppL [PP_Doc]
_lhsOppLI PP_Doc
_lhsOppR [PP_Doc]
_lhsOppRA PP_Doc
_lhsOppSF PP_Doc
_lhsOppSPF Attributes
_lhsOprdInh
in T_Productions_vOut37
__result_ )
in T_Productions_v37 -> T_Productions_s38
C_Productions_s38 T_Productions_v37
v37
{-# INLINE rule203 #-}
{-# LINE 62 "src-ag/AG2AspectAG.ag" #-}
rule203 = \ ((_hdIprdInh) :: Attributes) ((_lhsIinhNoGroup) :: [String]) ->
{-# LINE 62 "src-ag/AG2AspectAG.ag" #-}
filter (flip Map.member _hdIprdInh . identifier) _lhsIinhNoGroup
{-# LINE 2436 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule204 #-}
{-# LINE 234 "src-ag/AG2AspectAG.ag" #-}
rule204 = \ ((_hdIppD) :: PP_Doc) ((_tlIppDL) :: [PP_Doc]) ->
{-# LINE 234 "src-ag/AG2AspectAG.ag" #-}
_hdIppD : _tlIppDL
{-# LINE 2442 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule205 #-}
rule205 = \ ((_hdIhasMoreProds) :: Bool ) ((_tlIhasMoreProds) :: Bool ) ->
_hdIhasMoreProds || _tlIhasMoreProds
{-# INLINE rule206 #-}
rule206 = \ ((_hdIppA) :: PP_Doc) ((_tlIppA) :: PP_Doc) ->
_hdIppA >-< _tlIppA
{-# INLINE rule207 #-}
rule207 = \ ((_hdIppCata) :: PP_Doc) ((_tlIppCata) :: PP_Doc) ->
_hdIppCata >-< _tlIppCata
{-# INLINE rule208 #-}
rule208 = \ ((_hdIppL) :: PP_Doc) ((_tlIppL) :: PP_Doc) ->
_hdIppL >-< _tlIppL
{-# INLINE rule209 #-}
rule209 = \ ((_hdIppLI) :: [PP_Doc]) ((_tlIppLI) :: [PP_Doc]) ->
_hdIppLI ++ _tlIppLI
{-# INLINE rule210 #-}
rule210 = \ ((_hdIppR) :: PP_Doc) ((_tlIppR) :: PP_Doc) ->
_hdIppR >-< _tlIppR
{-# INLINE rule211 #-}
rule211 = \ ((_hdIppRA) :: [PP_Doc]) ((_tlIppRA) :: [PP_Doc]) ->
_hdIppRA ++ _tlIppRA
{-# INLINE rule212 #-}
rule212 = \ ((_hdIppSF) :: PP_Doc) ((_tlIppSF) :: PP_Doc) ->
_hdIppSF >-< _tlIppSF
{-# INLINE rule213 #-}
rule213 = \ ((_hdIppSPF) :: PP_Doc) ((_tlIppSPF) :: PP_Doc) ->
_hdIppSPF >-< _tlIppSPF
{-# INLINE rule214 #-}
rule214 = \ ((_hdIprdInh) :: Attributes) ((_tlIprdInh) :: Attributes) ->
_hdIprdInh `Map.union` _tlIprdInh
{-# INLINE rule215 #-}
rule215 = \ ((_lhsIext) :: Maybe String) ->
_lhsIext
{-# INLINE rule216 #-}
rule216 = \ ((_lhsIinh) :: Attributes ) ->
_lhsIinh
{-# INLINE rule217 #-}
rule217 = \ ((_lhsIinhMap) :: Map Identifier Attributes) ->
_lhsIinhMap
{-# INLINE rule218 #-}
rule218 = \ ((_lhsInewAtts) :: Attributes ) ->
_lhsInewAtts
{-# INLINE rule219 #-}
rule219 = \ ((_lhsInewNT) :: Bool) ->
_lhsInewNT
{-# INLINE rule220 #-}
rule220 = \ ((_lhsInewProds) :: Map.Map ConstructorIdent FieldMap ) ->
_lhsInewProds
{-# INLINE rule221 #-}
rule221 = \ ((_lhsIo_noGroup) :: [String]) ->
_lhsIo_noGroup
{-# INLINE rule222 #-}
rule222 = \ ((_lhsIo_rename) :: Bool) ->
_lhsIo_rename
{-# INLINE rule223 #-}
rule223 = \ ((_lhsIppNt) :: PP_Doc) ->
_lhsIppNt
{-# INLINE rule224 #-}
rule224 = \ ((_lhsIsyn) :: Attributes ) ->
_lhsIsyn
{-# INLINE rule225 #-}
rule225 = \ ((_lhsIsynMap) :: Map Identifier Attributes) ->
_lhsIsynMap
{-# INLINE rule226 #-}
rule226 = \ ((_lhsIsynNoGroup) :: [String]) ->
_lhsIsynNoGroup
{-# INLINE rule227 #-}
rule227 = \ ((_lhsIext) :: Maybe String) ->
_lhsIext
{-# INLINE rule228 #-}
rule228 = \ ((_lhsIinh) :: Attributes ) ->
_lhsIinh
{-# INLINE rule229 #-}
rule229 = \ ((_lhsIinhMap) :: Map Identifier Attributes) ->
_lhsIinhMap
{-# INLINE rule230 #-}
rule230 = \ ((_lhsIinhNoGroup) :: [String]) ->
_lhsIinhNoGroup
{-# INLINE rule231 #-}
rule231 = \ ((_lhsInewAtts) :: Attributes ) ->
_lhsInewAtts
{-# INLINE rule232 #-}
rule232 = \ ((_lhsInewNT) :: Bool) ->
_lhsInewNT
{-# INLINE rule233 #-}
rule233 = \ ((_lhsInewProds) :: Map.Map ConstructorIdent FieldMap ) ->
_lhsInewProds
{-# INLINE rule234 #-}
rule234 = \ ((_lhsIo_noGroup) :: [String]) ->
_lhsIo_noGroup
{-# INLINE rule235 #-}
rule235 = \ ((_lhsIo_rename) :: Bool) ->
_lhsIo_rename
{-# INLINE rule236 #-}
rule236 = \ ((_lhsIppNt) :: PP_Doc) ->
_lhsIppNt
{-# INLINE rule237 #-}
rule237 = \ ((_lhsIsyn) :: Attributes ) ->
_lhsIsyn
{-# INLINE rule238 #-}
rule238 = \ ((_lhsIsynMap) :: Map Identifier Attributes) ->
_lhsIsynMap
{-# INLINE rule239 #-}
rule239 = \ ((_lhsIsynNoGroup) :: [String]) ->
_lhsIsynNoGroup
{-# NOINLINE sem_Productions_Nil #-}
sem_Productions_Nil :: T_Productions
sem_Productions_Nil :: T_Productions
sem_Productions_Nil = Identity T_Productions_s38 -> T_Productions
T_Productions (forall (m :: * -> *) a. Monad m => a -> m a
return T_Productions_s38
st38) where
{-# NOINLINE st38 #-}
st38 :: T_Productions_s38
st38 = let
v37 :: T_Productions_v37
v37 :: T_Productions_v37
v37 = \ (T_Productions_vIn37 Maybe String
_lhsIext Attributes
_lhsIinh Map Identifier Attributes
_lhsIinhMap [String]
_lhsIinhNoGroup Attributes
_lhsInewAtts Bool
_lhsInewNT Map Identifier FieldMap
_lhsInewProds [String]
_lhsIo_noGroup Bool
_lhsIo_rename PP_Doc
_lhsIppNt Attributes
_lhsIsyn Map Identifier Attributes
_lhsIsynMap [String]
_lhsIsynNoGroup) -> ( let
_lhsOppDL :: [PP_Doc]
_lhsOppDL :: [PP_Doc]
_lhsOppDL = forall {a}. () -> [a]
rule240 ()
_lhsOhasMoreProds :: Bool
_lhsOhasMoreProds :: Bool
_lhsOhasMoreProds = () -> Bool
rule241 ()
_lhsOppA :: PP_Doc
_lhsOppA :: PP_Doc
_lhsOppA = () -> PP_Doc
rule242 ()
_lhsOppCata :: PP_Doc
_lhsOppCata :: PP_Doc
_lhsOppCata = () -> PP_Doc
rule243 ()
_lhsOppL :: PP_Doc
_lhsOppL :: PP_Doc
_lhsOppL = () -> PP_Doc
rule244 ()
_lhsOppLI :: [PP_Doc]
_lhsOppLI :: [PP_Doc]
_lhsOppLI = forall {a}. () -> [a]
rule245 ()
_lhsOppR :: PP_Doc
_lhsOppR :: PP_Doc
_lhsOppR = () -> PP_Doc
rule246 ()
_lhsOppRA :: [PP_Doc]
_lhsOppRA :: [PP_Doc]
_lhsOppRA = forall {a}. () -> [a]
rule247 ()
_lhsOppSF :: PP_Doc
_lhsOppSF :: PP_Doc
_lhsOppSF = () -> PP_Doc
rule248 ()
_lhsOppSPF :: PP_Doc
_lhsOppSPF :: PP_Doc
_lhsOppSPF = () -> PP_Doc
rule249 ()
_lhsOprdInh :: Attributes
_lhsOprdInh :: Attributes
_lhsOprdInh = forall {k} {a}. () -> Map k a
rule250 ()
__result_ :: T_Productions_vOut37
__result_ = Bool
-> PP_Doc
-> PP_Doc
-> [PP_Doc]
-> PP_Doc
-> [PP_Doc]
-> PP_Doc
-> [PP_Doc]
-> PP_Doc
-> PP_Doc
-> Attributes
-> T_Productions_vOut37
T_Productions_vOut37 Bool
_lhsOhasMoreProds PP_Doc
_lhsOppA PP_Doc
_lhsOppCata [PP_Doc]
_lhsOppDL PP_Doc
_lhsOppL [PP_Doc]
_lhsOppLI PP_Doc
_lhsOppR [PP_Doc]
_lhsOppRA PP_Doc
_lhsOppSF PP_Doc
_lhsOppSPF Attributes
_lhsOprdInh
in T_Productions_vOut37
__result_ )
in T_Productions_v37 -> T_Productions_s38
C_Productions_s38 T_Productions_v37
v37
{-# INLINE rule240 #-}
{-# LINE 235 "src-ag/AG2AspectAG.ag" #-}
rule240 = \ (_ :: ()) ->
{-# LINE 235 "src-ag/AG2AspectAG.ag" #-}
[]
{-# LINE 2585 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule241 #-}
rule241 = \ (_ :: ()) ->
False
{-# INLINE rule242 #-}
rule242 = \ (_ :: ()) ->
empty
{-# INLINE rule243 #-}
rule243 = \ (_ :: ()) ->
empty
{-# INLINE rule244 #-}
rule244 = \ (_ :: ()) ->
empty
{-# INLINE rule245 #-}
rule245 = \ (_ :: ()) ->
[]
{-# INLINE rule246 #-}
rule246 = \ (_ :: ()) ->
empty
{-# INLINE rule247 #-}
rule247 = \ (_ :: ()) ->
[]
{-# INLINE rule248 #-}
rule248 = \ (_ :: ()) ->
empty
{-# INLINE rule249 #-}
rule249 = \ (_ :: ()) ->
empty
{-# INLINE rule250 #-}
rule250 = \ (_ :: ()) ->
Map.empty
data Inh_Rule = Inh_Rule { Inh_Rule -> Maybe String
ext_Inh_Rule :: (Maybe String), Inh_Rule -> [String]
inhNoGroup_Inh_Rule :: ([String]), Inh_Rule -> Attributes
newAtts_Inh_Rule :: ( Attributes ), Inh_Rule -> Bool
newProd_Inh_Rule :: (Bool), Inh_Rule -> [String]
o_noGroup_Inh_Rule :: ([String]), Inh_Rule -> PP_Doc
ppNt_Inh_Rule :: (PP_Doc), Inh_Rule -> PP_Doc
ppProd_Inh_Rule :: (PP_Doc), Inh_Rule -> [String]
synNoGroup_Inh_Rule :: ([String]) }
data Syn_Rule = Syn_Rule { Syn_Rule -> [Identifier]
locals_Syn_Rule :: ([Identifier]), Syn_Rule -> [PPRule]
ppRL_Syn_Rule :: ([ PPRule ]) }
{-# INLINABLE wrap_Rule #-}
wrap_Rule :: T_Rule -> Inh_Rule -> (Syn_Rule )
wrap_Rule :: T_Rule -> Inh_Rule -> Syn_Rule
wrap_Rule (T_Rule Identity T_Rule_s41
act) (Inh_Rule Maybe String
_lhsIext [String]
_lhsIinhNoGroup Attributes
_lhsInewAtts Bool
_lhsInewProd [String]
_lhsIo_noGroup PP_Doc
_lhsIppNt PP_Doc
_lhsIppProd [String]
_lhsIsynNoGroup) =
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
do T_Rule_s41
sem <- Identity T_Rule_s41
act
let arg40 :: T_Rule_vIn40
arg40 = Maybe String
-> [String]
-> Attributes
-> Bool
-> [String]
-> PP_Doc
-> PP_Doc
-> [String]
-> T_Rule_vIn40
T_Rule_vIn40 Maybe String
_lhsIext [String]
_lhsIinhNoGroup Attributes
_lhsInewAtts Bool
_lhsInewProd [String]
_lhsIo_noGroup PP_Doc
_lhsIppNt PP_Doc
_lhsIppProd [String]
_lhsIsynNoGroup
(T_Rule_vOut40 [Identifier]
_lhsOlocals [PPRule]
_lhsOppRL) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_Rule_s41 -> T_Rule_v40
inv_Rule_s41 T_Rule_s41
sem T_Rule_vIn40
arg40)
forall (m :: * -> *) a. Monad m => a -> m a
return ([Identifier] -> [PPRule] -> Syn_Rule
Syn_Rule [Identifier]
_lhsOlocals [PPRule]
_lhsOppRL)
)
{-# INLINE sem_Rule #-}
sem_Rule :: Rule -> T_Rule
sem_Rule :: Rule -> T_Rule
sem_Rule ( Rule Maybe Identifier
mbName_ Pattern
pattern_ Expression
rhs_ Bool
owrt_ String
origin_ Bool
explicit_ Bool
pure_ Bool
identity_ Maybe Error
mbError_ Bool
eager_ ) = Maybe Identifier
-> T_Pattern
-> T_Expression
-> Bool
-> String
-> Bool
-> Bool
-> Bool
-> Maybe Error
-> Bool
-> T_Rule
sem_Rule_Rule Maybe Identifier
mbName_ ( Pattern -> T_Pattern
sem_Pattern Pattern
pattern_ ) ( Expression -> T_Expression
sem_Expression Expression
rhs_ ) Bool
owrt_ String
origin_ Bool
explicit_ Bool
pure_ Bool
identity_ Maybe Error
mbError_ Bool
eager_
newtype T_Rule = T_Rule {
T_Rule -> Identity T_Rule_s41
attach_T_Rule :: Identity (T_Rule_s41 )
}
newtype T_Rule_s41 = C_Rule_s41 {
T_Rule_s41 -> T_Rule_v40
inv_Rule_s41 :: (T_Rule_v40 )
}
data T_Rule_s42 = C_Rule_s42
type T_Rule_v40 = (T_Rule_vIn40 ) -> (T_Rule_vOut40 )
data T_Rule_vIn40 = T_Rule_vIn40 (Maybe String) ([String]) ( Attributes ) (Bool) ([String]) (PP_Doc) (PP_Doc) ([String])
data T_Rule_vOut40 = T_Rule_vOut40 ([Identifier]) ([ PPRule ])
{-# NOINLINE sem_Rule_Rule #-}
sem_Rule_Rule :: (Maybe Identifier) -> T_Pattern -> T_Expression -> (Bool) -> (String) -> (Bool) -> (Bool) -> (Bool) -> (Maybe Error) -> (Bool) -> T_Rule
sem_Rule_Rule :: Maybe Identifier
-> T_Pattern
-> T_Expression
-> Bool
-> String
-> Bool
-> Bool
-> Bool
-> Maybe Error
-> Bool
-> T_Rule
sem_Rule_Rule Maybe Identifier
_ T_Pattern
arg_pattern_ T_Expression
arg_rhs_ Bool
arg_owrt_ String
_ Bool
arg_explicit_ Bool
_ Bool
_ Maybe Error
_ Bool
_ = Identity T_Rule_s41 -> T_Rule
T_Rule (forall (m :: * -> *) a. Monad m => a -> m a
return T_Rule_s41
st41) where
{-# NOINLINE st41 #-}
st41 :: T_Rule_s41
st41 = let
v40 :: T_Rule_v40
v40 :: T_Rule_v40
v40 = \ (T_Rule_vIn40 Maybe String
_lhsIext [String]
_lhsIinhNoGroup Attributes
_lhsInewAtts Bool
_lhsInewProd [String]
_lhsIo_noGroup PP_Doc
_lhsIppNt PP_Doc
_lhsIppProd [String]
_lhsIsynNoGroup) -> ( let
_patternX29 :: T_Pattern_s29
_patternX29 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Pattern -> Identity T_Pattern_s29
attach_T_Pattern (T_Pattern
arg_pattern_))
_rhsX8 :: T_Expression_s8
_rhsX8 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Expression -> Identity T_Expression_s8
attach_T_Expression (T_Expression
arg_rhs_))
(T_Pattern_vOut28 Pattern
_patternIcopy (Identifier, Identifier)
_patternIinfo) = T_Pattern_s29 -> T_Pattern_v28
inv_Pattern_s29 T_Pattern_s29
_patternX29 (T_Pattern_vIn28
T_Pattern_vIn28 )
(T_Expression_vOut7 [String] -> Identifier -> FieldMap -> [Identifier] -> PP_Doc
_rhsIppRE) = T_Expression_s8 -> T_Expression_v7
inv_Expression_s8 T_Expression_s8
_rhsX8 (PP_Doc -> PP_Doc -> T_Expression_vIn7
T_Expression_vIn7 PP_Doc
_rhsOppNt PP_Doc
_rhsOppProd)
_lhsOlocals :: [Identifier]
_lhsOlocals :: [Identifier]
_lhsOlocals = (Identifier, Identifier) -> [Identifier]
rule251 (Identifier, Identifier)
_patternIinfo
_lhsOppRL :: [ PPRule ]
_lhsOppRL :: [PPRule]
_lhsOppRL = Attributes
-> Bool
-> [String]
-> PP_Doc
-> (Identifier, Identifier)
-> ([String] -> Identifier -> FieldMap -> [Identifier] -> PP_Doc)
-> Bool
-> Bool
-> [PPRule]
rule252 Attributes
_lhsInewAtts Bool
_lhsInewProd [String]
_lhsIo_noGroup PP_Doc
_lhsIppNt (Identifier, Identifier)
_patternIinfo [String] -> Identifier -> FieldMap -> [Identifier] -> PP_Doc
_rhsIppRE Bool
arg_explicit_ Bool
arg_owrt_
_rhsOppNt :: PP_Doc
_rhsOppNt = PP_Doc -> PP_Doc
rule253 PP_Doc
_lhsIppNt
_rhsOppProd :: PP_Doc
_rhsOppProd = PP_Doc -> PP_Doc
rule254 PP_Doc
_lhsIppProd
__result_ :: T_Rule_vOut40
__result_ = [Identifier] -> [PPRule] -> T_Rule_vOut40
T_Rule_vOut40 [Identifier]
_lhsOlocals [PPRule]
_lhsOppRL
in T_Rule_vOut40
__result_ )
in T_Rule_v40 -> T_Rule_s41
C_Rule_s41 T_Rule_v40
v40
{-# INLINE rule251 #-}
{-# LINE 375 "src-ag/AG2AspectAG.ag" #-}
rule251 = \ ((_patternIinfo) :: (Identifier, Identifier)) ->
{-# LINE 375 "src-ag/AG2AspectAG.ag" #-}
if (show (fst _patternIinfo) == "loc")
then [ snd _patternIinfo ]
else [ ]
{-# LINE 2674 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule252 #-}
{-# LINE 472 "src-ag/AG2AspectAG.ag" #-}
rule252 = \ ((_lhsInewAtts) :: Attributes ) ((_lhsInewProd) :: Bool) ((_lhsIo_noGroup) :: [String]) ((_lhsIppNt) :: PP_Doc) ((_patternIinfo) :: (Identifier, Identifier)) ((_rhsIppRE) :: [String] -> Identifier -> [(Identifier,Type)] -> [Identifier] -> PP_Doc) explicit_ owrt_ ->
{-# LINE 472 "src-ag/AG2AspectAG.ag" #-}
if (not explicit_ && not _lhsInewProd && not (Map.member (snd _patternIinfo) _lhsInewAtts) )
then []
else [ ppRule _patternIinfo owrt_ (defRule _lhsIppNt _patternIinfo _lhsIo_noGroup _rhsIppRE) ]
{-# LINE 2682 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule253 #-}
rule253 = \ ((_lhsIppNt) :: PP_Doc) ->
_lhsIppNt
{-# INLINE rule254 #-}
rule254 = \ ((_lhsIppProd) :: PP_Doc) ->
_lhsIppProd
data Inh_Rules = Inh_Rules { Inh_Rules -> Maybe String
ext_Inh_Rules :: (Maybe String), Inh_Rules -> [String]
inhNoGroup_Inh_Rules :: ([String]), Inh_Rules -> Attributes
newAtts_Inh_Rules :: ( Attributes ), Inh_Rules -> Bool
newProd_Inh_Rules :: (Bool), Inh_Rules -> [String]
o_noGroup_Inh_Rules :: ([String]), Inh_Rules -> PP_Doc
ppNt_Inh_Rules :: (PP_Doc), Inh_Rules -> PP_Doc
ppProd_Inh_Rules :: (PP_Doc), Inh_Rules -> [String]
synNoGroup_Inh_Rules :: ([String]) }
data Syn_Rules = Syn_Rules { Syn_Rules -> [Identifier]
locals_Syn_Rules :: ([Identifier]), Syn_Rules -> [PPRule]
ppRL_Syn_Rules :: ([ PPRule ]) }
{-# INLINABLE wrap_Rules #-}
wrap_Rules :: T_Rules -> Inh_Rules -> (Syn_Rules )
wrap_Rules :: T_Rules -> Inh_Rules -> Syn_Rules
wrap_Rules (T_Rules Identity T_Rules_s44
act) (Inh_Rules Maybe String
_lhsIext [String]
_lhsIinhNoGroup Attributes
_lhsInewAtts Bool
_lhsInewProd [String]
_lhsIo_noGroup PP_Doc
_lhsIppNt PP_Doc
_lhsIppProd [String]
_lhsIsynNoGroup) =
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
do T_Rules_s44
sem <- Identity T_Rules_s44
act
let arg43 :: T_Rules_vIn43
arg43 = Maybe String
-> [String]
-> Attributes
-> Bool
-> [String]
-> PP_Doc
-> PP_Doc
-> [String]
-> T_Rules_vIn43
T_Rules_vIn43 Maybe String
_lhsIext [String]
_lhsIinhNoGroup Attributes
_lhsInewAtts Bool
_lhsInewProd [String]
_lhsIo_noGroup PP_Doc
_lhsIppNt PP_Doc
_lhsIppProd [String]
_lhsIsynNoGroup
(T_Rules_vOut43 [Identifier]
_lhsOlocals [PPRule]
_lhsOppRL) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_Rules_s44 -> T_Rules_v43
inv_Rules_s44 T_Rules_s44
sem T_Rules_vIn43
arg43)
forall (m :: * -> *) a. Monad m => a -> m a
return ([Identifier] -> [PPRule] -> Syn_Rules
Syn_Rules [Identifier]
_lhsOlocals [PPRule]
_lhsOppRL)
)
{-# NOINLINE sem_Rules #-}
sem_Rules :: Rules -> T_Rules
sem_Rules :: Rules -> T_Rules
sem_Rules Rules
list = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
Prelude.foldr T_Rule -> T_Rules -> T_Rules
sem_Rules_Cons T_Rules
sem_Rules_Nil (forall a b. (a -> b) -> [a] -> [b]
Prelude.map Rule -> T_Rule
sem_Rule Rules
list)
newtype T_Rules = T_Rules {
T_Rules -> Identity T_Rules_s44
attach_T_Rules :: Identity (T_Rules_s44 )
}
newtype T_Rules_s44 = C_Rules_s44 {
T_Rules_s44 -> T_Rules_v43
inv_Rules_s44 :: (T_Rules_v43 )
}
data T_Rules_s45 = C_Rules_s45
type T_Rules_v43 = (T_Rules_vIn43 ) -> (T_Rules_vOut43 )
data T_Rules_vIn43 = T_Rules_vIn43 (Maybe String) ([String]) ( Attributes ) (Bool) ([String]) (PP_Doc) (PP_Doc) ([String])
data T_Rules_vOut43 = T_Rules_vOut43 ([Identifier]) ([ PPRule ])
{-# NOINLINE sem_Rules_Cons #-}
sem_Rules_Cons :: T_Rule -> T_Rules -> T_Rules
sem_Rules_Cons :: T_Rule -> T_Rules -> T_Rules
sem_Rules_Cons T_Rule
arg_hd_ T_Rules
arg_tl_ = Identity T_Rules_s44 -> T_Rules
T_Rules (forall (m :: * -> *) a. Monad m => a -> m a
return T_Rules_s44
st44) where
{-# NOINLINE st44 #-}
st44 :: T_Rules_s44
st44 = let
v43 :: T_Rules_v43
v43 :: T_Rules_v43
v43 = \ (T_Rules_vIn43 Maybe String
_lhsIext [String]
_lhsIinhNoGroup Attributes
_lhsInewAtts Bool
_lhsInewProd [String]
_lhsIo_noGroup PP_Doc
_lhsIppNt PP_Doc
_lhsIppProd [String]
_lhsIsynNoGroup) -> ( let
_hdX41 :: T_Rule_s41
_hdX41 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Rule -> Identity T_Rule_s41
attach_T_Rule (T_Rule
arg_hd_))
_tlX44 :: T_Rules_s44
_tlX44 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Rules -> Identity T_Rules_s44
attach_T_Rules (T_Rules
arg_tl_))
(T_Rule_vOut40 [Identifier]
_hdIlocals [PPRule]
_hdIppRL) = T_Rule_s41 -> T_Rule_v40
inv_Rule_s41 T_Rule_s41
_hdX41 (Maybe String
-> [String]
-> Attributes
-> Bool
-> [String]
-> PP_Doc
-> PP_Doc
-> [String]
-> T_Rule_vIn40
T_Rule_vIn40 Maybe String
_hdOext [String]
_hdOinhNoGroup Attributes
_hdOnewAtts Bool
_hdOnewProd [String]
_hdOo_noGroup PP_Doc
_hdOppNt PP_Doc
_hdOppProd [String]
_hdOsynNoGroup)
(T_Rules_vOut43 [Identifier]
_tlIlocals [PPRule]
_tlIppRL) = T_Rules_s44 -> T_Rules_v43
inv_Rules_s44 T_Rules_s44
_tlX44 (Maybe String
-> [String]
-> Attributes
-> Bool
-> [String]
-> PP_Doc
-> PP_Doc
-> [String]
-> T_Rules_vIn43
T_Rules_vIn43 Maybe String
_tlOext [String]
_tlOinhNoGroup Attributes
_tlOnewAtts Bool
_tlOnewProd [String]
_tlOo_noGroup PP_Doc
_tlOppNt PP_Doc
_tlOppProd [String]
_tlOsynNoGroup)
_lhsOppRL :: [ PPRule ]
_lhsOppRL :: [PPRule]
_lhsOppRL = [PPRule] -> [PPRule] -> [PPRule]
rule255 [PPRule]
_hdIppRL [PPRule]
_tlIppRL
_lhsOlocals :: [Identifier]
_lhsOlocals :: [Identifier]
_lhsOlocals = [Identifier] -> [Identifier] -> [Identifier]
rule256 [Identifier]
_hdIlocals [Identifier]
_tlIlocals
_hdOext :: Maybe String
_hdOext = Maybe String -> Maybe String
rule257 Maybe String
_lhsIext
_hdOinhNoGroup :: [String]
_hdOinhNoGroup = [String] -> [String]
rule258 [String]
_lhsIinhNoGroup
_hdOnewAtts :: Attributes
_hdOnewAtts = Attributes -> Attributes
rule259 Attributes
_lhsInewAtts
_hdOnewProd :: Bool
_hdOnewProd = Bool -> Bool
rule260 Bool
_lhsInewProd
_hdOo_noGroup :: [String]
_hdOo_noGroup = [String] -> [String]
rule261 [String]
_lhsIo_noGroup
_hdOppNt :: PP_Doc
_hdOppNt = PP_Doc -> PP_Doc
rule262 PP_Doc
_lhsIppNt
_hdOppProd :: PP_Doc
_hdOppProd = PP_Doc -> PP_Doc
rule263 PP_Doc
_lhsIppProd
_hdOsynNoGroup :: [String]
_hdOsynNoGroup = [String] -> [String]
rule264 [String]
_lhsIsynNoGroup
_tlOext :: Maybe String
_tlOext = Maybe String -> Maybe String
rule265 Maybe String
_lhsIext
_tlOinhNoGroup :: [String]
_tlOinhNoGroup = [String] -> [String]
rule266 [String]
_lhsIinhNoGroup
_tlOnewAtts :: Attributes
_tlOnewAtts = Attributes -> Attributes
rule267 Attributes
_lhsInewAtts
_tlOnewProd :: Bool
_tlOnewProd = Bool -> Bool
rule268 Bool
_lhsInewProd
_tlOo_noGroup :: [String]
_tlOo_noGroup = [String] -> [String]
rule269 [String]
_lhsIo_noGroup
_tlOppNt :: PP_Doc
_tlOppNt = PP_Doc -> PP_Doc
rule270 PP_Doc
_lhsIppNt
_tlOppProd :: PP_Doc
_tlOppProd = PP_Doc -> PP_Doc
rule271 PP_Doc
_lhsIppProd
_tlOsynNoGroup :: [String]
_tlOsynNoGroup = [String] -> [String]
rule272 [String]
_lhsIsynNoGroup
__result_ :: T_Rules_vOut43
__result_ = [Identifier] -> [PPRule] -> T_Rules_vOut43
T_Rules_vOut43 [Identifier]
_lhsOlocals [PPRule]
_lhsOppRL
in T_Rules_vOut43
__result_ )
in T_Rules_v43 -> T_Rules_s44
C_Rules_s44 T_Rules_v43
v43
{-# INLINE rule255 #-}
{-# LINE 468 "src-ag/AG2AspectAG.ag" #-}
rule255 = \ ((_hdIppRL) :: [ PPRule ]) ((_tlIppRL) :: [ PPRule ]) ->
{-# LINE 468 "src-ag/AG2AspectAG.ag" #-}
_hdIppRL ++ _tlIppRL
{-# LINE 2759 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule256 #-}
rule256 = \ ((_hdIlocals) :: [Identifier]) ((_tlIlocals) :: [Identifier]) ->
_hdIlocals ++ _tlIlocals
{-# INLINE rule257 #-}
rule257 = \ ((_lhsIext) :: Maybe String) ->
_lhsIext
{-# INLINE rule258 #-}
rule258 = \ ((_lhsIinhNoGroup) :: [String]) ->
_lhsIinhNoGroup
{-# INLINE rule259 #-}
rule259 = \ ((_lhsInewAtts) :: Attributes ) ->
_lhsInewAtts
{-# INLINE rule260 #-}
rule260 = \ ((_lhsInewProd) :: Bool) ->
_lhsInewProd
{-# INLINE rule261 #-}
rule261 = \ ((_lhsIo_noGroup) :: [String]) ->
_lhsIo_noGroup
{-# INLINE rule262 #-}
rule262 = \ ((_lhsIppNt) :: PP_Doc) ->
_lhsIppNt
{-# INLINE rule263 #-}
rule263 = \ ((_lhsIppProd) :: PP_Doc) ->
_lhsIppProd
{-# INLINE rule264 #-}
rule264 = \ ((_lhsIsynNoGroup) :: [String]) ->
_lhsIsynNoGroup
{-# INLINE rule265 #-}
rule265 = \ ((_lhsIext) :: Maybe String) ->
_lhsIext
{-# INLINE rule266 #-}
rule266 = \ ((_lhsIinhNoGroup) :: [String]) ->
_lhsIinhNoGroup
{-# INLINE rule267 #-}
rule267 = \ ((_lhsInewAtts) :: Attributes ) ->
_lhsInewAtts
{-# INLINE rule268 #-}
rule268 = \ ((_lhsInewProd) :: Bool) ->
_lhsInewProd
{-# INLINE rule269 #-}
rule269 = \ ((_lhsIo_noGroup) :: [String]) ->
_lhsIo_noGroup
{-# INLINE rule270 #-}
rule270 = \ ((_lhsIppNt) :: PP_Doc) ->
_lhsIppNt
{-# INLINE rule271 #-}
rule271 = \ ((_lhsIppProd) :: PP_Doc) ->
_lhsIppProd
{-# INLINE rule272 #-}
rule272 = \ ((_lhsIsynNoGroup) :: [String]) ->
_lhsIsynNoGroup
{-# NOINLINE sem_Rules_Nil #-}
sem_Rules_Nil :: T_Rules
sem_Rules_Nil :: T_Rules
sem_Rules_Nil = Identity T_Rules_s44 -> T_Rules
T_Rules (forall (m :: * -> *) a. Monad m => a -> m a
return T_Rules_s44
st44) where
{-# NOINLINE st44 #-}
st44 :: T_Rules_s44
st44 = let
v43 :: T_Rules_v43
v43 :: T_Rules_v43
v43 = \ (T_Rules_vIn43 Maybe String
_lhsIext [String]
_lhsIinhNoGroup Attributes
_lhsInewAtts Bool
_lhsInewProd [String]
_lhsIo_noGroup PP_Doc
_lhsIppNt PP_Doc
_lhsIppProd [String]
_lhsIsynNoGroup) -> ( let
_lhsOppRL :: [ PPRule ]
_lhsOppRL :: [PPRule]
_lhsOppRL = forall {a}. () -> [a]
rule273 ()
_lhsOlocals :: [Identifier]
_lhsOlocals :: [Identifier]
_lhsOlocals = forall {a}. () -> [a]
rule274 ()
__result_ :: T_Rules_vOut43
__result_ = [Identifier] -> [PPRule] -> T_Rules_vOut43
T_Rules_vOut43 [Identifier]
_lhsOlocals [PPRule]
_lhsOppRL
in T_Rules_vOut43
__result_ )
in T_Rules_v43 -> T_Rules_s44
C_Rules_s44 T_Rules_v43
v43
{-# INLINE rule273 #-}
{-# LINE 469 "src-ag/AG2AspectAG.ag" #-}
rule273 = \ (_ :: ()) ->
{-# LINE 469 "src-ag/AG2AspectAG.ag" #-}
[]
{-# LINE 2830 "src-generated/AG2AspectAG.hs" #-}
{-# INLINE rule274 #-}
rule274 = \ (_ :: ()) ->
[]
data Inh_TypeSig = Inh_TypeSig { }
data Syn_TypeSig = Syn_TypeSig { }
{-# INLINABLE wrap_TypeSig #-}
wrap_TypeSig :: T_TypeSig -> Inh_TypeSig -> (Syn_TypeSig )
wrap_TypeSig :: T_TypeSig -> Inh_TypeSig -> Syn_TypeSig
wrap_TypeSig (T_TypeSig Identity T_TypeSig_s47
act) (Inh_TypeSig
Inh_TypeSig ) =
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
do T_TypeSig_s47
sem <- Identity T_TypeSig_s47
act
let arg46 :: T_TypeSig_vIn46
arg46 = T_TypeSig_vIn46
T_TypeSig_vIn46
(T_TypeSig_vOut46
T_TypeSig_vOut46 ) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_TypeSig_s47 -> T_TypeSig_v46
inv_TypeSig_s47 T_TypeSig_s47
sem T_TypeSig_vIn46
arg46)
forall (m :: * -> *) a. Monad m => a -> m a
return (Syn_TypeSig
Syn_TypeSig )
)
{-# INLINE sem_TypeSig #-}
sem_TypeSig :: TypeSig -> T_TypeSig
sem_TypeSig :: TypeSig -> T_TypeSig
sem_TypeSig ( TypeSig Identifier
name_ Type
tp_ ) = Identifier -> Type -> T_TypeSig
sem_TypeSig_TypeSig Identifier
name_ Type
tp_
newtype T_TypeSig = T_TypeSig {
T_TypeSig -> Identity T_TypeSig_s47
attach_T_TypeSig :: Identity (T_TypeSig_s47 )
}
newtype T_TypeSig_s47 = C_TypeSig_s47 {
T_TypeSig_s47 -> T_TypeSig_v46
inv_TypeSig_s47 :: (T_TypeSig_v46 )
}
data T_TypeSig_s48 = C_TypeSig_s48
type T_TypeSig_v46 = (T_TypeSig_vIn46 ) -> (T_TypeSig_vOut46 )
data T_TypeSig_vIn46 = T_TypeSig_vIn46
data T_TypeSig_vOut46 = T_TypeSig_vOut46
{-# NOINLINE sem_TypeSig_TypeSig #-}
sem_TypeSig_TypeSig :: (Identifier) -> (Type) -> T_TypeSig
sem_TypeSig_TypeSig :: Identifier -> Type -> T_TypeSig
sem_TypeSig_TypeSig Identifier
_ Type
_ = Identity T_TypeSig_s47 -> T_TypeSig
T_TypeSig (forall (m :: * -> *) a. Monad m => a -> m a
return T_TypeSig_s47
st47) where
{-# NOINLINE st47 #-}
st47 :: T_TypeSig_s47
st47 = let
v46 :: T_TypeSig_v46
v46 :: T_TypeSig_v46
v46 = \ (T_TypeSig_vIn46
T_TypeSig_vIn46 ) -> ( let
__result_ :: T_TypeSig_vOut46
__result_ = T_TypeSig_vOut46
T_TypeSig_vOut46
in T_TypeSig_vOut46
__result_ )
in T_TypeSig_v46 -> T_TypeSig_s47
C_TypeSig_s47 T_TypeSig_v46
v46
data Inh_TypeSigs = Inh_TypeSigs { }
data Syn_TypeSigs = Syn_TypeSigs { }
{-# INLINABLE wrap_TypeSigs #-}
wrap_TypeSigs :: T_TypeSigs -> Inh_TypeSigs -> (Syn_TypeSigs )
wrap_TypeSigs :: T_TypeSigs -> Inh_TypeSigs -> Syn_TypeSigs
wrap_TypeSigs (T_TypeSigs Identity T_TypeSigs_s50
act) (Inh_TypeSigs
Inh_TypeSigs ) =
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
do T_TypeSigs_s50
sem <- Identity T_TypeSigs_s50
act
let arg49 :: T_TypeSigs_vIn49
arg49 = T_TypeSigs_vIn49
T_TypeSigs_vIn49
(T_TypeSigs_vOut49
T_TypeSigs_vOut49 ) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_TypeSigs_s50 -> T_TypeSigs_v49
inv_TypeSigs_s50 T_TypeSigs_s50
sem T_TypeSigs_vIn49
arg49)
forall (m :: * -> *) a. Monad m => a -> m a
return (Syn_TypeSigs
Syn_TypeSigs )
)
{-# NOINLINE sem_TypeSigs #-}
sem_TypeSigs :: TypeSigs -> T_TypeSigs
sem_TypeSigs :: TypeSigs -> T_TypeSigs
sem_TypeSigs TypeSigs
list = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
Prelude.foldr T_TypeSig -> T_TypeSigs -> T_TypeSigs
sem_TypeSigs_Cons T_TypeSigs
sem_TypeSigs_Nil (forall a b. (a -> b) -> [a] -> [b]
Prelude.map TypeSig -> T_TypeSig
sem_TypeSig TypeSigs
list)
newtype T_TypeSigs = T_TypeSigs {
T_TypeSigs -> Identity T_TypeSigs_s50
attach_T_TypeSigs :: Identity (T_TypeSigs_s50 )
}
newtype T_TypeSigs_s50 = C_TypeSigs_s50 {
T_TypeSigs_s50 -> T_TypeSigs_v49
inv_TypeSigs_s50 :: (T_TypeSigs_v49 )
}
data T_TypeSigs_s51 = C_TypeSigs_s51
type T_TypeSigs_v49 = (T_TypeSigs_vIn49 ) -> (T_TypeSigs_vOut49 )
data T_TypeSigs_vIn49 = T_TypeSigs_vIn49
data T_TypeSigs_vOut49 = T_TypeSigs_vOut49
{-# NOINLINE sem_TypeSigs_Cons #-}
sem_TypeSigs_Cons :: T_TypeSig -> T_TypeSigs -> T_TypeSigs
sem_TypeSigs_Cons :: T_TypeSig -> T_TypeSigs -> T_TypeSigs
sem_TypeSigs_Cons T_TypeSig
arg_hd_ T_TypeSigs
arg_tl_ = Identity T_TypeSigs_s50 -> T_TypeSigs
T_TypeSigs (forall (m :: * -> *) a. Monad m => a -> m a
return T_TypeSigs_s50
st50) where
{-# NOINLINE st50 #-}
st50 :: T_TypeSigs_s50
st50 = let
v49 :: T_TypeSigs_v49
v49 :: T_TypeSigs_v49
v49 = \ (T_TypeSigs_vIn49
T_TypeSigs_vIn49 ) -> ( let
_hdX47 :: T_TypeSig_s47
_hdX47 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_TypeSig -> Identity T_TypeSig_s47
attach_T_TypeSig (T_TypeSig
arg_hd_))
_tlX50 :: T_TypeSigs_s50
_tlX50 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_TypeSigs -> Identity T_TypeSigs_s50
attach_T_TypeSigs (T_TypeSigs
arg_tl_))
(T_TypeSig_vOut46
T_TypeSig_vOut46 ) = T_TypeSig_s47 -> T_TypeSig_v46
inv_TypeSig_s47 T_TypeSig_s47
_hdX47 (T_TypeSig_vIn46
T_TypeSig_vIn46 )
(T_TypeSigs_vOut49
T_TypeSigs_vOut49 ) = T_TypeSigs_s50 -> T_TypeSigs_v49
inv_TypeSigs_s50 T_TypeSigs_s50
_tlX50 (T_TypeSigs_vIn49
T_TypeSigs_vIn49 )
__result_ :: T_TypeSigs_vOut49
__result_ = T_TypeSigs_vOut49
T_TypeSigs_vOut49
in T_TypeSigs_vOut49
__result_ )
in T_TypeSigs_v49 -> T_TypeSigs_s50
C_TypeSigs_s50 T_TypeSigs_v49
v49
{-# NOINLINE sem_TypeSigs_Nil #-}
sem_TypeSigs_Nil :: T_TypeSigs
sem_TypeSigs_Nil :: T_TypeSigs
sem_TypeSigs_Nil = Identity T_TypeSigs_s50 -> T_TypeSigs
T_TypeSigs (forall (m :: * -> *) a. Monad m => a -> m a
return T_TypeSigs_s50
st50) where
{-# NOINLINE st50 #-}
st50 :: T_TypeSigs_s50
st50 = let
v49 :: T_TypeSigs_v49
v49 :: T_TypeSigs_v49
v49 = \ (T_TypeSigs_vIn49
T_TypeSigs_vIn49 ) -> ( let
__result_ :: T_TypeSigs_vOut49
__result_ = T_TypeSigs_vOut49
T_TypeSigs_vOut49
in T_TypeSigs_vOut49
__result_ )
in T_TypeSigs_v49 -> T_TypeSigs_s50
C_TypeSigs_s50 T_TypeSigs_v49
v49