úÎŒéˆBN      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLM(c) 2010-2012 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None %&:OQRT9yThis type represents transition functions of generalised deterministic top-down tree acceptors (GDTAs) which have accessbThis type represents transition functions of total, deterministic top-down tree acceptors (DTAs).This is a variant of the  L type that makes it easier to define DTTs as it avoids the explicit use of N) to inject placeholders into the result. cThis type represents transition functions of total deterministic top-down tree transducers (DTTs). —This type represents transition functions of generalised deterministic bottom-up tree acceptors (GUTAs) which have access to an extended state space. cThis type represents transition functions of total, deterministic bottom-up tree acceptors (UTAs). This is a variant of the  L type that makes it easier to define UTTs as it avoids the explicit use of N) to inject placeholders into the result. eThis type represents transition functions of total, deterministic bottom-up tree transducers (UTTs).ÈThis type represents stateful term homomorphisms. Stateful term homomorphisms have access to a state that is provided (separately) by a bottom-up or top-down state transformation function (or both).HThis function provides access to components of the states from "below".FThis function provides access to components of the state from "above"OTurns the explicit parameters ?above and ?below into explicit ones.qThis function turns a stateful homomorphism with a fully polymorphic state type into a (stateless) homomorphism.1This function turns a UTT defined using the type  # in to the canonical form of type  .PDThis function transforms a UTT transition function into an algebra.3This function runs the given UTT on the given term.QThis function is a variant of 7 that additionally returns the final state of the run.RThis function generalises V to contexts. Therefore, additionally, a transition function for the holes is needed.:This function composes two UTTs. (see TATA, Theorem 6.4.5)-This function composes a UTT with an algebra.@This combinator composes a UTT followed by a signature function.@This combinator composes a signature function followed by a UTT.:This combinator composes a UTT followed by a homomorphism.:This combinator composes a homomorphism followed by a UTT.?Changes the state space of the UTA using the given isomorphism.SThis combinator runs the given UTA on a term returning the final state of the run.=This function combines the product UTA of the two given UTAs.sThis function constructs a UTT from a given stateful term homomorphism with the state propagated by the given UTA.sThis function applies a given stateful term homomorphism with a state space propagated by the given UTA to a term.This is a variant of / that also returns the final state of the run. 3This combinator turns an arbitrary UTA into a GUTA.!PThis combinator turns a GUTA with the smallest possible state space into a UTA."&This combinator runs a GUTA on a term.#3This combinator constructs the product of two GUTA.%1This function turns a DTT defined using the type # in to the canonical form of type  .&4Thsis function runs the given DTT on the given tree.S3This function runs the given DTT on the given tree.'`This function composes two DTTs. (see W.C. Rounds /Mappings and grammars on trees/, Theorem 2.)(8This function composes a signature function after a DTT.).This function composes a DTT after a function.*2This function composes a homomorphism after a DTT.+2This function composes a DTT after a homomorphism.,?Changes the state space of the DTA using the given isomorphism.-?This function constructs the product DTA of the given two DTAs.T±Apply the given state mapping to the given functorial value by adding the state to the corresponding index if it is in the map and otherwise adding the provided default state..uThis function constructs a DTT from a given stateful term-- homomorphism with the state propagated by the given DTA./sThis function applies a given stateful term homomorphism with a state space propagated by the given DTA to a term.03This combinator turns an arbitrary DTA into a GDTA.1PThis combinator turns a GDTA with the smallest possible state space into a DTA.2XThis combinator constructs the product of two dependant top-down state transformations.3This is a synonym for 2.4”This combinator combines a bottom-up and a top-down state transformations. Both state transformations can depend mutually recursive on each other.5‰This combinator runs a stateful term homomorphisms with a state space produced both on a bottom-up and a top-down state transformation.62Lift a stateful term homomorphism over signatures f and g[ to a stateful term homomorphism over the same signatures, but extended with annotations.71Lift a bottom-up tree transducer over signatures f and gZ to a bottom-up tree transducer over the same signatures, but extended with annotations.80Lift a top-down tree transducer over signatures f and gY to a top-down tree transducer over the same signatures, but extended with annotations.9ÈThis function adds unique annotations to a term/context. Each node in the term/context is annotated with its path from the root, which is represented as an integer list. It is implemented as a DTT.<U V OPQR !"#$%&S'()*+,-T./01234567899WX  !"#$%&'()*+,-./01234567897./5   !"#$ %&')(+*,-012346789<U V OPQR !"#$%&S'()*+,-T./0123456789(c) 2013 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None%&OQRT:*This type is a more convenient variant of ;! with which one can avoid using N7 explicitly when injecting placeholders in the result.;‚This type represents MTTs with regular look-ahead, i.e. MTTs that have access to information that is generated by a separate UTA.<This type is a variant of the =I which is more convenient to work with as it avoids the explicit use of N( to embed placeholders into the result.=%This type is an instantiation of the A† type to a state space with only a single state with a single accumulation parameter (i.e. the state space is the identity functor).>zThis type constructor is used to define the state space of an MTT that is obtained by composing an MTT followed by a DTT.@This is a variant of the type AG that makes it easier to define MTTs as it avoids the explicit use of N( when using placeholders in the result.AHThis type represents total deterministic macro tree transducers (MTTs).BCThis function turns an MTT defined using the more convenient type @! into its canonical form of type A.CkThis function defines the semantics of MTTs. It applies a given MTT to an input with and an initial state.D¨This function composes a DTT followed by an MTT. The resulting MTT's semantics is equivalent to the function composition of the semantics of the original MTT and DTT.YThis function is a variant of &@ that is used to define composition, similarly to the function Z.E’This function composes an MTT followed by a DTT. The resulting MTT's semantics is equivalent to first running the original MTT and then the DTT.FhThis function transforms an MTT of type |MacroTransId| into the canonical type such that it can be run.GiThis function transforms an MTT of type |MacroTransId'| into the canonical type such that it can be run.H›This function turns an MTT with regular look-ahead defined using the more convenient type |MacroTransLA'| into its canonical form of type |MacroTransLA|.IÝThis function defines the semantics of MTTs with regular look-ahead. It applies a given MTT with regular look-ahead (including an accompanying bottom-up state transition function) to an input with and an initial state.JIThis function composes an MTT with regular look-ahead followed by a DTT.K-Lift a macro tree transducer over signatures f and gV to a macro tree transducer over the same signatures, but extended with annotations.LFLift a macro tree transducer with regular look-ahead over signatures f and gm to a macro tree transducer with regular look-ahead over the same signatures, but extended with annotations.:;<=>?@ABCZDYEFGHIJKLM:;<=>?@ABCDEFGHIJKLA@BCDE=<FG;:HIJ>?KL:;<=>?@ABCZDYEFGHIJKLM[       !"#$%&'()*+,-./0123456789:;<=>?@ABCCDEFGHIJKLMNOPQRSTUVWXYZ[\]^\]_X`a.compdata-automata-0.9.1-E2c0NK3xV3Z88MFojVLccGData.Comp.AutomataData.Comp.MacroAutomata$compdata-0.11-9FQG0hVaPcDJeuJLRT7IykData.Comp.Mappingempty|->&Data.Comp.Multi.HFunctorunII DDownState DownState DownTrans' DownTransDUpStateUpStateUpTrans'UpTransQHombelowabovepureHom mkUpTrans runUpTrans compUpTranscompAlgUpTranscompSigUpTranscompUpTransSigcompHomUpTranscompUpTransHom tagUpState runUpState prodUpStateupTransrunUpHom runUpHomStdUpStateupState runDUpState prodDUpState|*| mkDownTrans runDownTrans compDownTranscompSigDownTranscompDownTransSigcompHomDownTranscompDownTransHom tagDownState prodDownState downTrans runDownHom dDownState downStateprodDDownState>*< runDStaterunQHompropAnnQ propAnnUp propAnnDownpathAnn MacroTransLA' MacroTransLA MacroTransId' MacroTransId:^: MacroTrans' MacroTrans mkMacroTrans runMacroTrans compMacroDown compDownMacrofromMacroTransIdfromMacroTransId'mkMacroTransLArunMacroTransLAcompDownMacroLA propAnnMacropropAnnMacroLA $fFunctor:^:Data.Comp.TermHoleexplicitupAlg runUpTransSt runUpTrans' runDownTrans'appMap DDownState' DUpState'%projection-0.1-BDECvT69ALv2nrMF1Q3w9FData.Projectionpr:<runMacroTrans'