pPFA      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJK L M N O P Q 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:;<=>?@NoneDifference list  Empty list Singleton list  Given a list is9 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). KCount the number of occurrences of each element in the list. The result is = an array mapping each element to its number of occurrences. KPartitions the list such that two elements are in the same sub-list if and G only if they satisfy the equivalence check. The complexity is O(n^2). 4Upper and lower bound on the elements to be counted Elements to be counted NoneKind-polymorphic proxy type None     None Symbol subsumption Injection from sub to sup Symbol projection Partial projection from sup to sub !Direct sum of two symbol domains 5The result type of a symbol with the given signature -Class for the type-level recursion needed by ! 7Signature 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) 8 -> (ASTF dom a -> ASTF dom b -> ... -> ASTF dom x) "&Constrain a symbol to a specific type #%Projection to a specific symbol type "  !"#ABCDEFGHIJK  !"#  !"#  !"#ABCDEFGHIJKNone$=Can be used to make an arbitrary type constructor indexed by ( a). 5 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 *IMap a function over all immediate sub-terms (corresponds to the function / with the same name in Scrap Your Boilerplate) +IMap a function over all immediate sub-terms, collecting the results in a D list (corresponds to the function with the same name in Scrap Your  Boilerplate) ,DApply a transformation bottom-up over an expression (corresponds to   everywhere in Scrap Your Boilerplate) -CApply a transformation top-down over an expression (corresponds to   everywhere' in Scrap Your Boilerplate) .Map a function over an '- list and collect the results in an ordinary  list /Map a function over an ' list 0$Map an applicative function over an ' list 1Map a monadic function over an ' list LRight fold for an ' list 2?Apply a (partially applied) symbol to a list of argument terms 3" Pattern match" on an - using a function that gets direct access to ' the top-most symbol and its sub-trees 5 A version of 3 with a simpler result type 6Fold an  using an '' list to hold the results of sub-terms 7Simplified version of 6/ for situations where all intermediate results  have the same type 8Fold an / using a list to hold the results of sub-terms 9 A version of 30 where the result is a transformed syntax tree,  wrapped in a type constructor c : Convert an  to a M $%&NOP'()*+,-./01L23456789:$%&'()*+,-./0123456789:+*,-')(./0128345679$%&:$%&NOP')(*+,-./01L23456789:None;Equality for expressions <Equality for expressions FComparing expressions of different types is often needed when dealing ; with expressions with existentially quantified sub-terms. = Computes a Q/ for an expression. Expressions that are equal  according to < must result in the same hash: (equal a b ==> exprHash a == exprHash b;<=RSTU;<=;<=;<=RSTUNone >Convert a symbol to a M of strings ?Convert a symbol to a M given a list of argument trees @QRender a symbol as concrete syntax. A complete instance must define at least the A  method. AShow a symbol as a V B3Render a symbol given a list of rendered arguments C(Render an expression as concrete syntax DConvert an expression to a M of strings E#Show a syntax tree using ASCII art F$Print a syntax tree using ASCII art >?@ABCDEFGWXY >?@ABCDEFG @ABC>?DEFG >?@ABCDEFGWXYNoneIEvaluation of expressions J4The denotation of a symbol with the given signature HIJZ[HIJJHIHIJZ[ NoneK7Class of expressions that can be treated as constructs M/A representation of a syntactic construct as a V and an evaluation B function. It is not meant to be used as a syntactic symbol in an . Its J only purpose is to provide the default implementations of functions like  < via the K class. QDefault implementation of < RDefault implementation of = SDefault implementation of A TDefault implementation of B UDefault implementation of I VDerive instances for K related classes  (;, @, >, H) KLMNOPQRSTUV\]^ KLMNOPQRSTUV MNOPKLQRSTUV KLMNOPQRSTUV\]^ NoneWEmpty symbol type  Use-case:   data A a  data B a  * test :: AST (A :+: (B:||Eq) :+: Empty) a ) test = injC (undefined :: (B :|| Eq) a) Without WH, 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) a Y3 with bounded existentially quantified result type [+ with existentially quantified result type ] Similar to _(, but assumes a result type of the form c a b and constrains both a  and b. _ Similar to gJ, but rather than constraining the whole result type, it assumes a result  type of the form c a and constrains the a. aSymbol injection (like   ) with constrained result types d.Expressions that constrain their result types e@Returns a predicate that is satisfied by the result type of all $ expressions of the given type (see f). f9Compute a constraint on the result type of an expression gCConstrain the result type of the expression by the given predicate The difference between g and i! is seen in the instances of the e  type: - type Sat (dom :| pred) = pred :/\: Sat dom  type Sat (dom :|| pred) = pred iCConstrain the result type of the expression by the given predicate k#Subset relation on type predicates lCompute evidence that sub is a subset of sup (i.e. that (sup a)  implies (sub a)) mEvidence that the predicate sub is a subset of sup nUniversal type predicate o Intersection of type predicates rWeaken an intersection sWeaken an intersection t A version of f, that returns a constraint for a particular  predicate p as long as (p :< Sat dom) holds u A version of f$ that works for domains of the form  (dom1 :+: dom2) as long as (Sat dom1 ~ Sat dom2) holds vGeneric symbol application v has any type of the form: % appSymC :: InjectC expr (AST dom) x * => expr (a :-> b :-> ... :-> Full x) 8 -> (ASTF dom a -> ASTF dom b -> ... -> ASTF dom x) OWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{_`abcdefghijklmnopqrstuvwxyz{|}~%WXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{%onpqmrsklijghdefctuabv_`]^[\wxYZyzXW{EWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{_`abcdefghijklmnopqrstuvwxyz{|}~ None|N-ary syntactic functions } has any type of the form:   desugarN ::  ( 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 I ) => 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 I ) => expr (Internal a :-> Internal b :-> ... :-> Full (Internal x))  -> (a -> b -> ... -> x) |}~ |}~ |}~|}~None~  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ None NoneNone /Decorating symbols with additional information  One usage of : is to decorate every node of a syntax tree. This is done  simply by changing   AST dom sig to  AST (Decor info dom) sig )Get the decoration of the top-level node ,Update the decoration of the top-level node LLift a function that operates on expressions with associated information to  operate on an 9 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 art Strip decorations from an   NoneIdentity function NoneNone$Projection with explicit monad type None$Expressions for constructing tuples .Expressions for selecting elements of a tuple These families ( - $) 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. K selectPos (Sel3 poly :: Select Poly ((Int,Int,Int,Int) :-> Full Int)) = 3 5//NoneNone8Type-level function computing the predicate attached to  or  ( (whichever appears first) in a domain. NoneAlpha-equivalence 8Environments containing a list of variable equivalences )Evaluation of expressions with variables  Let binding K is just an application operator with flipped argument order. The argument  (a -> b) is preferably constructed by . Lambda binding  Variables Variable identifier EAllow an existing binding to be used with a body of a different type LShould be a capture-avoiding substitution, but it is currently not correct. FNote: Variables with a different type than the new expression will be  silently ignored. LBeta-reduction of an expression. The expression to be reduced is assumed to  be a . (Evaluation of possibly open expressions !Evaluation of closed expressions 1Apply a symbol denotation to a list of arguments %Convenient default implementation of  HAlpha-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  bindings. This is a valid 9 over-approximation that enables the following property:  a b ==> = a == = b<? does strict identifier comparison; i.e. no alpha equivalence. =9 assigns the same hash to all variables. This is a valid 9 over-approximation that enables the following property:  a b ==> = a == = bNVariable to be substituted Expression to substitute for Expression to substitute in  Argument Function to be reduced ENoneAn abstraction of  . with a constraint on the bound variable type Equivalent to F (including type constraints), but using a first-order representation  of binding <Adding support for higher-order abstract syntax to a domain Higher-order lambda binding CTranslating expressions with higher-order binding to corresponding ' expressions using first-order binding "Reify an n-ary syntactic function  None,User interface to embedded monadic programs (One-layer desugaring of monadic actions &One-layer sugaring of monadic actions NoneBasic optimization GBottom-up optimization of an expression. The optimization performed is H up to each instance, but the intention is to provide a sensible set of  "always-appropriate"+ optimizations. The default implementation  3 does only constant folding. This constant folding / uses the set of free variables to know when it's static evaluation is A possible. Thus it is possible to help constant folding of other K constructs by pruning away parts of the syntax tree that are known not to D be needed. For example, by replacing (using ordinary Haskell as an  example)   if True then a else b with a, we don''t need to report the free variables in b . This, in F turn, can lead to more constant folding higher up in the expression. Constant folder GGiven an expression and the statically known value of that expression, L returns a (possibly) new expression with the same meaning as the original. ! Typically, the result will be a #, if the relevant type constraints  are satisfied. Optimize an expression %Convenient default implementation of  (uses  to  partially evaluate)           None^A 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  function 2Whether the current expression is inside a lambda ;Counting the number of occurrences of an expression in the  environment AThe 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 c 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 0 responsible for making sure that the necessary + type constraints are fulfilled (otherwise , is returned). It also makes it possible to S transfer information, e.g. from the shared expression to the introduced variable. +Interface for injecting binding constructs  ,Interface for projecting binding constructs DSubstituting a sub-expression. Assumes no variable capturing in the  expressions involved. 4Count the number of occurrences of a sub-expression  IChecks 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 hoisting A   implementation for  Like B but with common sub-expression elimination and variable hoisting An  implementation for  [The supplied function determines whether or not an expression can be shared by returning a A witness that the type of the expression satisfies the predicate pVar. !"     Sub-expression to be replaced Replacing sub-expression Whole expression Expression to count Expression to count in #$ IControl wether a sub-expression can be hoisted over the given expression           !"     #$ None %BA set of expressions used to keep track of gathered expression in & 'IAn occurence count and a union of scopes for a gathered expression. Used 4 for the heuristic for when to share an expression. (JA 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. ,BA list of nodes which the gathered expression occurs in, which it H should not be hoisted out of, along with the number of times it occurs B in it and the union of all the scopes where the variable occurs. -HPlaceholder for a syntax tree. Similar to Node from Graph, but with the M invariant that nodes with the same id are alpha-equivalent, given that they  come from the same expression. .9Note: Assumes the given lambda is not already in the map &BConvert an expression to a graph representation where each set of I alpha-equivalent sub-expressions share a node. Occurence counts for the : sub-expressions, and other information is also recorded. Like B but with common sub-expression elimination and variable hoisting N/0123456789:;<=>?@%ABC'DEF(G)*+,H-IJKLMNOPQRSTUVWXYZ[\]^IControl wether a sub-expression can be hoisted over the given expression _`ab.cdefgh&ijklmnop8/0123456789:;<=>?@%ABC'DEF(G)*+,H-IJKLMNOPQRSTUVWXYZ[\]^_`ab.cdefgh&ijklmnopNone%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 0 succeeds (and the  field is correct). Top-level expression 'Mapping from node id to sub-expression Total number of nodes  "Environment for alpha-equivalence #Placeholder for a syntax tree %Node identifier )"Show syntax graph using ASCII art *#Print syntax graph using ASCII art +"Update the node identifiers in an  using the supplied reindexing  function ,LReindex the nodes according to the given index mapping. The number of nodes L 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 graph .DRemove duplicate nodes from a graph. The function only looks at the  % of each node. The  field is updated accordingly. /Folding over a graph >The user provides a function to fold a single constructor (an "algebra"). J The result contains the result of folding the whole graph as well as the O result of each internal node, represented both as an array and an association , list. Each node is processed exactly once. 0 Convert an  to an  by inlining all nodes 1IFind 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. 2>Count the number of occurrences of each node in an expression 3%Inline all nodes that are not shared 4HCompute a table (both array and list representation) of hash values for  each node 5IPartitions the nodes such that two nodes are in the same sub-list if and $ only if they are alpha-equivalent. 6=Common sub-expression elimination based on alpha-equivalence + !"#$%&'()*+,-./0123456qrstuvwx# !"#$%&'()*+,-./0123456#%&'(#$ !")*+,-./0123456 !"#$%&'()*+,-./0123456qrstuvwxNone7A hash table from 8 to % (with : as the hashing ( function). I.e. it is assumed that the 8s at each entry all have the 6 same hash, and that this number is equal to the entry's key. 8y of a  (c (Full a)) with hidden result type ;Lookup a name in the history <!Insert the name into the history =0Return a fresh identifier from the given supply 789:;<=z789:;<=89:7;<=789:;<=zNone{Shorthand used by | GWrites out a list of encountered nodes and returns the top expression. >4Convert a syntax tree to a sharing-preserving graph :This function is not referentially transparent (hence the }). However, it M 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 >>{|>None~Shorthand used by  GWrites out a list of encountered nodes and returns the top expression. ?4Convert a syntax tree to a sharing-preserving graph @CReifying an n-ary syntactic function to a sharing-preserving graph :This function is not referentially transparent (hence the }). However, it M 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[\]^_`abcdef g h i j k l m n o p q r s t u u v v w w x x y z { | } ~                      !"#$%%&'()*+,-..//0123456789:;<=>?@AABCDEFGFHIJKLMNOPQRSTUVWWXYZ[\]^_`abcdefg h i j k l m n o p q r s t u v w x y z { | } ~                                    `% !"#$%&'().*+,--./01123456789:;;<$=>%$.//0?!1@ABCDEFGHIJKLMNO9PQRSTUVWXYZ[\]^_`^abc[]_`defghijkghlsyntactic-1.14 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.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.Syntactic!Language.Syntactic.Frontend.TupleDListemptysingle fromDListreindexcount fullPartitionPDynamictoDynfromDyn:<:injProjectprj:+:InjRInjL DenResultApplySymappSym':->PartialFullresultASTFAST:$SymsizeappSymsymTypeprjPWrapFull unwrapFullArgs:*NilgmapTgmapQ everywhereUpeverywhereDownlistArgsmapArgsmapArgsAmapArgsMappArgsmatchquery simpleMatchfold simpleFoldlistFold matchTranstoTreeEqualityequalexprHash StringTree stringTreeSymRender renderSym renderArgsrender stringTreeshowASTdrawAST writeHtmlASTEvalevaluate DenotationSemantic semantics SemanticsSem semanticName semanticEval equalDefaultexprHashDefaultrenderSymDefaultrenderArgsDefaultevaluateDefaultsemanticInstancesEmptyASTSATASTBASTE SubConstr2 SubConstr1InjectCinjC ConstrainedBy ConstrainedSatexprDict:||C':|C:<subSubTop:/\:pTop pTypeableweakLweakR exprDictSub exprDictPlusappSymCliftASTE liftASTE2liftASTB liftASTB2universe SyntacticNdesugarNsugarN SyntacticDomainInternaldesugarsugarresugarsugarSym sugarSymC Condition ConstructDecor decorInfo decorExprgetInfo updateDecor liftDecor collectInfostringTreeDecor showDecorWith drawDecorWith stripDecorIdentityIdLiteralMONADWhenThenBindReturnprjMonadTupleTup15Tup14Tup13Tup12Tup11Tup10Tup9Tup8Tup7Tup6Tup5Tup4Tup3Tup2SelectSel15Sel14Sel13Sel12Sel11Sel10Sel9Sel8Sel7Sel6Sel5Sel4Sel3Sel2Sel1Sel15'Sel14'Sel13'Sel12'Sel11'Sel10'Sel9'Sel8'Sel7'Sel6'Sel5'Sel4'Sel3'Sel2'Sel1' selectPosTupleSatAlphaEq alphaEqSymVarEqEnv prjVarEqEnv modVarEqEnvEvalBind evalBindSymLetLambdaVariableVarId varIntegershowVar reuseLambdasubst betaReduce evalBindMevalBindappDenevalBindSymDefaultalphaEqM alphaEqM2alphaEqalphaEqSymDefaultalphaEqChildren IsHODomainlambdaCLambdaFODomainHODomainHOLambdareifyMreifyTopreifyMonunMon desugarMonad sugarMonad Optimize'Optimize optimizeSym ConstFolder optimizeMoptimizeoptimizeSymDefault MkInjDictInjDict injVariable injLambdainjLetPrjDict prjVariable prjLambda codeMotion prjDictFO reifySmart mkInjDictFO codeMotion2 reifySmart2SyntaxPFDomPFNodePFAppPF NodeDomainASG topExpression graphNodesnumNodesNodeEnvEqEnv NodeEqEnv prjNodeEqEnv modNodeEqEnvNodeNodeId nodeIntegershowNodeshowASGdrawASGreindexNodesAST reindexNodesreindexNodesFrom0nubNodes foldGraph inlineAll nodeChildren occurrences inlineSingle hashNodespartitionNodescseHistoryStNamehash lookHistoryrememberfresh reifyGraph reifyGraphTop $f:<:expr1:+:$f:<:expr1:+:0 $f:<:exprexpr $f:<:subAST$fProjectexpr1:+:$fProjectexpr1:+:0$fProjectexprexpr$fProjectsubAST$fApplySym:->(->)dom$fApplySymFullASTdom $fFunctorAST foldrArgscontainers-0.5.0.0 Data.TreeTreeWrapAST unWrapASTdata-hash-0.2.0.0Data.Hash.BaseHash$fEq:+: $fEquality:+:$fEqAST $fEqualityASTbaseGHC.BaseString$fStringTree:+: $fShowAST $fRender:+: $fEval:+: $fEvalAST$fEvalSemantics$fRenderSemantics$fEqualitySemantics$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$fSyntacticASTconstraints-0.4Data.ConstraintDict$fSemanticCondition$fConstrainedCondition$fEqualityCondition$fSemanticConstruct$fConstrainedConstruct$fEqualityConstruct $fEvalDecor$fStringTreeDecor $fRenderDecor$fEqualityDecor$fProjectsubDecor$fConstrainedDecor$fSemanticIdentity$fConstrainedIdentity$fEqualityIdentity $fEvalLiteral$fStringTreeLiteral$fRenderLiteral$fEqualityLiteral$fConstrainedLiteral$fStringTreeMONAD $fEvalMONAD $fRenderMONAD$fEqualityMONAD$fSemanticMONAD$fConstrainedMONAD$fSemanticTuple$fConstrainedTuple$fSemanticSelect$fConstrainedSelect$fEqualityTuple$fEqualitySelect$fSyntactic(,,,,,,,,,,,,,,)$fSyntactic(,,,,,,,,,,,,,)$fSyntactic(,,,,,,,,,,,,)$fSyntactic(,,,,,,,,,,,)$fSyntactic(,,,,,,,,,,)$fSyntactic(,,,,,,,,,)$fSyntactic(,,,,,,,,)$fSyntactic(,,,,,,,)$fSyntactic(,,,,,,)$fSyntactic(,,,,,)$fSyntactic(,,,,)$fSyntactic(,,,)$fSyntactic(,,)$fSyntactic(,) sugarSymC'$fTupleSat:+:p$fTupleSat:||p $fTupleSat:|p$fTupleSat:+:p0$fTupleSat:||p0$fTupleSat:+:p1$fTupleSat:||p1$fEqualityLambda$fEqualityVariable$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$fConstrainedLambda$fStringTreeVariable$fRenderVariable$fConstrainedVariable $fShowVarId$fSyntactic(->)$fIsHODomain:||ppVar$fSyntacticMon$fApplicativeMon $fMonadMon$fOptimizeLambda$fOptimizeVariable$fOptimizeCondition $fOptimizeLet$fOptimizeSelect$fOptimizeTuple$fOptimizeLiteral$fOptimizeConstruct$fOptimizeIdentity$fOptimizeSubConstr2$fOptimizeSubConstr1$fOptimizeEmpty $fOptimize:|| $fOptimize:| $fOptimize:+:ChosenEnvchooseinLambdacounter 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 $fRenderNode$fEqualityNode$fConstrainedNode$fAlphaEqNodeNodedomenv $fShowNodeId$fFunctorSyntaxPF $fVarEqEnv(,)$fNodeEqEnvdom(,)$fStringTreeNodeSystem.Mem.StableName StableName $fEqStName GraphMonad reifyGraphMghc-prim GHC.TypesIO