úÎm¼g¶l      !"#$%&'()*+,-./0123456789:;< = > ? @ 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 [ \ ] ^ _ ` a b c d e f g h i j k "GData family for collecting the children of a constructor, for example:  E subTrees :: forall dom . SubTrees dom (Int :-> Bool :-> Full [Int])  subTrees = a :*: b :*: Nil  where # a = undefined :: ASTF dom Int $ b = undefined :: ASTF dom Bool ( a) is meaningful iff. ( a) 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 l mentioned in the type of  is  interchangeable with . Returns the result type ( removed) of a . This is a public  alias for the hidden type m. Maps a  to a simpler form where  has been replaced by ->,  and > has been removed. This is a public alias for the hidden type  n. 'Fully or partially applied constructor ,This is a public alias for the hidden class l. The only instances  are:  instance ConsType' (Full a) - instance ConsType' b => ConsType' (a :-> b) l'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. nmo;The type of a partially applied (or unapplied) constructor (The type of a fully applied constructor %Make a constructor evaluation from a  representation !Semantic constructor application Syntactic type casting  Process 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 G count' :: Count domain => subDomain a -> SubTrees 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 = processNode count' Here, count' represents some static analysis on an . Each constructor " in the tree will be processed 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  pq    1Equality for expressions. The difference between r 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 s %HRender a partially applied constructor given a list of rendered missing  arguments &Print an expression t'Convert an expression to a syntax tree '!Show syntax tree using ASCII art ("Print syntax tree using ASCII art !"#$%&'(#$%&!"'(!""#$%$%&'()*Evaluation of expressions +,)*+,)*+,)**+,-. Computes a u/ for an expression. Expressions that are equal  according to  must result in the same hash. -.-.-../012/012/012/001234567834567834567834456789:;9:;9:;9::; <.Expressions for selecting elements of a tuple =>?@ABCD$Expressions for constructing tuples EFGHIJK#Return the selected position, e.g. ; selectPos (Sel3 :: Select ((Int,Int,Int,Int) -> Int)) = 3 <=>?@ABCDEFGHIJKDJIHGFE<CBA@?>=K<CBA@?>==>?@ABCDJIHGFEEFGHIJK L5Annotating 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  N / O. MNOPLMNOPLMNOPLMMNOP S pq !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOP Q Let binding RS%The class of n-ary binding functions TU3N-ary binding by nested use of the supplied binder VLambda binding WX Variables YZVariable identifier [\]^Alpha-equivalence on WV- expressions. Free variables are taken to be - equvalent if they have the same identifier. _`Evaluation of possibly open  LambdaAST expressions aEvaluation of closed WV expressions QRSTUVWXYZ[\]^_`aZ[\]XYVW^_`aSTUQRQRRSTUTUVWWXYYZ[\[\]^_`a b5Convenient class alias for n-ary syntactic functions cdHigher-order lambda binding efLambda binding gN-ary lambda binding h Let binding ijCTranslating expressions with higher-order binding to corresponding ' expressions using first-order binding k%Reifying an n-ary syntactic function a pq !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRXabcdefghijkXaQRdecfghijbk bcdeefghijkv !"#$%%&'()*+,-./0123456789:;<<=>??@ABCDDE F G H I J K L M N O P Q R S T U V V W X Y Z Z [ \ ] ^ ^ _ _ ` ` a b c d e f g h i i j k l m n opqrstuvwxvyz{|}~ syntactic-0.2Language.Syntactic.Syntax$Language.Syntactic.Analysis.Equality"Language.Syntactic.Analysis.Render&Language.Syntactic.Analysis.Evaluation Language.Syntactic.Analysis.Hash#Language.Syntactic.Features.Literal$Language.Syntactic.Features.PrimFunc%Language.Syntactic.Features.Condition!Language.Syntactic.Features.Tuple$Language.Syntactic.Features.Annotate#Language.Syntactic.Features.Binding/Language.Syntactic.Features.Binding.HigherOrderLanguage.SyntacticSubTrees SyntacticNdesugarNsugarN SyntacticInternaldesugarsugar:<:injectproject:+:InjectRInjectLASTFAST:$:Symbol EvalResultConsEvalConsType:->PartialFullresultconsEval$:resugar processNodeExprEqexprEqeqSynToTree toTreePartRenderrender renderPart printExprshowASTdrawASTEvalevaluateevalFullevalSynExprHashexprHashLiterallitlitSynPrimFuncprimFunc primFunc2 primFunc3 primFunc4 Condition conditionSelectSel7Sel6Sel5Sel4Sel3Sel2Sel1TupleTup7Tup6Tup5Tup4Tup3Tup2 selectPosAnn injectAnn projectAnngetInfoLetNAryNAryEvalbindNLambdaVariableVarId varIntegershowVar eqLambdaMeqLambda evalLambdaM evalLambda ReifiableHOASTHOLambdalambdalambdaNlet_reifyM reifyHOASTreify ConsType' EvalResult' ConsEval' consEval':*:Nilbase GHC.ClassesEqGHC.BaseStringtoTreedata-hash-0.1.0.0Data.Hash.BaseHash