3pl      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQ R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None !"&*+-23468=BHJKMDifference list Empty listSingleton list Given a list isI of unique natural numbers, returns a function that maps each number in is! to a unique number in the range [0 .. length is-1]. The complexity is O( maximum is).Count the number of occurrences of each element in the list. The result is an array mapping each element to its number of occurrences.Partitions the list such that two elements are in the same sub-list if and only if they satisfy the equivalence check. The complexity is O(n^2).3Upper and lower bound on the elements to be countedElements to be countedNone !"&'*+-23468=BHJKMKind-polymorphic proxy typeNone !"&*+-23468=BHJKM     None !"&*+-23468=BHJKM Symbol subsumptionInjection from sub to supSymbol projectionPartial projection from sup to sub Direct sum of two symbol domains4The result type of a symbol with the given signature-Class for the type-level recursion needed by !6Signature of a partially applied (or unapplied) symbol#Signature of a fully applied symbol"Fully applied abstract syntax tree>Generic abstract syntax tree, parameterized by a symbol domain( dom (a  b))] represents a partially applied (or unapplied) symbol, missing at least one argument, while ( dom ( a))A represents a fully applied symbol, i.e. a complete syntax tree. ,Count the number of symbols in an expression!Generic symbol application! has any type of the form: |appSym :: (expr :<: AST dom) => expr (a :-> b :-> ... :-> Full x) -> (ASTF dom a -> ASTF dom b -> ... -> ASTF dom x)"%Constrain a symbol to a specific type#$Projection to a specific symbol type$  !"#  !"#  !"#  !"#  None !"&*+-23468=BHJKM$=Can be used to make an arbitrary type constructor indexed by ( a)7. This is useful as the type constructor parameter of '. That is, use Args (WrapFull c) ... instead of  Args c ...if c is not indexed by ( a).'List of symbol arguments*wMap a function over all immediate sub-terms (corresponds to the function with the same name in Scrap Your Boilerplate)+Map 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),EApply a transformation bottom-up over an expression (corresponds to  everywhere in Scrap Your Boilerplate)-DApply a transformation top-down over an expression (corresponds to  everywhere' in Scrap Your Boilerplate).Map a function over an '2 list and collect the results in an ordinary list/Map a function over an ' list0$Map an applicative function over an ' list1Map a monadic function over an ' listRight fold for an ' list2>Apply a (partially applied) symbol to a list of argument terms3"Pattern match" on an S using a function that gets direct access to the top-most symbol and its sub-trees5 A version of 3 with a simpler result type6Fold an  using an '& list to hold the results of sub-terms7Simplified version of 6B for situations where all intermediate results have the same type8Fold an . using a list to hold the results of sub-terms9 A version of 3O where the result is a transformed syntax tree, wrapped in a type constructor c: Convert an  to a $%&'()*+,-./0123456789:$%&'()*+,-./0123456789:+*,-')(./0128345679$%&:$%&')(*+,-./0123456789:( None !"&*+-23468=BHJKM;Equality for expressions<Equality for expressionsComparing expressions of different types is often needed when dealing with expressions with existentially quantified sub-terms.= Computes a = for an expression. Expressions that are equal according to < must result in the same hash: (equal a b ==> exprHash a == exprHash b;<=>?@A;<=;<=A@?>;<=>?@ANone !"&*+-23468=BHJKM BConvert a symbol to a  of stringsCConvert a symbol to a  given a list of argument treesDQRender a symbol as concrete syntax. A complete instance must define at least the E method.EShow a symbol as a F2Render a symbol given a list of rendered argumentsG'Render an expression as concrete syntaxHConvert an expression to a  of stringsI"Show a syntax tree using ASCII artJ#Print a syntax tree using ASCII art BCDEFGHIJK BCDEFGHIJK DEFGBCHIJK BCDEFGHIJKNone !"&*+-23468=BHJKMMEvaluation of expressionsN3The denotation of a symbol with the given signatureLMNOP LMNNLMPOLMNOP None !"&*+-23468=BHJKMQ6Class of expressions that can be treated as constructsS/A representation of a syntactic construct as a U and an evaluation function. It is not meant to be used as a syntactic symbol in an Q. Its only purpose is to provide the default implementations of functions like < via the Q class.WDefault implementation of <XDefault implementation of =YDefault implementation of EZDefault implementation of F[Default implementation of M\Derive instances for Q related classes (;, D, B, L)QRSTUVWXYZ[\]^_ QRSTUVWXYZ[\STUV_^]QRWXYZ[\ QRSTUVWXYZ[\]^_ None !"&*+-23468=BHJKM`Empty symbol type Use-case: cdata A a data B a test :: AST (A :+: (B:||Eq) :+: Empty) a test = injC (undefined :: (B :|| Eq) a)Without `G, this would lead to an overlapping instance error due to the instances +InjectC (B :|| Eq) (B :|| Eq) (DenResult a)and :InjectC sub sup a, pred a) => InjectC sub (sup :|| pred) ab2 with bounded existentially quantified result typed* with existentially quantified result typef Similar to h(, but assumes a result type of the form c a b and constrains both a and b.h Similar to p\, but rather than constraining the whole result type, it assumes a result type of the form c a and constrains the a.jSymbol injection (like  ) with constrained result typesm-Expressions that constrain their result typesndReturns a predicate that is satisfied by the result type of all expressions of the given type (see o).o8Compute a constraint on the result type of an expressionpBConstrain the result type of the expression by the given predicateThe difference between p and r! is seen in the instances of the n type: Jtype Sat (dom :| pred) = pred :/\: Sat dom type Sat (dom :|| pred) = predrBConstrain the result type of the expression by the given predicatet"Subset relation on type predicatesuCompute evidence that sub is a subset of sup (i.e. that (sup a) implies (sub a))vEvidence that the predicate sub is a subset of supwUniversal type predicatexIntersection of type predicates{Weaken an intersection|Weaken an intersection} A version of o7 that returns a constraint for a particular predicate p as long as (p :< Sat dom) holds~ A version of o% that works for domains of the form (dom1 :+: dom2) as long as (Sat dom1 ~ Sat dom2) holdsGeneric symbol application has any type of the form: appSymC :: InjectC expr (AST dom) x => expr (a :-> b :-> ... :-> Full x) -> (ASTF dom a -> ASTF dom b -> ... -> ASTF dom x)O`abcdefghijklmnopqrstuvwxyz{|}~%`abcdefghijklmnopqrstuvwxyz{|}~Oxwyzv{|turspqmnol}~jkhifgdebca`E`abcdefghijklmnopqrstuvwxyz{|}~prx None !"&*+-23468=BHJKMN-ary syntactic functions has any type of the form: 3desugarN :: ( Syntactic a , Syntactic b , ... , Syntactic x , Domain a ~ dom , Domain b ~ dom , ... , Domain x ~ dom ) => (a -> b -> ... -> x) -> ( ASTF dom (Internal a) -> ASTF dom (Internal b) -> ... -> ASTF dom (Internal x) )...and vice versa for .It is usually assumed that ( ( a)) has the same meaning as a.Syntactic type casting"Sugared" symbol application has any type of the form: sugarSym :: ( expr :<: AST dom , Syntactic a dom , Syntactic b dom , ... , Syntactic x dom ) => expr (Internal a :-> Internal b :-> ... :-> Full (Internal x)) -> (a -> b -> ... -> x)"Sugared" symbol application has any type of the form: sugarSymC :: ( InjectC expr (AST dom) (Internal x) , Syntactic a dom , Syntactic b dom , ... , Syntactic x dom ) => expr (Internal a :-> Internal b :-> ... :-> Full (Internal x)) -> (a -> b -> ... -> x) None !"&*+-23468=BHJKM~    !"#$%&'()*+,-./0123456789:;<=BCDEFGHIJKLMNQRSTUVWXYZ[\`abcdefghijklmnopqrstuvwxyz{|}~ None !"&*+-23468=BHJKM None !"&*+-23468=BHJKMNone !"&*+-23468=BHJKM .Decorating symbols with additional information One usage of M is to decorate every node of a syntax tree. This is done simply by changing  AST dom sigto AST (Decor info dom) sig(Get the decoration of the top-level node+Update the decoration of the top-level node[Lift a function that operates on expressions with associated information to operate on an D expression. This function is convenient to use together with e.g. queryNodeSimple when the domain has the form ( info dom).$Collect the decorations of all nodes#Rendering of decorated syntax trees-Show an decorated syntax tree using ASCII art.Print an decorated syntax tree using ASCII artStrip decorations from an  None !"&*+-23468=BHJKMIdentity functionNone !"&*+-23468=BHJKMNone !"&*+-23468=BHJKM#Projection with explicit monad type  None !"&*+-23468=BHJKM#Expressions for constructing tuples-Expressions for selecting elements of a tuple These families (  - 2) are needed because of the problem described in: Jhttp://emil-fp.blogspot.com/2011/08/fundeps-weaker-than-type-families.html$"Return the selected position, e.g. IselectPos (Sel3 poly :: Select Poly ((Int,Int,Int,Int) :-> Full Int)) = 3      !"   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~#$%/      $;####      "!%%%%$      !"   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~#$%None !"&*+-23468=BHJKM&'()*+,-./01233210/.-,+*)('&&'()*+,-./0123None !"&*+-23468=BHJKM48Type-level function computing the predicate attached to  or ( (whichever appears first) in a domain.4444None !"&*+-23468=BHJKM5Alpha-equivalence77Environments containing a list of variable equivalences:(Evaluation of expressions with variables< Let binding<L is just an application operator with flipped argument order. The argument (a -> b) is preferably constructed by >.>Lambda binding@ VariablesBVariable identifierFDAllow an existing binding to be used with a body of a different typeGKShould be a capture-avoiding substitution, but it is currently not correct.XNote: Variables with a different type than the new expression will be silently ignored.HRBeta-reduction of an expression. The expression to be reduced is assumed to be a >.I'Evaluation of possibly open expressionsJ Evaluation of closed expressionsK0Apply a symbol denotation to a list of argumentsL%Convenient default implementation of ;OuAlpha-equivalence on lambda expressions. Free variables are taken to be equivalent if they have the same identifier.|<> does strict identifier comparison; i.e. no alpha equivalence.= assigns the same hash to all >S bindings. This is a valid over-approximation that enables the following property: O a b ==> = a == = b<> does strict identifier comparison; i.e. no alpha equivalence.=q assigns the same hash to all variables. This is a valid over-approximation that enables the following property: O a b ==> = a == = bN56789:;<=>?@ABCDEFGVariable to be substitutedExpression to substitute forExpression to substitute inHArgumentFunction to be reducedIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~56789:;<=>?@ABCDEFGHIJKLMNOPQNBCDE@A~>?}|{zF<=yxwvuGH:;tIJKLsrqponmlkjihgfed789c56bMNOPQa`_^]\[ZYXWVUTSRE56789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None !"&*+-23468=BHJKMAn abstraction of >- with a constraint on the bound variable typeEquivalent to Q (including type constraints), but using a first-order representation of binding;Adding support for higher-order abstract syntax to a domainHigher-order lambda bindingiTranslating expressions with higher-order binding to corresponding expressions using first-order binding!Reify an n-ary syntactic function  <=@ @<= None !"&*+-23468=BHJKM+User interface to embedded monadic programs'One-layer desugaring of monadic actions%One-layer sugaring of monadic actionsNone !"&*+-23468=BHJKMBasic optimizationBottom-up optimization of an expression. The optimization performed is up to each instance, but the intention is to provide a sensible set of "always-appropriate" optimizations. The default implementation S does only constant folding. This constant folding uses the set of free variables to know when it's static evaluation is possible. Thus it is possible to help constant folding of other constructs by pruning away parts of the syntax tree that are known not to be needed. For example, by replacing (using ordinary Haskell as an example) if True then a else bwith a0, we don't need to report the free variables in bP. This, in turn, can lead to more constant folding higher up in the expression.Constant folderGiven an expression and the statically known value of that expression, returns a (possibly) new expression with the same meaning as the original. Typically, the result will be a 2, if the relevant type constraints are satisfied.Optimize an expression%Convenient default implementation of  (uses J to partially evaluate)None !"&*+-23468=BHJKMA sub-expression chosen to be shared together with an evidence that it can actually be shared in the whole expression under consideration&Environment for the expression in the  function1Whether the current expression is inside a lambdaGCounting the number of occurrences of an expression in the environmentLThe set of variables that are not allowed to occur in the chosen expression)A function that, if possible, returns an  for sharing a specific sub-expression. The first argument is the expression to be shared, and the second argument the expression in which it will be shared."This function makes the caller of [ responsible for making sure that the necessary type constraints are fulfilled (otherwise ~ is returned). It also makes it possible to transfer information, e.g. from the shared expression to the introduced variable.*Interface for injecting binding constructs+Interface for projecting binding constructsZSubstituting a sub-expression. Assumes no variable capturing in the expressions involved.3Count the number of occurrences of a sub-expressionHChecks whether a sub-expression in a given environment can be lifted out Choose a sub-expression to share?Perform common sub-expression elimination and variable hoistingA  implementation for Like A but with common sub-expression elimination and variable hoistingAn  implementation for The supplied function determines whether or not an expression can be shared by returning a witness that the type of the expression satisfies the predicate pVar.Sub-expression to be replacedReplacing sub-expressionWhole expressionExpression to countExpression to count inHControl wether a sub-expression can be hoisted over the given expressionNone !"&*+-23468=BCHJKM BA set of expressions used to keep track of gathered expression in |An occurence count and a union of scopes for a gathered expression. Used for the heuristic for when to share an expression.bA gathered sub-expression along with information used to decide where and if it should be shared.The gathered expression.The node id of the expression.,Variables that occur free in the expression.A list of nodes which the gathered expression occurs in, which it should not be hoisted out of, along with the number of times it occurs in it and the union of all the scopes where the variable occurs.Placeholder for a syntax tree. Similar to Node from Graph, but with the invariant that nodes with the same id are alpha-equivalent, given that they come from the same expression.8Note: Assumes the given lambda is not already in the mapConvert an expression to a graph representation where each set of alpha-equivalent sub-expressions share a node. Occurence counts for the sub-expressions, and other information is also recorded.Like A but with common sub-expression elimination and variable hoistingNHControl wether a sub-expression can be hoisted over the given expression8None !"&*+-23468=BHJKM%Pattern functor representation of an  with s"Abstract Syntax Graph"<A representation of a syntax tree with explicit sharing. An  is valid if and only if  succeeds (and the  field is correct).Top-level expression&Mapping from node id to sub-expressionTotal number of nodes!Environment for alpha-equivalencePlaceholder for a syntax treeNode identifier!Show syntax graph using ASCII art"Print syntax graph using ASCII art"Update the node identifiers in an ( using the supplied reindexing functionReindex the nodes according to the given index mapping. The number of nodes is unchanged, so if the index mapping is not 1:1, the resulting graph will contain duplicates.%Reindex the nodes to be in the range  [0 .. l-1], where l% is the number of nodes in the graphERemove duplicate nodes from a graph. The function only looks at the  of each node. The  field is updated accordingly.Folding over a graphThe user provides a function to fold a single constructor (an "algebra"). The result contains the result of folding the whole graph as well as the result of each internal node, represented both as an array and an association list. Each node is processed exactly once. Convert an  to an  by inlining all nodesOFind the child nodes of each node in an expression. The child nodes of a node n* are the first nodes along all paths from n.=Count the number of occurrences of each node in an expression$Inline all nodes that are not sharedRCompute a table (both array and list representation) of hash values for each nodelPartitions the nodes such that two nodes are in the same sub-list if and only if they are alpha-equivalent.<Common sub-expression elimination based on alpha-equivalence+#+None !"&*+-23468=BHJKMA hash table from  to  (with 8 as the hashing function). I.e. it is assumed that the Zs at each entry all have the same hash, and that this number is equal to the entry's key. of a  (c (Full a)) with hidden result typeLookup a name in the history Insert the name into the history/Return a fresh identifier from the given supplyNone !"&*+-23468=BHJKMShorthand used by FWrites out a list of encountered nodes and returns the top expression.3Convert a syntax tree to a sharing-preserving graph:This function is not referentially transparent (hence the ). However, it is well-behaved in the sense that the worst thing that could happen is that sharing is lost. It is not possible to get false sharing.:A function that decides whether a given node can be sharedNone !"&*+-23468=BHJKMShorthand used by FWrites out a list of encountered nodes and returns the top expression.3Convert a syntax tree to a sharing-preserving graphBReifying an n-ary syntactic function to a sharing-preserving graph:This function is not referentially transparent (hence the ). However, it is well-behaved in the sense that the worst thing that could happen is that sharing is lost. It is not possible to get false sharing.:A function that decides whether a given node can be shared !"#$%&''(()*+,-./01234567789:;<=>?@AABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijkl m n o p q r s t u v w x y z { | } ~ ~                                 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPPQQRRSSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~:;<=>?@ABCDEFG%syntactic-1.15 Language.Syntactic.Sharing.UtilsData.PolyProxyData.DynamicAltLanguage.Syntactic.SyntaxLanguage.Syntactic.Traversal*Language.Syntactic.Interpretation.Equality(Language.Syntactic.Interpretation.Render,Language.Syntactic.Interpretation.Evaluation+Language.Syntactic.Interpretation.SemanticsLanguage.Syntactic.ConstraintLanguage.Syntactic.Sugar'Language.Syntactic.Constructs.Condition'Language.Syntactic.Constructs.Construct(Language.Syntactic.Constructs.Decoration&Language.Syntactic.Constructs.Identity%Language.Syntactic.Constructs.Literal#Language.Syntactic.Constructs.Monad#Language.Syntactic.Constructs.Tuple!Language.Syntactic.Frontend.Tuple,Language.Syntactic.Frontend.TupleConstrained%Language.Syntactic.Constructs.Binding1Language.Syntactic.Constructs.Binding.HigherOrder!Language.Syntactic.Frontend.Monad.Language.Syntactic.Constructs.Binding.Optimize+Language.Syntactic.Sharing.SimpleCodeMotion&Language.Syntactic.Sharing.CodeMotion2 Language.Syntactic.Sharing.Graph%Language.Syntactic.Sharing.StableName Language.Syntactic.Sharing.Reify"Language.Syntactic.Sharing.ReifyHOLanguage.SyntacticDListemptysingle fromDListreindexcount fullPartitionPDynamictoDynfromDyn:<:injProjectprj:+:InjRInjL DenResultApplySymappSym':->PartialFullresultASTFAST:$SymsizeappSymsymTypeprjPWrapFull unwrapFullArgs:*NilgmapTgmapQ everywhereUpeverywhereDownlistArgsmapArgsmapArgsAmapArgsMappArgsmatchquery simpleMatchfold simpleFoldlistFold matchTranstoTreeEqualityequalexprHash$fEq:+: $fEquality:+:$fEqAST $fEqualityAST StringTree stringTreeSymRender renderSym renderArgsrender stringTreeshowASTdrawAST writeHtmlASTEvalevaluate Denotation $fEval:+: $fEvalASTSemantic semantics SemanticsSem semanticName semanticEval equalDefaultexprHashDefaultrenderSymDefaultrenderArgsDefaultevaluateDefaultsemanticInstances$fEvalSemantics$fRenderSemantics$fEqualitySemanticsEmptyASTSATASTBASTE SubConstr2 SubConstr1InjectCinjC ConstrainedBy ConstrainedSatexprDict:||C':|C:<subSubTop:/\:pTop pTypeableweakLweakR exprDictSub exprDictPlusappSymCliftASTE liftASTE2liftASTB liftASTB2universe$fStringTreeEmpty $fRenderEmpty $fEvalEmpty$fEqualityEmpty$fConstrainedEmpty$fEvalSubConstr2$fStringTreeSubConstr2$fRenderSubConstr2$fEqualitySubConstr2$fProjectsubSubConstr2$fConstrainedSubConstr2$fEvalSubConstr1$fStringTreeSubConstr1$fRenderSubConstr1$fEqualitySubConstr1$fProjectsubSubConstr1$fConstrainedSubConstr1$fInjectCexpr1:+:a$fInjectCexpr1:+:a0$fInjectCexprexpra$fInjectCsub:||a$fInjectCsub:|a$fInjectCsubASTa$fConstrained:||$fConstrained:|$fConstrained:+:$fConstrainedAST$fStringTree:|| $fEval:|| $fRender:|| $fEquality:||$fProjectsub:||$fStringTree:|$fEval:| $fRender:| $fEquality:|$fProjectsub:| $f:<:/\:q $f:<:/\:p$f:)(->)$fSyntacticNaia$fSyntacticAST Condition$fSemanticCondition$fConstrainedCondition$fEqualityCondition Construct$fSemanticConstruct$fConstrainedConstruct$fEqualityConstructDecor decorInfo decorExprgetInfo updateDecor liftDecor collectInfostringTreeDecor showDecorWith drawDecorWith stripDecor $fEvalDecor$fStringTreeDecor $fRenderDecor$fEqualityDecor$fProjectsubDecor$fConstrainedDecorIdentityId$fSemanticIdentity$fConstrainedIdentity$fEqualityIdentityLiteral $fEvalLiteral$fStringTreeLiteral$fRenderLiteral$fEqualityLiteral$fConstrainedLiteralMONADWhenThenBindReturnprjMonad$fStringTreeMONAD $fEvalMONAD $fRenderMONAD$fEqualityMONAD$fSemanticMONAD$fConstrainedMONADTupleTup15Tup14Tup13Tup12Tup11Tup10Tup9Tup8Tup7Tup6Tup5Tup4Tup3Tup2$fSemanticTuple$fConstrainedTupleSelectSel15Sel14Sel13Sel12Sel11Sel10Sel9Sel8Sel7Sel6Sel5Sel4Sel3Sel2Sel1Sel15'Sel14'Sel13'Sel12'Sel11'Sel10'Sel9'Sel8'Sel7'Sel6'Sel5'Sel4'Sel3'Sel2'Sel1'$fSemanticSelect$fConstrainedSelect$fEqualityTuple selectPos$fEqualitySelect$fSyntactic(,,,,,,,,,,,,,,)$fSyntactic(,,,,,,,,,,,,,)$fSyntactic(,,,,,,,,,,,,)$fSyntactic(,,,,,,,,,,,)$fSyntactic(,,,,,,,,,,)$fSyntactic(,,,,,,,,,)$fSyntactic(,,,,,,,,)$fSyntactic(,,,,,,,)$fSyntactic(,,,,,,)$fSyntactic(,,,,,)$fSyntactic(,,,,)$fSyntactic(,,,)$fSyntactic(,,)$fSyntactic(,)TupleSatAlphaEq alphaEqSymVarEqEnv prjVarEqEnv modVarEqEnvEvalBind evalBindSymLetLambdaVariableVarId varIntegershowVar reuseLambdasubst betaReduce evalBindMevalBindappDenevalBindSymDefaultalphaEqM alphaEqM2alphaEqalphaEqSymDefaultalphaEqChildren$fAlphaEqLambdaLambdadomenv$fAlphaEqVariableVariabledomenv$fAlphaEqMONADMONADdomenv$fAlphaEqDecorDecordomenv$fAlphaEqTupleTupledomenv$fAlphaEqSelectSelectdomenv$fAlphaEqLiteralLiteraldomenv$fAlphaEqLetLetdomenv$fAlphaEqIdentityIdentitydomenv!$fAlphaEqConstructConstructdomenv!$fAlphaEqConditionConditiondomenv$fAlphaEqEmptyEmptydomenv#$fAlphaEqSubConstr2SubConstr2domenv#$fAlphaEqSubConstr1SubConstr1domenv$fAlphaEq:||:||domenv$fAlphaEq:|:|domenv$fAlphaEq:+::+:domenv $fVarEqEnv[]$fEvalBindLambda$fEvalBindVariable$fEvalBindMONAD $fEvalBindLet$fEvalBindSelect$fEvalBindTuple$fEvalBindCondition$fEvalBindLiteral$fEvalBindConstruct$fEvalBindIdentity$fEvalBindDecor$fEvalBindEmpty$fEvalBindSubConstr2$fEvalBindSubConstr1 $fEvalBind:|| $fEvalBind:| $fEvalBind:+: $fEvalLet$fStringTreeLet $fRenderLet $fEqualityLet$fConstrainedLet$fStringTreeLambda$fRenderLambda$fEqualityLambda$fConstrainedLambda$fStringTreeVariable$fRenderVariable$fEqualityVariable$fConstrainedVariable $fShowVarId IsHODomainlambdaCLambdaFODomainHODomainHOLambdareifyMreifyTopreifyMonunMon desugarMonad sugarMonad$fSyntacticMon$fApplicativeMon $fMonadMon Optimize'Optimize optimizeSym ConstFolder optimizeMoptimizeoptimizeSymDefault$fOptimizeLambda$fOptimizeVariable$fOptimizeCondition $fOptimizeLet$fOptimizeSelect$fOptimizeTuple$fOptimizeLiteral$fOptimizeConstruct$fOptimizeIdentity$fOptimizeSubConstr2$fOptimizeSubConstr1$fOptimizeEmpty $fOptimize:|| $fOptimize:| $fOptimize:+: MkInjDictInjDict injVariable injLambdainjLetPrjDict prjVariable prjLambda codeMotion prjDictFO reifySmart mkInjDictFO codeMotion2 reifySmart2SyntaxPFDomPFNodePFAppPF NodeDomainASG topExpression graphNodesnumNodesNodeEnvEqEnv NodeEqEnv prjNodeEqEnv modNodeEqEnvNodeNodeId nodeIntegershowNodeshowASGdrawASGreindexNodesAST reindexNodesreindexNodesFrom0nubNodes foldGraph inlineAll nodeChildren occurrences inlineSingle hashNodespartitionNodescse$fFunctorSyntaxPF$fAlphaEqNodeNodedomenv $fVarEqEnv(,)$fNodeEqEnvdom(,)$fStringTreeNode $fRenderNode$fConstrainedNode $fShowNodeIdHistoryStNamehash lookHistoryrememberfresh $fEqStName reifyGraph reifyGraphTop $f:<:expr1:+:$f:<:expr1:+:0 $f:<:exprexpr $f:<:subAST$fProjectexpr1:+:$fProjectexpr1:+:0$fProjectexprexpr$fProjectsubASTTFCo:R:DenResult:->TFCo:R:DenResultFull$fApplySym:->(->)dom$fApplySymFullASTdom $fFunctorAST foldrArgscontainers-0.5.5.1 Data.TreeTreeWrapAST unWrapASTdata-hash-0.2.0.0Data.Hash.BaseHashbaseGHC.BaseString$fStringTree:+: $fShowAST $fRender:+:TFCo:R:Denotation:->TFCo:R:DenotationFullconstraints-0.4.1.3Data.ConstraintDictTFCo:R:Sel15'(,,,,,,,,,,,,,,)TFCo:R:Sel14'(,,,,,,,,,,,,,,)TFCo:R:Sel14'(,,,,,,,,,,,,,)TFCo:R:Sel13'(,,,,,,,,,,,,,,)TFCo:R:Sel13'(,,,,,,,,,,,,,)TFCo:R:Sel13'(,,,,,,,,,,,,)TFCo:R:Sel12'(,,,,,,,,,,,,,,)TFCo:R:Sel12'(,,,,,,,,,,,,,)TFCo:R:Sel12'(,,,,,,,,,,,,)TFCo:R:Sel12'(,,,,,,,,,,,)TFCo:R:Sel11'(,,,,,,,,,,,,,,)TFCo:R:Sel11'(,,,,,,,,,,,,,)TFCo:R:Sel11'(,,,,,,,,,,,,)TFCo:R:Sel11'(,,,,,,,,,,,)TFCo:R:Sel11'(,,,,,,,,,,)TFCo:R:Sel10'(,,,,,,,,,,,,,,)TFCo:R:Sel10'(,,,,,,,,,,,,,)TFCo:R:Sel10'(,,,,,,,,,,,,)TFCo:R:Sel10'(,,,,,,,,,,,)TFCo:R:Sel10'(,,,,,,,,,,)TFCo:R:Sel10'(,,,,,,,,,)TFCo:R:Sel9'(,,,,,,,,,,,,,,)TFCo:R:Sel9'(,,,,,,,,,,,,,)TFCo:R:Sel9'(,,,,,,,,,,,,)TFCo:R:Sel9'(,,,,,,,,,,,)TFCo:R:Sel9'(,,,,,,,,,,)TFCo:R:Sel9'(,,,,,,,,,)TFCo:R:Sel9'(,,,,,,,,)TFCo:R:Sel8'(,,,,,,,,,,,,,,)TFCo:R:Sel8'(,,,,,,,,,,,,,)TFCo:R:Sel8'(,,,,,,,,,,,,)TFCo:R:Sel8'(,,,,,,,,,,,)TFCo:R:Sel8'(,,,,,,,,,,)TFCo:R:Sel8'(,,,,,,,,,)TFCo:R:Sel8'(,,,,,,,,)TFCo:R:Sel8'(,,,,,,,)TFCo:R:Sel7'(,,,,,,,,,,,,,,)TFCo:R:Sel7'(,,,,,,,,,,,,,)TFCo:R:Sel7'(,,,,,,,,,,,,)TFCo:R:Sel7'(,,,,,,,,,,,)TFCo:R:Sel7'(,,,,,,,,,,)TFCo:R:Sel7'(,,,,,,,,,)TFCo:R:Sel7'(,,,,,,,,)TFCo:R:Sel7'(,,,,,,,)TFCo:R:Sel7'(,,,,,,)TFCo:R:Sel6'(,,,,,,,,,,,,,,)TFCo:R:Sel6'(,,,,,,,,,,,,,)TFCo:R:Sel6'(,,,,,,,,,,,,)TFCo:R:Sel6'(,,,,,,,,,,,)TFCo:R:Sel6'(,,,,,,,,,,)TFCo:R:Sel6'(,,,,,,,,,)TFCo:R:Sel6'(,,,,,,,,)TFCo:R:Sel6'(,,,,,,,)TFCo:R:Sel6'(,,,,,,)TFCo:R:Sel6'(,,,,,)TFCo:R:Sel5'(,,,,,,,,,,,,,,)TFCo:R:Sel5'(,,,,,,,,,,,,,)TFCo:R:Sel5'(,,,,,,,,,,,,)TFCo:R:Sel5'(,,,,,,,,,,,)TFCo:R:Sel5'(,,,,,,,,,,)TFCo:R:Sel5'(,,,,,,,,,)TFCo:R:Sel5'(,,,,,,,,)TFCo:R:Sel5'(,,,,,,,)TFCo:R:Sel5'(,,,,,,)TFCo:R:Sel5'(,,,,,)TFCo:R:Sel5'(,,,,)TFCo:R:Sel4'(,,,,,,,,,,,,,,)TFCo:R:Sel4'(,,,,,,,,,,,,,)TFCo:R:Sel4'(,,,,,,,,,,,,)TFCo:R:Sel4'(,,,,,,,,,,,)TFCo:R:Sel4'(,,,,,,,,,,)TFCo:R:Sel4'(,,,,,,,,,)TFCo:R:Sel4'(,,,,,,,,)TFCo:R:Sel4'(,,,,,,,)TFCo:R:Sel4'(,,,,,,)TFCo:R:Sel4'(,,,,,)TFCo:R:Sel4'(,,,,)TFCo:R:Sel4'(,,,)TFCo:R:Sel3'(,,,,,,,,,,,,,,)TFCo:R:Sel3'(,,,,,,,,,,,,,)TFCo:R:Sel3'(,,,,,,,,,,,,)TFCo:R:Sel3'(,,,,,,,,,,,)TFCo:R:Sel3'(,,,,,,,,,,)TFCo:R:Sel3'(,,,,,,,,,)TFCo:R:Sel3'(,,,,,,,,)TFCo:R:Sel3'(,,,,,,,)TFCo:R:Sel3'(,,,,,,)TFCo:R:Sel3'(,,,,,)TFCo:R:Sel3'(,,,,)TFCo:R:Sel3'(,,,)TFCo:R:Sel3'(,,)TFCo:R:Sel2'(,,,,,,,,,,,,,,)TFCo:R:Sel2'(,,,,,,,,,,,,,)TFCo:R:Sel2'(,,,,,,,,,,,,)TFCo:R:Sel2'(,,,,,,,,,,,)TFCo:R:Sel2'(,,,,,,,,,,)TFCo:R:Sel2'(,,,,,,,,,)TFCo:R:Sel2'(,,,,,,,,)TFCo:R:Sel2'(,,,,,,,)TFCo:R:Sel2'(,,,,,,)TFCo:R:Sel2'(,,,,,)TFCo:R:Sel2'(,,,,)TFCo:R:Sel2'(,,,)TFCo:R:Sel2'(,,)TFCo:R:Sel2'(,)TFCo:R:Sel1'(,,,,,,,,,,,,,,)TFCo:R:Sel1'(,,,,,,,,,,,,,)TFCo:R:Sel1'(,,,,,,,,,,,,)TFCo:R:Sel1'(,,,,,,,,,,,)TFCo:R:Sel1'(,,,,,,,,,,)TFCo:R:Sel1'(,,,,,,,,,)TFCo:R:Sel1'(,,,,,,,,)TFCo:R:Sel1'(,,,,,,,)TFCo:R:Sel1'(,,,,,,)TFCo:R:Sel1'(,,,,,)TFCo:R:Sel1'(,,,,)TFCo:R:Sel1'(,,,)TFCo:R:Sel1'(,,)TFCo:R:Sel1'(,) sugarSymC'$fTupleSat:+:p$fTupleSat:||p $fTupleSat:|p$fTupleSat:+:p0$fTupleSat:||p0$fTupleSat:+:p1$fTupleSat:||p1$fSyntactic(->)$fIsHODomain:||ppVarChosenEnvchooseinLambdacounter dependencies Data.MaybeNothing substituteliftable independent isVariable GatherSetgather GatherInfoGatheredgeExprgeNodeId geFreeVarsgeInfoinsertLT LambdaTable GatherMonad LambdaInfoliExprliLambdaNodeId liFreeVars GatherState gatherSet nodeCounter lambdaTable additionals Additional GatherEnv ShareInfo RebuildMonad RebuildEnvHashySet unHashySetgiCountgiScopestypeEq lookupWithHS updateWithHSemptyHStoListHSlookupGSupdateGSemptyGStoListGS runRebuild addBoundVar getBoundVars addNodeExprgetNodeExprMap addSeenNode getSeenNodesrebuild runGatherlookupLT getInnerLimitgetScopegetLambdaTableputLambdaTable addInnerLimit addScopeVar mergeInfos updateInfo lambdaHashes$fEqualityNodeSystem.Mem.StableName StableName GraphMonad reifyGraphMghc-prim GHC.TypesIO