h$mdR      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                      None#$'(35679>?  syntacticHigher-kinded version of  syntacticForce a symbol to normal form syntactic"Typed" symbol. Using  sym instead of sym gives access to the function 0 for casting expressions. syntacticExistential quantification of  -indexed type syntacticExistential quantification syntacticEmpty symbol type Can be used to make uninhabited $ types. It can also be used as a terminator in co-product lists (e.g. to avoid overlapping instances): (A :+: B :+: Empty)  syntacticSymbol injectionThe class includes types sub and sup where sup is of the form (...   sub   ...).  syntacticInjection from sub to sup  syntacticSymbol projectionThe class is defined for all pairs of types, but   can only succeed if sup is of the form (...   sub   ...).  syntacticPartial projection from sup to sub  syntactic Direct sum of two symbol domains syntactic7Returns the symbol in the result of a smart constructor syntacticMaps a smart constructor type to the corresponding symbol signature: SmartSig (ASTF sym a -> ASTF sym b -> ... -> ASTF sym x) = a :-> b :-> ... :-> Full x syntacticMaps a symbol signature to the type of the corresponding smart constructor: SmartFun sym (a :-> b :-> ... :-> Full x) = ASTF sym a -> ASTF sym b -> ... -> ASTF sym x syntacticValid symbols to use in an $ syntacticReify the signature of a symbol syntactic4The result type of a symbol with the given signature syntacticValid symbol signatures syntactic*Witness of the arity of a symbol signature syntactic6Signature of a partially applied (or unapplied) symbol syntactic#Signature of a fully applied symbol  syntactic"Fully applied abstract syntax treeThis type is like $, but being a newtype, it is a proper type constructor that can be partially applied.# syntactic"Fully applied abstract syntax tree$ syntactic>Generic abstract syntax tree, parameterized by a symbol domain($ sym (a  b)) represents a partially applied (or unapplied) symbol, missing at least one argument, while ($ sym ( a)) represents a fully applied symbol, i.e. a complete syntax tree.' syntactic"Count the number of symbols in an $( syntactic&Make a smart constructor of a symbol. ( has any type of the form: smartSym' :: sym (a :-> b :-> ... :-> Full x) -> (ASTF sym a -> ASTF sym b -> ... -> ASTF sym x)) syntactic&Make a smart constructor of a symbol. ) has any type of the form: smartSym :: (sub :<: AST sup) => sub (a :-> b :-> ... :-> Full x) -> (ASTF sup a -> ASTF sup b -> ... -> ASTF sup x)* syntactic&Make a smart constructor of a symbol. * has any type of the form: smartSymTyped :: (sub :<: AST (Typed sup), Typeable x) => sub (a :-> b :-> ... :-> Full x) -> (ASTF sup a -> ASTF sup b -> ... -> ASTF sup x)/ syntacticInject a symbol in an $ with a  domain0 syntacticType cast an expression1 syntactic%Constrain a symbol to a specific type2 syntactic$Projection to a specific symbol type0 syntacticExpression to cast syntactic!Witness for typeability of result3  !"#$%&'()*+,-./0123$%&# !"'(  )*+,-./012  &1None#$'(35679>?I syntacticN-ary syntactic functionsJ has any type of the form: desugarN :: ( Syntactic a , Syntactic b , ... , Syntactic x , Domain a ~ sym , Domain b ~ sym , ... , Domain x ~ sym ) => (a -> b -> ... -> x) -> ( ASTF sym (Internal a) -> ASTF sym (Internal b) -> ... -> ASTF sym (Internal x) )...and vice versa for K.L syntacticIt is usually assumed that (O (P a)) has the same meaning as a.Q syntacticSyntactic type castingR syntactic"Sugared" symbol applicationR has any type of the form: sugarSym :: ( sub :<: AST sup , Syntactic a , Syntactic b , ... , Syntactic x , Domain a ~ Domain b ~ ... ~ Domain x ) => sub (Internal a :-> Internal b :-> ... :-> Full (Internal x)) -> (a -> b -> ... -> x)S syntactic"Sugared" symbol applicationS has any type of the form: sugarSymTyped :: ( sub :<: AST (Typed sup) , Syntactic a , Syntactic b , ... , Syntactic x , Domain a ~ Domain b ~ ... ~ Domain x , Typeable (Internal x) ) => sub (Internal a :-> Internal b :-> ... :-> Full (Internal x)) -> (a -> b -> ... -> x) IKJLPONMQRS LPONMQIKJRSNone#$'(35679>?\X syntacticConvert a symbol to a  of stringsY syntacticConvert a symbol to a  given a list of argument treesZ syntacticRender a symbol as concrete syntax. A complete instance must define at least the [ method.[ syntacticShow a symbol as a \ syntactic2Render a symbol given a list of rendered arguments] syntacticHigher-kinded equality^ syntacticHigher-kinded equalityComparing elements of different types is often needed when dealing with expressions with existentially quantified sub-terms._ syntactic hash a == hash b` syntacticImplementation of \ that handles infix operatorsa syntactic Render an $ as concrete syntaxb syntactic Convert an $ to a  of stringsc syntactic"Show a syntax tree using ASCII artd syntactic#Print a syntax tree using ASCII arte syntactic7Write a syntax tree to an HTML file with foldable nodesf syntacticDefault implementation of ^g syntacticDefault implementation of _XYZ[\]_^`abcdefg]_^Z[\`aXYbcdefgNone#$'(35679>?'u syntactic=Can be used to make an arbitrary type constructor indexed by ( a)7. This is useful as the type constructor parameter of x. That is, use Args (WrapFull c) ... instead of  Args c ...if c is not indexed by ( a).x syntacticList of symbol arguments{ syntacticMap a function over all immediate sub-terms (corresponds to the function with the same name in Scrap Your Boilerplate)| syntacticMap a function over all immediate sub-terms, collecting the results in a list (corresponds to the function with the same name in Scrap Your Boilerplate)} syntactic)Apply a transformation bottom-up over an $ (corresponds to  everywhere in Scrap Your Boilerplate)~ syntactic(Apply a transformation top-down over an $ (corresponds to  everywhere' in Scrap Your Boilerplate) syntactic#List all sub-terms (corresponds to universe in Uniplate) syntacticMap a function over an x1 list and collect the results in an ordinary list syntacticMap a function over an x list syntactic$Map an applicative function over an x list syntacticMap a monadic function over an x list syntacticRight fold for an x list syntactic>Apply a (partially applied) symbol to a list of argument terms syntactic"Pattern match" on an $ using a function that gets direct access to the top-most symbol and its sub-trees syntactic A version of  with a simpler result type syntacticFold an $ using an x& list to hold the results of sub-terms syntacticSimplified version of  for situations where all intermediate results have the same type syntacticFold an $. using a list to hold the results of sub-terms syntactic A version of  where the result is a transformed syntax tree, wrapped in a type constructor c syntacticUpdate the symbols in an AST syntactic Convert an $ to a uvwxyz{|}~|{}~xyzuvwz None#$'(35679>?.  syntactic=Decorating symbols or expressions with additional information One usage of  is to decorate every node of a syntax tree. This is done simply by changing  AST sym sigto AST (sym :&: info) sig syntacticMap over a decoration syntactic(Get the decoration of the top-level node syntactic+Update the decoration of the top-level node syntacticLift a function that operates on expressions with associated information to operate on a  expression. This function is convenient to use together with e.g. queryNodeSimple when the domain has the form (sym  info). syntacticStrip decorations from an $ syntactic#Rendering of decorated syntax trees syntactic-Show an decorated syntax tree using ASCII art syntactic.Print an decorated syntax tree using ASCII art syntactic&Make a smart constructor of a symbol.  has any type of the form: smartSymDecor :: (sub :<: AST (sup :&: info)) => info x -> sub (a :-> b :-> ... :-> Full x) -> (ASTF sup a -> ASTF sup b -> ... -> ASTF sup x) syntactic"Sugared" symbol application has any type of the form: sugarSymDecor :: ( sub :<: AST (sup :&: info) , Syntactic a , Syntactic b , ... , Syntactic x , Domain a ~ Domain b ~ ... ~ Domain x ) => info (Internal x) -> sub (Internal a :-> Internal b :-> ... :-> Full (Internal x)) -> (a -> b -> ... -> x)None#$'(35679>?.  !"#$%&'()*+,-./012IJKLPOMNMNQRSXYZ[\]_^`abcdefguvwxyz{|}~None#$'(35679>?6 syntacticDescription of class methods syntactic rhs = lhs syntactic /MatchingMethod methodName mkClause extraClausesmkClause takes as arguments (1) a description of the constructor, (2) the constructor's index, (3) the constructor's name, and (4) its arity. syntactic'Get the name and arity of a constructor syntactic!General method for class deriving syntactic!General method for class deriving syntacticDerive  instance for a type syntacticDerive ] instance for a type equal Con1 Con1 = True equal (Con2 a1 ... x1) (Con2 a2 ... x2) = and [a1==a2, ... x1==x2] equal _ _ = False hash Con1 = hashInt 0 hash (Con2 a ... x) = foldr1 combine [hashInt 1, hash a, ... hash x] syntacticDerive Z instance for a type renderSym Con1 = "Con1" renderSym (Con2 a ... x) = concat ["(", unwords ["Con2", show a, ... show x], ")"] syntactic!Construct an instance declaration syntactic.Get the constructors of a data type definition syntactic#Portable method for constructing a  of the form  (t1 ~ t2) syntactic#Portable method for constructing a  of the form SomeClass t1 t2 ... syntactic8Portable method for constructing a type synonym instance syntacticInstance context syntacticType constructor name syntacticClass head (e.g.  Render Con) syntacticMethods syntactic Class name syntacticType constructor name syntacticMethods syntactic Type name syntactic Type name syntacticConstructor name modifier syntactic Type name syntacticContext syntacticInstance syntactic Methods, etc. syntactic Class name syntactic,How to make a type for the class (typically  or ) syntacticClass argumentsNone#$'(35679>?7c syntacticMax tuple width  None#$'(35679>?8 syntactic1Tuples that can be converted to/from nested pairs syntacticRepresentation as nested pairs syntacticConvert to nested pairs syntacticConvert from nested pairs None#$'(35679>?9 syntactic internalPred (see above) syntacticmkDomain (see above) syntacticextraConstraint (see above) syntacticMax tuple width None#$'(35679>?Qv% syntactic Evaluation syntacticRuntime environment syntactic3Monadic denotation; mapping from a symbol signature a :-> b :-> Full cto m a -> m b -> m c syntactic4Semantic function type of the given symbol signature syntacticEnvironment used by  syntacticReifiable monadSee "Generic Monadic Constructs for Embedded Languages" (Persson et al., IFL 2011  ?https://emilaxelsson.github.io/documents/persson2011generic.pdf).!It is advised to convert to/from  using the L# instance provided in the modules Language.Syntactic.Sugar.Monad or Language.Syntactic.Sugar.MonadT. syntacticMonadic constructsSee "Generic Monadic Constructs for Embedded Languages" (Persson et al., IFL 2011  ?https://emilaxelsson.github.io/documents/persson2011generic.pdf). syntacticA symbol for let bindingsThis symbol is just an application operator. The actual binding has to be done by a lambda that constructs the second argument.The provided string is just a tag and has nothing to do with the name of the variable of the second argument (if that argument happens to be a lambda). However, a back end may use the tag to give a sensible name to the generated variable.The string tag may be empty. syntactic2Domains that "might" include variables and binders syntactic;Rename a variable or a lambda (no effect for other symbols) syntacticTyped variables and binders syntacticVariables and binders syntactic Variable name syntactic!Generic N-ary syntactic construct gives a quick way to introduce a syntactic construct by giving its name and semantic function. syntacticLiteral syntactic(Get the highest name bound by the first 7 binders at every path from the root. If the term has ordered binders 1, 7 returns the highest name introduced in the whole term.1) Ordered binders means that the names of 6 nodes are decreasing along every path from the root. syntacticHigher-order interface for variable binding for domains based on  Assumptions: The body f does not inspect its argument. Applying f7 to a term with ordered binders results in a term with ordered binders 1.1) Ordered binders means that the names of 6 nodes are decreasing along every path from the root.See "Using Circular Programs for Higher-Order Syntax" (ICFP 2013,  >https://emilaxelsson.github.io/documents/axelsson2013using.pdf). syntactic+Higher-order interface for variable bindingThis function is  specialized to domains sym satisfying (   sym). syntacticConvert from a term with De Bruijn indexes to one with explicit namesIn the argument term, variable /s are treated as De Bruijn indexes, and lambda s are ignored. (Ideally, one should use a different type for De Bruijn terms.) syntactic(Get the highest name bound by the first 7 binders at every path from the root. If the term has ordered binders 1, 7 returns the highest name introduced in the whole term.1) Ordered binders means that the names of 6 nodes are decreasing along every path from the root. syntactic+Higher-order interface for variable binding Assumptions: The body f does not inspect its argument. Applying f7 to a term with ordered binders results in a term with ordered binders 1.1) Ordered binders means that the names of 6 nodes are decreasing along every path from the root.See "Using Circular Programs for Higher-Order Syntax" (ICFP 2013,  >https://emilaxelsson.github.io/documents/axelsson2013using.pdf). syntactic+Higher-order interface for variable bindingThis function is  specialized to domains sym satisfying (   sym). syntactic+Higher-order interface for variable bindingThis function is  specialized to domains sym satisfying (sym ~  s,    s). syntactic'One-layer desugaring of monadic actions syntactic'One-layer desugaring of monadic actions syntactic.Get the set of free variables in an expression syntacticGet the set of variables (free, bound and introduced by lambdas) in an expression syntactic$Rename the bound variables in a termThe free variables are left untouched. The bound variables are given unique names using as small names as possible. The first argument is a list of reserved names. Reserved names and names of free variables are not used when renaming bound variables. syntactic$Rename the bound variables in a termThe free variables are left untouched. The bound variables are given unique names using as small names as possible. Names of free variables are not used when renaming bound variables. syntacticAlpha-equivalence syntactic Evaluation syntacticLift a  to  syntacticSimple implementation of  from a  syntacticEvaluation of open terms syntactic!Evaluation of closed terms where $ is used as the internal environment(Note that there is no guarantee that the term is actually closed.) syntactic^> does strict identifier comparison; i.e. no alpha equivalence._ assigns the same hash to all variables and binders. This is a valid over-approximation that enables the following property:  a b ==> _ a == _ b syntactic^> does strict identifier comparison; i.e. no alpha equivalence._ assigns the same hash to all variables and binders. This is a valid over-approximation that enables the following property:  a b ==> _ a == _ b syntacticVariable symbol constructor syntacticLambda constructor syntacticVariable symbol constructor syntacticLambda constructor55 None#$'(35679>?R None#$'(35679>?S syntactic%One-layer sugaring of monadic actions None#$'(35679>?SENone#$'(35679>?S syntactic%One-layer sugaring of monadic actionsNone#$'(35679>?[ syntactic Well-scoped $ syntacticWrap a symbol to give it a  signature syntacticMapping from a symbol signature /Reader e a :-> Reader e b :-> Full (Reader e c)to a :-> b :-> Full c syntacticMapping from a symbol signature a :-> b :-> Full cto 5Reader env a :-> Reader env b :-> Full (Reader env c) syntacticWell-scoped variable bindingWell-scoped terms are introduced to be able to evaluate without type casting. The implementation is inspired by "Typing Dynamic Typing" (Baars and Swierstra, ICFP 2002,  (http://doi.acm.org/10.1145/581478.5814946) where expressions are represented as (essentially)  env a after "compilation". However, a major difference is that "Typing Dynamic Typing" starts from an untyped term, and thus needs (safe) dynamic type casting during compilation. In contrast, the denotational semantics of  (the ! instance) uses no type casting. syntacticEnvironment extension syntactic&Remove the extension of an environment syntactic;Return the amount by which an environment has been extended syntactic!Lookup in an extended environment syntactic7Higher-order interface for well-scoped variable bindingInspired by Conor McBride's "I am not a number, I am a classy hack" ( 0http://mazzo.li/epilogue/index.html%3Fp=773.html). syntactic$Evaluation of open well-scoped terms syntactic&Evaluation of closed well-scoped terms syntactic9Convert the representation of variables and binders from  to *. The latter is easier to analyze, has a Z instance, etc. syntactic0Make a smart constructor for well-scoped terms.  has any type of the form: smartWS :: (sub :<: sup, bsym ~ (BindingWS :+: ReaderSym sup)) => sub (a :-> b :-> ... :-> Full x) -> ASTF bsym (Reader env a) -> ASTF bsym (Reader env b) -> ... -> ASTF bsym (Reader env x)None#$'(35679>?\2None#$'(35679>?\None#$'(35679>?\None#$'(35679>?d  syntacticCode motion interface syntacticTry to construct an . The first argument is the expression to be shared, and the second argument the expression in which it will be shared. This function can be used to transfer information (e.g. from static analysis) from the shared expression to the introduced variable. syntacticTry to type cast an expression. The first argument is the expression to cast. The second argument can be used to construct a witness to support the casting. The resulting expression (if any) should be equal to the first argument. syntacticWhether a sub-expression can be hoisted over the given expression syntactic*Interface for injecting binding constructs syntacticInject a variable syntacticInject a lambda syntacticInject a "let" symbol syntacticDefault  for domains of the form  (...      ...). syntacticDefault  for domains of the form (...  info), where info$ can be used to witness type casting syntactic?Perform common sub-expression elimination and variable hoisting syntacticVariable constructor (e.g.  or ) syntacticLambda constructor (e.g.  or ) syntacticCan the expression represented by the first argument be shared in the second argument? syntactic"Can we hoist over this expression? syntactic!Construct a type equality witness syntacticConstruct info for a function, given info for the argument and the result syntacticVariable constructor syntacticLambda constructor syntacticCan the expression represented by the first argument be shared in the second argument? syntactic"Can we hoist over this expression?   !"#$%&'()*+,-.//01123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                      &syntactic-3.8.3-5Z13UrStQTrIgudx32D9SrLanguage.Syntactic.SyntaxLanguage.Syntactic.Sugar!Language.Syntactic.InterpretationLanguage.Syntactic.TraversalLanguage.Syntactic.DecorationLanguage.Syntactic.THData.NestTuple.THData.NestTuple&Language.Syntactic.Functional.Tuple.THLanguage.Syntactic.Functional%Language.Syntactic.Sugar.BindingTyped#Language.Syntactic.Sugar.MonadTyped Language.Syntactic.Sugar.BindingLanguage.Syntactic.Sugar.Monad(Language.Syntactic.Functional.WellScoped#Language.Syntactic.Functional.Tuple#Language.Syntactic.Sugar.TupleTypedLanguage.Syntactic.Sugar.Tuple%Language.Syntactic.Functional.SharingLanguage.SyntacticNFData1rnf1TypedEFEEmpty:<:injProjectprj:+:InjLInjRSmartSymSmartSigSmartFunSymbolsymSig DenResult Signature signatureSigRepSigFullSigMore:->PartialFullresultASTFull unASTFullASTFASTSym:$size smartSym'smartSym smartSymTypedliftEliftE2liftEFliftEF2injTcastExprsymTypeprjP $fFunctorAST$fSignature:->$fSignatureFull $fSymbol:+:$fProjectsym1:+:$fProjectsym1:+:0$fProjectsymsym$fProjectsubAST $f:<:sym1:+: $f:<:sym1:+:0 $f:<:symsym $f:<:subAST$fProjectsubTyped $fNFData1:+: $fNFDataAST $fFunctor:+: $fFoldable:+:$fTraversable:+: $fFunctor:->$fEqFull $fShowFull $fFunctorFull SyntacticNdesugarNsugarN SyntacticDomainInternaldesugarsugarresugarsugarSym sugarSymTyped$fSyntacticASTFull$fSyntacticAST$fSyntacticN->->$fSyntacticNffi StringTree stringTreeSymRender renderSym renderArgsEqualityequalhashrenderArgsSmartrender stringTreeshowASTdrawAST writeHtmlAST equalDefault hashDefault $fShowAST $fRenderTyped $fRenderEmpty $fRender:+:$fEqualityTyped$fEqualityEmpty$fEq:+: $fEquality:+:$fEqAST $fEqualityAST$fStringTreeTyped$fStringTreeEmpty$fStringTree:+:WrapFull unwrapFullArgsNil:*gmapTgmapQ everywhereUpeverywhereDownuniverselistArgsmapArgsmapArgsAmapArgsM foldrArgsappArgsmatch simpleMatchfold simpleFoldlistFold matchTransmapASTtoTree:&: decorExpr decorInfomapDecorgetDecor updateDecor liftDecor stripDecorstringTreeDecor showDecorWith drawDecorWithwriteHtmlDecorWith smartSymDecor sugarSymDecor$fStringTree:&: $fRender:&: $fEquality:&:$fProjectsub:&: $fNFData1:&: $fSymbol:&:Method DefaultMethodMatchingMethodconName deriveClassderiveClassSimple varSupply deriveSymbolderiveEquality deriveRenderinstD viewDataDefeqPred classPred tySynInstNestLeafPairmkTupTmkPairTmkTupEmkPairEmkPairPfoldNesttoNestmkNestableInstances$fEqNest $fShowNest $fFunctorNestNestableNestednestunnest$fNestable(,,,,,,,,,,,,,,)$fNestable(,,,,,,,,,,,,,)$fNestable(,,,,,,,,,,,,)$fNestable(,,,,,,,,,,,)$fNestable(,,,,,,,,,,)$fNestable(,,,,,,,,,)$fNestable(,,,,,,,,)$fNestable(,,,,,,,)$fNestable(,,,,,,)$fNestable(,,,,,)$fNestable(,,,,)$fNestable(,,,)$fNestable(,,) $fNestable(,)deriveSyntacticForTuplesEvalEnv compileSymRunEnv DenotationMEvalevalSym DenotationAlphaEnvRemonunRemonMONADReturnBindLet BindingDomainprVarprLam renameBindBindingTVarTLamTBindingVarLamName ConstructLiteralmaxLam lam_templatelam fromDeBruijnmaxLamT lamT_templatelamTlamTyped desugarMonaddesugarMonadTypedfreeVarsallVars renameUnique' renameUniquealphaEq'alphaEqevalDenliftDenotationMcompileSymDefaultevalOpen evalClosed$fStringTreeLiteral$fEqualityLiteral$fRenderLiteral$fSymbolLiteral $fShowName$fStringTreeBinding$fRenderBinding$fEqualityBinding$fNFData1Binding$fSymbolBinding$fStringTreeBindingT$fRenderBindingT$fEqualityBindingT$fNFData1BindingT$fSymbolBindingT$fBindingDomainsym$fBindingDomainBindingT$fBindingDomainBinding$fBindingDomainAST$fBindingDomain:&:$fBindingDomainTyped$fBindingDomain:+:$fStringTreeLet $fEqualityLet $fRenderLet $fSymbolLet$fStringTreeMONAD$fEqualityMONAD $fRenderMONAD $fSymbolMONAD $fMonadRemon$fApplicativeRemon$fStringTreeConstruct$fEqualityConstruct$fRenderConstruct$fSymbolConstruct $fEvalMONAD $fEvalLet$fEvalConstruct $fEvalLiteral $fEval:&: $fEvalEmpty $fEval:+:$fEvalEnvBindingT[]$fEvalEnvMONADenv$fEvalEnvLetenv$fEvalEnvConstructenv$fEvalEnvLiteralenv$fEvalEnv:&:env$fEvalEnvTypedenv$fEvalEnvEmptyenv$fEvalEnv:+:env$fFunctorRemon$fEqName $fOrdName $fNumName $fEnumName $fRealName$fIntegralName $fNFDataName $fSyntactic-> sugarMonad$fSyntacticRemonWS ReaderSym LowerReaderUnReader LiftReader BindingWSVarWSLamWSExtunextdifflookEnvlamWS evalOpenWS evalClosedWSfromWSsmartWS $fExtexte $fExtenvenv$fEvalBindingWS$fNFData1BindingWS$fSymbolBindingWS$fEvalReaderSymTupleFstSnd $fSymbolTuple$fEqualityTuple$fEvalEnvTupleenv $fEvalTuple$fStringTreeTuple $fRenderTuple$fSyntactic(,)$fSyntactic(,,,,,,,,,,,,,,)$fSyntactic(,,,,,,,,,,,,,)$fSyntactic(,,,,,,,,,,,,)$fSyntactic(,,,,,,,,,,,)$fSyntactic(,,,,,,,,,,)$fSyntactic(,,,,,,,,,)$fSyntactic(,,,,,,,,)$fSyntactic(,,,,,,,)$fSyntactic(,,,,,,)$fSyntactic(,,,,,)$fSyntactic(,,,,)$fSyntactic(,,,)$fSyntactic(,,)CodeMotionInterface Interface mkInjDict castExprCM hoistOverInjDict injVariable injLambdainjLetdefaultInterfacedefaultInterfaceDecor codeMotiondeepseq-1.4.4.0Control.DeepSeqNFDatacontainers-0.6.2.1 Data.TreeTreebaseGHC.BaseStringtemplate-haskellLanguage.Haskell.TH.SyntaxPredConTtransformers-0.5.6.2Control.Monad.Trans.ReaderReader