[vS4portable experimental(Niklas Broberg, niklas.broberg@gmail.comNone#>A simple datatype to annotate return values from sub-patterns 5A simple annotation datatype for statement contexts. ?Transform away occurences of regular patterns from an abstract ' Haskell module, preserving semantics. <Transform a declaration by transforming subterms that could  contain regular patterns. Transform a function match" by generating pattern guards and B declarations representing regular patterns in the argument list. F Subterms, such as guards and the right-hand side, are also traversed  transformed. ATransform and update guards and right-hand side of a function or B pattern binding. The supplied list of guards is prepended to the > original guards, and subterms are traversed and transformed. HPlace declarations of postponed regular patterns in a let-expression to G make them lazy, in order to make them behave as irrefutable patterns. 3Make pattern binds from postponed regular patterns .Transform expressions by traversing subterms. H Of special interest are expressions that contain patterns as subterms,  i.e. let, case6 and lambda expressions, and also list comprehensions  and do;-expressions. All other expressions simply transform their  sub-expressions, if any. = Of special interest are of course also any xml expressions. .Transform expressions by traversing subterms. H Of special interest are expressions that contain patterns as subterms,  i.e. let, case6 and lambda expressions, and also list comprehensions  and do;-expressions. All other expressions simply transform their  sub-expressions, if any. = Of special interest are of course also any xml expressions. -Transform pattern bind declarations inside a let-expression by transforming S subterms that could appear as regular patterns, as well as transforming the bound Q pattern itself. The reason we need to do this in a special way is scoping, i.e.  in the expression let a | Just b <- match a = list in b the variable b will not  be in scope after the in9. And besides, we would be on thin ice even if it was in P scope since we are referring to the pattern being bound in the guard that will P decide if the pattern will be bound... yikes, why does Haskell allow guards on V pattern binds to refer to the patterns being bound, could that ever lead to anything  but an infinite loop?? OTransform binding of implicit parameters by transforming the expression on the N right-hand side. The left-hand side can only be an implicit parameter, so no  regular patterns there... >Transform statements by traversing and transforming subterms. > Since generator statements have slightly different semantics A depending on their context, statements are annotated with their A context to ensure that the semantics of the resulting statement @ sequence is correct. The return type is a list since generated = guards will be added as statements on the same level as the  statement to be transformed. Transform alternatives in a case-expression. Patterns are : transformed, while other subterms are traversed further. FGenerate variables as placeholders for any regular patterns, in order K to place their evaluation elsewhere. We must likewise move the evaluation 9 of Tags because attribute lookups are force evaluation. !Rename declarations appearing in lets or where clauses. )Move irrefutable regular patterns into a let-expression instead, $ to make sure that the semantics of ~ are preserved. 8Transform several patterns in the same context, thereby 4 generating any code for matching regular patterns. /Transform several patterns in the same context 3Transform a pattern by traversing the syntax tree. 5 A regular pattern is translated, other patterns are  simply left as is. 2Transform away a regular pattern, generating code  to replace it. Functions and ids from the Match module, * used in the generated matching functions Functions and ids from the Match module, * used in the generated matching functions Functions and ids from the Match module, * used in the generated matching functions Functions and ids from the Match module, * used in the generated matching functions Some magic& gensym-like functions, and functions  with related functionality. :Create an xml tag, given its domain, name, attributes and  children. @Create an empty xml tag, given its domain, name and attributes. /Create an attribute by applying the overloaded asAttr 1Create a property from an attribute and a value. DMake xml out of some expression by applying the overloaded function  asChild.  convert a ! literal to lazy Text by calling a function named  fromStringLit ".Lookup an attribute in the set of attributes. #3Generate a pattern under the Tag data constructor. $6Generate a pattern under the PCDATA data constructor. %&'()*+,-./0123456789:;<=>?  @ABCD EFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ "#$%)('&*+,-./0143256789:;<=>?  @ABCD EFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ "#$None2QuasiQuoter which can be used to parse HSX syntax       !"#$%&'()*+,-.//01233456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ hsx2hs-0.13.0Language.Haskell.HSX.TransformLanguage.Haskell.HSX.QQ transform transformExphsxMTypeStmtType transformDecltransformMatchmkRhs addLetDeclsmkDecl transformExpMtransformLetDeclstransformIPBind transformStmt transformAlt renameRPatsrenameLetDecls renameIrrPatstransformPatterns trPatterns trPatterntrRPat runMatchFun baseMatchFun manyMatchFun gManyMatchFunretnamemetaGenElementmetaGenEElement metaAsAttr metaAssign metaAsChildmetaFromStringLitbaseGHC.BaseString metaExtractmetaTag metaPcdata MFunMetaInfoMELSTrStateNameBindRNStateRNGuard ListCompStmt GuardStmtDoStmtHsxStateHsxMMkHsxM getHsxState setHsxState initHsxStatesetHarpTransformedsetXmlTransformedrunHsxMtransformInstDecltransformClassDecltransformFieldUpdatetransformSplice transform2exp transform3expmkAttrtransformQualStmt mkStmtGuard mkDeclGuard initRNState runRename getRNState setRNState genVarName rename1pat rename2pat renameNpatrenameRP renameIrrPliftTr initState initStateFromrunTr runTrFromTogetStatesetState updateState pushGuardpushDecl pushAttrGuard genMatchName genPatName genAttrNamesetHarpTransformedTsetXmlTransformedTtr1pattr2pattrNpat runMatch_namebaseMatch_namemanyMatch_namegManyMatch_name match_modmatch_qual_mod match_qualchoiceOpappendOp foldCompFun mkMetaUnzip matchFunctionvarsnamevalnamevalsname valsvarsname mkValName extendVar xNameParts metaReturn metaConst metaUnzip metaEither metaMaybe metaConcatmetaMap metaAppend metaChoice metaPConsmetaConsmetaComp metaPJust metaPNothing metaPMkMaybemetaJust metaNothing metaMkMaybeconsFunidFunconconsfcompchoiceappend just_name nothing_name left_name right_name argAsAttr metaMkName $fFunctorTr $fMonadTr $fFunctorRN $fMonadRN $fFunctorHsxM $fMonadHsxM parseHsxExpparseExp parseHsExp parseMode allExtensions