uPn,~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOP 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 { | } +N-ary syntactic functions  has any type of the form:   desugarN ::  ( Syntactic a dom  , Syntactic b dom  , ...  , Syntactic x dom  ) => (a -> b -> ... -> x) ) -> ( AST dom (Full (Internal a)) ) -> AST dom (Full (Internal b))  -> ... ) -> AST dom (Full (Internal x))  ) ...and vice versa for . !It is assumed that for all types A fulfilling ( A dom):  5 eval a == eval (desugar $ (id :: A -> A) $ sugar a) (using +Language.Syntactic.Analysis.Evaluation.eval) Injection from sub to sup Partial projection from sup to sub !Co-product of two symbol domains #Fully applied abstract syntax tree ?Generic abstract syntax tree, parameterized by a symbol domain  In general, ( dom (a  b))$ represents a partially applied (or > unapplied) constructor, missing at least one argument, while  ( dom ( a))0 represents a fully applied constructor, i.e. a  complete syntax tree. 7 It is not possible to construct a total value of type ( dom a) that ! does not fulfill the constraint ( a). Note that the hidden class ~ mentioned in the type of  is  interchangeable with . Returns the result type ( removed) of a . This is a public  alias for the hidden type . Maps a  to a simpler form where  has been replaced by ->,  and > has been removed. This is a public alias for the hidden type  . 'Fully or partially applied constructor ,This is a public alias for the hidden class ~. The only instances  are:  instance ConsType' (Full a) - instance ConsType' b => ConsType' (a :-> b) ~'Fully or partially applied constructor IThis class is private to the module to guarantee that all members of the  class have the form:   Full a  a1 :-> Full a2  a1 :-> a2 :-> ... :-> Full an (The closed class also has the property:  ConsType' (a :-> b) iff. ConsType' b. 6Heterogeneous list, indexed by a container type and a  ;The type of a partially applied (or unapplied) constructor (The type of a fully applied constructor %Make a constructor evaluation from a  representation .Convert a heterogeneous list to a normal list .Convert a heterogeneous list to a normal list =Change the container of each element in a heterogeneous list !Semantic constructor application Syntactic type casting ! Query an : using a function that gets direct access to the top-most  constructor and its sub-trees $This function can be used to create $ traversal functions indexed by the  symbol types, for example:   class Count subDomain  where J count' :: Count domain => subDomain a -> HList (AST domain) a -> Int  < instance (Count sub1, Count sub2) => Count (sub1 :+: sub2)  where - count' (InjectL a) args = count' a args - count' (InjectR a) args = count' a args  ) count :: Count dom => ASTF dom a -> Int  count = queryNode count' Here, count' represents some static analysis on an . Each constructor  in the tree will be queried by count'% indexed by the corresponding symbol  type. That way, count'2 can be seen as an open-ended function on an open  data type. The (Count domain) constraint on count' is to allow recursion  over sub-trees. Let's say we have a symbol   data Add a  where + Add :: Add (Int :-> Int :-> Full Int)  Then the Count instance for Add might look as follows:  instance Count Add  where : count' Add (a :*: b :*: Nil) = 1 + count a + count b " Transform an : using a function that gets direct access to the top-most < constructor and its sub-trees. This function is similar to !, but  returns a transformed & rather than abstract interpretation. %  !"#   !"#    !"#1Equality for expressions. The difference between  and # is that  #D allows comparison of expressions with different value types. It is M assumed that when the types differ, the expressions also differ. The reason L for allowing comparison of different types is that this is convenient when ) the types are existentially quantified. $%#$%#$%#$$% &'FConvert a partially applied constructor to a syntax tree given a list  of rendered missing arguments (IRender an expression as concrete syntax. A complete instance must define  either of the methods ) and *. )Render an expression as a  *HRender a partially applied constructor given a list of rendered missing  arguments +Print an expression 'Convert an expression to a syntax tree ,!Show syntax tree using ASCII art -"Print syntax tree using ASCII art &'()*+,-()*+&',-&''()*)*+,-./Evaluation of expressions 01./01./01.//0123 Computes a / for an expression. Expressions that are equal  according to $ must result in the same hash. 2323233455Annotating an expression with arbitrary information. KThis can be used to annotate every node of a syntax tree, which is done by  changing   AST dom a to   AST (Ann info dom) a  Injection/.projection of an annotated tree is done using  9 / :. 6789:;456789:;567849:;456786789:; >  !"#$%&'()*+,-./0123456789:;<=>Literal ?Annotated literal <=>?<=>?<==>?@@Class of expressions that can be treated as primitive functions ABCDEFGHIJKLDefault implementation of $ MDefault implementation of * NDefault implementation of / ODefault implementation of 3 @ABCDEFGHIJKLMNOBCDEFGHIJK@ALMNO@AABCCDEFGHIJKLMNO PQRConditional expression PQRPQRPQQR S.Expressions for selecting elements of a tuple TUVWXYZ[$Expressions for constructing tuples \]^_`ab#Return the selected position, e.g. ; selectPos (Sel3 :: Select ((Int,Int,Int,Int) -> Int)) = 3 STUVWXYZ[\]^_`ab[a`_^]\SZYXWVUTbSZYXWVUTTUVWXYZ[a`_^]\\]^_`ab c Let binding de%The class of n-ary binding functions fg3N-ary binding by nested use of the supplied binder hLambda binding ij Variables klVariable identifier mnopAlpha-equivalence on ih- expressions. Free variables are taken to be - equvalent if they have the same identifier. qrEvaluation of possibly open  LambdaAST expressions sEvaluation of closed ih expressions cdefghijklmnopqrslmnojkhipqrsefgcdcddefgfghiijkklmnmnopqrs t5Convenient class alias for n-ary syntactic functions uvHigher-order lambda binding wxLambda binding yN-ary lambda binding z Let binding {|CTranslating expressions with higher-order binding to corresponding ' expressions using first-order binding }%Reifying an n-ary syntactic function cdjstuvwxyz{|}jscdvwuxyz{|t} tuvwwxyz{|} !"#$%&&'()*+,-./0123456789:;<=>?@ABCCDEFGHIIJKLMNNOPQRSTUVWXYZ [ [ \ ] ^ _ ` a b c d e f g h i j k l m m n o p q q r r s s t u v w x y z { | | } ~   syntactic-0.3Language.Syntactic.Syntax$Language.Syntactic.Analysis.Equality"Language.Syntactic.Analysis.Render&Language.Syntactic.Analysis.Evaluation Language.Syntactic.Analysis.Hash$Language.Syntactic.Features.Annotate#Language.Syntactic.Features.Literal$Language.Syntactic.Features.PrimFunc%Language.Syntactic.Features.Condition!Language.Syntactic.Features.Tuple#Language.Syntactic.Features.Binding/Language.Syntactic.Features.Binding.HigherOrderLanguage.Syntactic*Language.Syntactic.Features.TupleSyntactic SyntacticNdesugarNsugarN SyntacticInternaldesugarsugar:<:injectproject:+:InjectRInjectLASTFAST:$:Symbol EvalResultConsEvalConsTypeHList:->PartialFullresultfromEvaltoEval listHList listHListMmapHList$:resugar queryNode transformNodeExprEqexprEqeqSynToTree toTreePartRenderrender renderPart printExprshowASTdrawASTEvalevaluateevalFullevalSynExprHashexprHashAnnSTFAnnannInfoannExpr injectAnn projectAnngetInfoLiterallitlitAnn IsFunction toFunctionPrimFunc primFunc1 primFunc2 primFunc3 primFunc4 primFuncAnn1 primFuncAnn2 primFuncAnn3 primFuncAnn4 exprEqFuncrenderPartFunc evaluateFunc exprHashFunc Condition conditionSelectSel7Sel6Sel5Sel4Sel3Sel2Sel1TupleTup7Tup6Tup5Tup4Tup3Tup2 selectPosLetNAryNAryEvalbindNLambdaVariableVarId varIntegershowVar eqLambdaMeqLambda evalLambdaM evalLambda ReifiableHOASTHOLambdalambdalambdaNlet_reifyM reifyHOASTreify ConsType' EvalResult' ConsEval' fromEval'toEval' listHList' listHListM' mapHList':*:Nilbase GHC.ClassesEqGHC.BaseStringtoTreedata-hash-0.1.0.0Data.Hash.BaseHash