\y      !"#$%&'()*+ , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ 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 l m n o p q r s t u v w x y z { | } ~        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ! ! ! !!!!!!!!!!!""""""## #!#"##$$%$&$'$($)$*$+$,$-./%0%1%2%3&4&5&6&789:';'<'='>'?'@'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*l*m*n*o*p*q*r*s*t*u*v*w*x*y*z*{*|*}*~***************************+++++++,,,,----...../////////////0000000000000000000000000000000000000000000000000000000000000000000000111 1 1 1 1 1111111111111111111 1!1"1#1$1%1&1'1(1)1*1+1,1-1.1/101112131415262728292:2;2<2=2>2?2@2A2B2C2D2E2F2G2H2I2J2K2L2M2N2O2P2Q2R2S2T2U2V2W2X2Y2Z2[2\2]2^2_2`2a2b2c2d2e2f2g2h2i2j2k2l2m2n2o2p2q2r2s2t2u2v2w3x3y3z3{3|3}3~33344444444455555555555555555555677777777777778899999999999999:::::::::;;;;;;;;;;;;;;;;;;;;;<<<<None 7Abstract notion of a name (the constructor is hidden). -Monad for generating fresh (abstract) names. Change the type tag of a name. 8Run the given computation with the next available name. .Evaluate a computation that uses fresh names.         non-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>None7Abstract notion of a name (the constructor is hidden). -Monad for generating fresh (abstract) names. 8Run the given computation with the next available name. .Evaluate a computation that uses fresh names. non-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk> Safe-InferredIThis class represents difunctors, i.e. binary type constructors that are K contravariant in the first argument and covariant in the second argument. 'The canonical example of a difunctor. non-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk> Safe-InferredKDifunctors representing data structures that can be traversed from left to  right. non-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk> Safe-Inferred&Remove annotations from a signature. AThis class defines how to distribute an annotation over a sum of  signatures. (Inject an annotation over a signature. )Project an annotation from a signature. 8This data type adds a constant product to a signature. !+Formal product of signatures (difunctors). #LSignature containment relation for automatic injections. The left-hand must L be an atomic signature, where as the right-hand side must have a list-like  structure. Examples include f :< : f :+: g and g :<: f :+: (g :+: h),  non-examples include  f :+: g :<: f :+: (g :+: h) and  f :<: (f :+: g) :+: h. &'Formal sum of signatures (difunctors).  !"#$%&'()* !"#$%&'()*&('#$%!")*  !"#$%&(')* non-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>None +Monads for which embedded Trm, values, which are parametric at top level,  can be made into monadic Term values, i.e. "pushing the parametricity  inwards". -@A term is a context with no holes, where all occurrences of the 0 contravariant parameter is fully parametric. 0"Preterms" 1A context may contain holes. 2Phantom type used to define -. 3Phantom type used to define 1. 4HThis data type represents contexts over a signature. Contexts are terms H containing zero or more holes, and zero or more parameters. The first L parameter is a phantom type indicating whether the context has holes. The E second paramater is the signature of the context, in the form of a  Data.Comp.Param.Difunctor1. The third parameter is the type of parameters, 2 and the fourth parameter is the type of holes. 8.Convert a difunctorial value into a context. :?This combinator maps a function over a context by applying the  function to each hole. +,-./0123456789:+,-./0123456789:476532-./0189:+,+,-./0123476589: non-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>NoneI;AThis type represents a generalised cv-coalgebra over a difunctor f and  carrier a. <=This type represents a monadic cv-coalgebra over a difunctor f and carrier  a. =5This type represents a cv-coalgebra over a difunctor f and carrier a.  The list of (a,b)1s represent the parameters that may occur in the O constructed value. The first component represents the seed of the parameter, E and the second component is the (polymorphic) parameter itself. If f is 0 itself a binder, then the parameters bound by f can be passed to the C covariant argument, thereby making them available to sub terms. >9This type represents a monadic cv-algebra over a functor f and carrier  a. ?3This type represents a cv-algebra over a difunctor f and carrier a. @:This type represents a monadic r-coalgebra over a functor f and carrier  a. A5This type represents an r-coalgebra over a difunctor f and carrier a. B:This type represents a monadic r-algebra over a difunctor f and carrier  a. C3This type represents an r-algebra over a difunctor f and carrier a. D:This type represents a monadic coalgebra over a difunctor f and carrier  a. E2This type represents a coalgebra over a difunctor f and carrier a. The  list of (a,b)=s represent the parameters that may occur in the constructed C value. The first component represents the seed of the parameter, E and the second component is the (polymorphic) parameter itself. If f is 0 itself a binder, then the parameters bound by f can be passed to the C covariant argument, thereby making them available to sub terms. FCThis type represents a monadic term homomorphism. It is similar to  G- but has monadic values also in the domain. G3This type represents a monadic term homomorphism. HDThis type represents a monadic signature function. It is similar to  J- but has monadic values also in the domain. I2This type represents a monadic context function. J4This type represents a monadic signature function. K+This type represents a term homomorphism. L,This type represents a signature function. M*This type represents a context function. N9This type represents a monadic algebra. It is similar to O but  the return type is monadic. O1This type represents an algebra over a difunctor f and carrier a. P+Construct a catamorphism for contexts over f with holes of type b, from  the given algebra. Q2Construct a catamorphism from the given algebra. RA generalisation of Q from terms over f to contexts over f, where 3 the holes have the type of the algebra carrier. S=This function applies a whole context into another context. TBConvert a monadic algebra into an ordinary algebra with a monadic  carrier. U3Construct a monadic catamorphism for contexts over f with holes of type  b#, from the given monadic algebra. VBConstruct a monadic catamorphism from the given monadic algebra. WA generalisation of V from terms over f to contexts over f, where ; the holes have the type of the monadic algebra carrier. X/Apply a term homomorphism recursively to a term/ context. Y/Apply a term homomorphism recursively to a term/ context. Z!Compose two term homomorphisms. [CCompose an algebra with a term homomorphism to get a new algebra. ]BThis function applies a signature function to the given context. ^8This function applies a signature function to the given * context. This is a top-bottom variant of ]. _1This function composes two signature functions. `FThis function composes a term homomorphism and a signature function. aFThis function composes a term homomorphism and a signature function. bHLifts the given signature function to the canonical term homomorphism. cMLift the given signature function to a monadic signature function. Note that O term homomorphisms are instances of signature functions. Hence this function ' also applies to term homomorphisms. dCLift the given signature function to a monadic term homomorphism. e3Apply a monadic term homomorphism recursively to a  term/+context. The monad is sequenced bottom-up. f<A restricted form of |appHomM| which only works for terms. g3Apply a monadic term homomorphism recursively to a  term/)context. The monad is sequence top-down. hA restricted form of |appHomM'| which only works for terms. iBThis function constructs the unique monadic homomorphism from the 3 initial term algebra to the given term algebra. jJThis function applies a monadic signature function to the given context. k?A restricted form of |appSigFunM| which only works for terms. l@This function applies a monadic signature function to the given  context. This is a 'top-down variant of j. m A restricted form of |appSigFunM'| which only works for terms. nBThis function applies a signature function to the given context. o@A restricted form of |appSigFunMD| which only works for terms. p)Compose two monadic term homomorphisms. q)Compose two monadic term homomorphisms. r)Compose two monadic term homomorphisms. s)Compose two monadic term homomorphisms. tHCompose a monadic algebra with a monadic term homomorphism to get a new  monadic algebra. uHCompose a monadic algebra with a term homomorphism to get a new monadic  algebra. vICompose a monadic algebra with a monadic signature function to get a new  monadic algebra. wICompose a monadic algebra with a signature function to get a new monadic  algebra. x9This function composes two monadic signature functions. y4Construct an anamorphism from the given coalgebra. zCConstruct a monadic anamorphism from the given monadic coalgebra. {4Construct a paramorphism from the given r-algebra. |DConstruct a monadic paramorphism from the given monadic r-algebra. }6Construct an apomorphism from the given r-coalgebra. ~EConstruct a monadic apomorphism from the given monadic r-coalgebra. This function applies  at the tip of the term. 6Construct a histomorphism from the given cv-algebra. FConstruct a monadic histomorphism from the given monadic cv-algebra. 7Construct a futumorphism from the given cv-coalgebra. GConstruct a monadic futumorphism from the given monadic cv-coalgebra. CConstruct a futumorphism from the given generalised cv-coalgebra. L;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~I;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~IOPQRSNTUVWMLKXYZ]^_`ab[\IJGHFcefghdijklmnopqxrsvwtuEyDzC{B|A}@~?>=;<L;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~=non-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>None   >non-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>None         non-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>NoneKProject the outermost layer of a term to a sub signature. If the signature  g is compound of n atomic signatures, use projectn instead. Tries to coerce a termcontext to a term!context over a sub-signature. If  the signature g is compound of n atomic signatures, use   deepProjectn instead. MInject a term where the outermost layer is a sub signature. If the signature  g is compound of n atomic signatures, use injectn instead. MInject a term where the outermost layer is a sub signature. If the signature  g is compound of n atomic signatures, use injectn instead. KInject a term over a sub signature to a term over larger signature. If the  signature g is compound of n atomic signatures, use  deepInjectn  instead. =This function injects a whole context into another context. 5This function lifts the given functor to a context. @ A#$%&A#$%&@  non-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>NoneLTransform a function with a domain constructed from a functor to a function I with a domain constructed with the same functor, but with an additional  annotation. LTransform a function with a domain constructed from a functor to a function J with a domain constructed with the same functor, but with an additional  annotation. DStrip the annotations from a term over a functor with annotations. )Lift a term homomorphism over signatures f and g to a term homomorphism ; over the same signatures, but extended with annotations. 1Lift a monadic term homomorphism over signatures f and g to a monadic N term homomorphism over the same signatures, but extended with annotations. 5Annotate each node of a term with a constant value. This function is similar to  but applies to signatures +with an annotation which is then ignored.  !" !" non-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>None Signature equality. An instance EqD f gives rise to an instance   Eq (Term f),. The equality test is performed inside the  monad for ! generating fresh identifiers. IEquality on parametric values. The equality test is performed inside the  ) monad for generating fresh identifiers. Equality on terms. From an  difunctor an - instance of the corresponding term type can  be derived.  is propagated through sums. non-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>None Signature ordering. An instance OrdD f gives rise to an instance   Ord (Term f). Ordering of parametric values. Ordering of terms. From an  difunctor an ) instance of the corresponding term type  can be derived.  is propagated through sums.  non-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>None >This type represents algebras which have terms with thunks as  carrier. +This type represents contexts with thunks. (This type represents terms with thunks. (This type represents terms with thunks. 8This function turns a monadic computation into a thunk. =This function evaluates all thunks until a non-thunk node is  found. >This function first evaluates the argument term into whnf via  : and then projects the top-level signature to the desired > subsignature. Failure to do the projection is signalled as a  failure in the monad. $This function evaluates all thunks. $This function evaluates all thunks. 8This function evaluates all thunks while simultaneously ? projecting the term to a smaller signature. Failure to do the 9 projection is signalled as a failure in the monad as in . 8This function evaluates all thunks while simultaneously ? projecting the term to a smaller signature. Failure to do the 9 projection is signalled as a failure in the monad as in . :This combinator makes the evaluation of the given functor D application strict by evaluating all thunks of immediate subterms. :This combinator makes the evaluation of the given functor D application strict by evaluating all thunks of immediate subterms. ?non-portable (GHC Extensions) experimental:Patrick Bahr <paba@diku.dk>, Tom Hvitved <hvitved@diku.dk>None !"#$%&+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~non-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk> Safe-Inferred@This data type denotes the composition of two functor families. AThis class represents higher-order functors (Johann, Ghani, POPL  '<08) which are endofunctors on the category of endofunctors. A higher-order functor f$ also maps a natural transformation  g :-> h to a natural transformation  f g :-> f h #This type represents co-cones from f to a. f :=> a is  isomorphic to f :-> K a .This type represents natural transformations. #The parametrised constant functor. The identity Functor.  !  !non-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk> Safe-Inferred*Higher-order functors that can be folded. Minimal complete definition:  or . non-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk> Safe-Inferred>Map each element of a structure to a monadic action, evaluate < these actions from left to right, and collect the results. ;Alternative type in terms of natural transformations using  functor composition :.:: :hmapM :: Monad m => (a :-> m :.: b) -> t a :-> m :.: (t b)non-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk> Safe-Inferred/This class represents higher-order difunctors. "CA higher-order difunctor gives rise to a higher-order functor when 4 restricted to a particular contravariant argument. ""non-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>NoneLHDifunctors representing data structures that can be traversed from left to  right. non-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>None Monads for which embedded Trm, values, which are parametric at top level,  can be made into monadic Term values, i.e. "pushing the parametricity  inwards". @A term is a context with no holes, where all occurrences of the 0 contravariant parameter is fully parametric.  "Preterms" |  A context may contain holes.  Phantom type used to define .  Phantom type used to define  . HThis data type represents contexts over a signature. Contexts are terms H containing zero or more holes, and zero or more parameters. The first L parameter is a phantom type indicating whether the context has holes. The E second paramater is the signature of the context, in the form of a  Data.Comp.MultiParam.HDifunctor%. The third parameter is the type of G parameters, the fourth parameter is the type of holes, and the fifth  parameter is the GADT type. .Convert a difunctorial value into a context. This is an instance of  for . This is an instance of  for .      #$%&               #$%&non-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>None(3This type represents a monadic term homomorphism. 2This type represents a monadic context function. 4This type represents a monadic signature function. +This type represents a term homomorphism. *This type represents a context function. ,This type represents a signature function. LThis type represents a monadic algebra, but where the covariant argument is  also a monadic computation. 9This type represents a monadic algebra. It is similar to  but  the return type is monadic. 1This type represents an algebra over a difunctor f and carrier a. +Construct a catamorphism for contexts over f with holes of type b, from  the given algebra.  2Construct a catamorphism from the given algebra. !A generalisation of   from terms over f to contexts over f, where 3 the holes have the type of the algebra carrier. "=This function applies a whole context into another context. #3Construct a monadic catamorphism for contexts over f with holes of type  b#, from the given monadic algebra. $BConstruct a monadic catamorphism from the given monadic algebra. %3Construct a monadic catamorphism for contexts over f with holes of type  b#, from the given monadic algebra. &BConstruct a monadic catamorphism from the given monadic algebra. '/Apply a term homomorphism recursively to a term/ context. (/Apply a term homomorphism recursively to a term/context. This is  a top-down variant of '. )!Compose two term homomorphisms. *CCompose an algebra with a term homomorphism to get a new algebra. +BThis function applies a signature function to the given context. ,BThis function applies a signature function to the given context. -1This function composes two signature functions. .HLifts the given signature function to the canonical term homomorphism. /MLift the given signature function to a monadic signature function. Note that O term homomorphisms are instances of signature functions. Hence this function ' also applies to term homomorphisms. 0JLift the give monadic signature function to a monadic term homomorphism. 1CLift the given signature function to a monadic term homomorphism. 27Apply a monadic term homomorphism recursively to a term/ context. 3<A restricted form of |appHomM| which only works for terms. 43Apply a monadic term homomorphism recursively to a  term/'context. This is a top-down variant of 2. 5A restricted form of |appHomM'| which only works for terms. 6JThis function applies a monadic signature function to the given context. 7?A restricted form of |appSigFunM| which only works for terms. 8@This function applies a monadic signature function to the given ( context. This is a top-down variant of 6. 9 A restricted form of |appSigFunM'| which only works for terms. :)Compose two monadic term homomorphisms. ;HCompose a monadic algebra with a monadic term homomorphism to get a new  monadic algebra. <HCompose a monadic algebra with a term homomorphism to get a new monadic  algebra. =9This function composes two monadic signature functions. ( !"#$%&'()*+,-./0123456789:;<=+  !"#$%&'()*+,-./0123456789:;<=+ !"#$ %&'()+,-.*/0234516789:=;<( !"#$%&'()*+,-./0123456789:;<=non-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>None>2A (higher-order) term is a context with no holes. ?A context might contain holes. @!Phantom type that signals that a B does not contain holes. A!Phantom type that signals that a B might contain holes. BBThis data type represents contexts over a signature. Contexts are B terms containing zero or more holes. The first type parameter is ) supposed to be one of the phantom types A and @. The = second parameter is the signature of the context. The third B parameter is the type family of the holes. The last parameter is  the index/label. F?This function converts a constant to a term. This assumes that C the argument is indeed a constant, i.e. does not have a value for % the argument type of the functor f. G<This function unravels the given term at the topmost layer. IDCast a term over a signature to a context over the same signature. >?@ABCDEFGHI'() >?@ABCDEFGHI BDCA@?>EFGIH >?@ABDCEFGHI'()@non-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>NoneJ An instance a :< b means that a is a component of b. a  can be extracted from b via the method K. *+,JK-./01234 *+,JK-./01234 *,+JK-./01234non-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>None567JKJK567non-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk> Safe-InferredLBThis type is used for numbering components of a functorial value. O=This function numbers the components of the given functorial 0 value with consecutive integers starting at 0. LMNO89LMNOLMNOLMNO89Anon-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>None : This is the Q-lifted version of 'abstractNewtypeQ. ;This function abstracts away newtype! declaration, it turns them into  data declarations. <MThis function provides the name and the arity of the given data constructor. =Same as normalCon' but expands type synonyms. >Same as normalConExp'% but retains strictness annotations. ?MThis function provides the name and the arity of the given data constructor. @8This function returns the name of a bound type variable AGThis function provides a list (of the given length) of new names based  on the given string. PGHelper function for generating a list of instances for a list of named 7 signatures. For example, in order to derive instances  and  ShowF for a signature Exp+, use derive as follows (requires Template  Haskell): , $(derive [makeFunctor, makeShowF] [''Exp]) B3This function lifts type class instances over sums D ofsignatures. To this end it assumes that it contains only methods  with types of the form f t1 .. tn -> t where f is the signature C that is used to construct sums. Since this function is generic it @ assumes as its first argument the name of the function that is 8 used to lift methods over sums i.e. a function of type   E (f t1 .. tn -> t) -> (g t1 .. tn -> t) -> ((f :+: g) t1 .. tn -> t) where :+:5 is the sum type constructor. The second argument to C this function is expected to be the name of that constructor. The B last argument is the name of the class whose instances should be  lifted over sums. :;<C=>?@DEAFPBG:;<C=>?@DEAFPBG:;<C=>?@DEAFPBGBnon-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>NoneQ Signature printing. An instance ShowF f gives rise to an instance   Show (Term f). SDerive an instance of Q0 for a type constructor of any first-order kind ! taking at least one argument. QRHSQRSQRHSCnon-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>NoneTDerive an instance of + for a type constructor of any first-order & kind taking at least one argument. IJTTIJTDnon-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>NoneUDerive an instance of  for a type constructor of any 2 first-order kind taking at least one argument. KLUUKLUEnon-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>NoneV#Signature arbitration. An instance  ArbitraryF f gives rise to an instance  Arbitrary (Term f). ZDerive an instance of  for a type constructor. [Derive an instance of V for a type constructor of any F first-order kind taking at least one argument. It is necessary that E all types that are used by the data type definition are themselves  instances of . M4This function generates a declaration of the method  for the given  list of constructors using N. NQThis function generates a declaration of a generator having the given name using 5 the given constructors, i.e., something like this:    <name> :: Gen <type>  <name> = ... where <type>J is the type of the given constructors. If the constructors do not belong ^ to the same type this function fails. The generated function will generate only elements of ` this type using the given constructors. All argument types of these constructors are supposed  to be instances of . O5This function generates a declaration for the method Y using the given constructors. < The constructors are supposed to belong to the same type. VWXYZ[MNO VWXYZ[VWXYZ[MNOFnon-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>None\#Signature normal form. An instance  NFDataF f gives rise to an instance  NFData (Term f). ^Derive an instance of \+ for a type constructor of any first-order & kind taking at least one argument. \]^\]^\]^Gnon-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>None_Derive an instance of , for a type constructor of any higher-order ' kind taking at least two arguments. P__P_Hnon-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>None`Derive an instance of , for a type constructor of any higher-order ' kind taking at least two arguments. QRS``QRS`Inon-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>NoneaDerive an instance of  for a type constructor of any 4 higher-order kind taking at least two arguments. TUaaTUaJnon-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>NonebDerive an instance of * for a type constructor of any parametric ' kind taking at least two arguments. bbbKnon-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>NonecDerive an instance of * for a type constructor of any parametric ' kind taking at least two arguments. cccLnon-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>Noned Signature printing. An instance ShowD f gives rise to an instance   Show (Term f). fDerive an instance of d* for a type constructor of any parametric ' kind taking at least two arguments. VWdefXdefVWdefXMnon-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>NonegDerive an instance of * for a type constructor of any parametric ' kind taking at least two arguments. gggNnon-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>NonehDerive an instance of  Traversable for a type constructor of any 2 first-order kind taking at least one argument. YZhhYZhOnon-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>NoneiFDerive smart constructors for a difunctor. The smart constructors are - similar to the ordinary constructors, but a 'inject . dimap Var id' is  automatically inserted. iiiPnon-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>NonejFDerive smart constructors with annotations for a difunctor. The smart > constructors are similar to the ordinary constructors, but a  'injectA . dimap Var id' is automatically inserted. jjjQnon-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>NonekJGiven the name of a type class, where the first parameter is a difunctor, * lift it to sums of difunctors. Example: class ShowD f where ... is lifted  as 9instance (ShowD f, ShowD g) => ShowD (f :+: g) where ... . lKUtility function to case on a difunctor sum, without exposing the internal  representation of sums. klklklnon-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>NonePbcdefghijklPbcdefghijklRnon-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>None[Printing of terms. \From an d difunctor an d) instance of the corresponding term type  can be derived. ][\^dede][\^non-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>Nonem"The desugaring term homomorphism. pDesugar a term. q$Lift desugaring to annotated terms. _Default desugaring instance. mnopq_`mnopqmnopqmnopq_`Snon-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>Noner Signature printing. An instance ShowHD f gives rise to an instance  Show (Term f i). tDerive an instance of r* for a type constructor of any parametric ) kind taking at least three arguments. abrstcrstabrstcTnon-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>NoneuDerive an instance of * for a type constructor of any parametric ) kind taking at least three arguments. uuuUnon-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>Nonev Signature equality. An instance EqF f gives rise to an instance   Eq (Term f). xDerive an instance of v0 for a type constructor of any first-order kind ! taking at least one argument. vwxvwxvwxVnon-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>Noney Signature ordering. An instance OrdF f gives rise to an instance   Ord (Term f). {Derive an instance of y0 for a type constructor of any first-order kind ! taking at least one argument. yzd{yz{yzd{non-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk> Safe-Inferred}&Remove annotations from a signature. ~AThis class defines how to distribute an annotation over a sum of  signatures. (Inject an annotation over a signature. )Project an annotation from a signature. EThis data type adds a constant product (annotation) to a signature. )Formal product of signatures (functors). LSignature containment relation for automatic injections. The left-hand must L be an atomic signature, where as the right-hand side must have a list-like  structure. Examples include f :< : f :+: g and g :<: f :+: (g :+: h),  non-examples include  f :+: g :<: f :+: (g :+: h) and  f :<: (f :+: g) :+: h. %Formal sum of signatures (functors). |}~efghijklmnopq|}~~|}|}~efghijklmnopqnon-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>None06This type represents monadic cv-coalgebras over monad m and  functor f, and with domain a. 0This type represents cv-coalgebras over functor f and with domain  a. 5This type represents monadic r-coalgebras over monad m and  functor f with domain a. /This type represents r-coalgebras over functor f and with  domain a. 3This type represents monadic r-algebras over monad m and  functor f and with domain a. -This type represents r-algebras over functor f and with domain  a. ,This type represents monadic term algebras. /This type represents monadic context function. 2This type represents monadic signature functions. )This type represents term homomorphisms. 'This type represents context function. ?This type represents uniform signature function specification. 9This type represents a monadic algebra. It is similar to  ! but the return type is monadic. !This type represents multisorted f-algebras with a family e  of carriers. +Construct a catamorphism for contexts over f with holes of type  b, from the given algebra. 1Construct a catamorphism from the given algebra. A generalisation of  from terms over f to contexts over  f8, where the holes have the type of the algebra carrier. <This function applies a whole context into another context. ?This function lifts a many-sorted algebra to a monadic domain. 3Construct a monadic catamorphism for contexts over f with holes  of type b", from the given monadic algebra. This is a monadic version of . 7This function applies the given term homomorphism to a  term/ context. 7This function applies the given term homomorphism to a  term/)context. This is the top-down variant of . *This function composes two term algebras. 7This function composes a term algebra with an algebra. 8This function applies a signature function to the given * context. This is the top-down variant of . AThis function applies a signature function to the given context. 0This function composes two signature functions. GLifts the given signature function to the canonical term homomorphism. >This function lifts the given signature function to a monadic > signature function. Note that term algebras are instances of ? signature functions. Hence this function also applies to term  algebras. =This function lifts the give monadic signature function to a  monadic term algebra. >This function lifts the given signature function to a monadic  term algebra. AThis function applies the given monadic term homomorphism to the  given term/ context. AThis function applies the given monadic term homomorphism to the  given term/'context. This is a top-down variant of . BThis function applies the given monadic signature function to the  given context. BThis function applies the given monadic signature function to the . given context. This is a top-down variant of . 2This function composes two monadic term algebras. FThis function composes a monadic term algebra with a monadic algebra =This function composes a monadic term algebra with a monadic  algebra. :This function composes two monadic signature functions. @This function unfolds the given value to a term using the given 6unravelling function. This is the unique homomorphism  a -> Term f !from the given coalgebra of type a -> f a to the final coalgebra Term f. @This function unfolds the given value to a term using the given ? monadic unravelling function. This is the unique homomorphism a ->  Term f" from the given coalgebra of type a -> f a to the final  coalgebra Term f. AThis function constructs a paramorphism from the given r-algebra ?This function constructs a monadic paramorphism from the given  monadic r-algebra 7This function constructs an apomorphism from the given  r-coalgebra. >This function constructs a monadic apomorphism from the given  monadic r-coalgebra. @This function constructs the unique futumorphism from the given # cv-coalgebra to the term algebra. BThis function constructs the unique monadic futumorphism from the 1 given monadic cv-coalgebra to the term algebra. 3333Wnon-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>None Signature printing. An instance ShowHF f gives rise to an instance  KShow (HTerm f). Derive an instance of , for a type constructor of any higher-order ' kind taking at least two arguments. rr non-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk> Safe-InferredAThis class defines how to distribute an annotation over a sum of  signatures. 6This function injects an annotation over a signature. ,This data type adds a constant product to a @ signature. Alternatively, this could have also been defined as   data (f :&: a) (g :: * -> *) e = f g e :&: a e.This is too general, however, for example for  productHHom. The subsumption relation. Data type defining coproducts. stuvwxyz{|}~stuvwxyz{|}~Xnon-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>NoneYnon-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>None!non-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>NoneKProject the outermost layer of a term to a sub signature. If the signature  g is compound of n atomic signatures, use projectn instead. Tries to coerce a termcontext to a term!context over a sub-signature. If  the signature g is compound of n atomic signatures, use   deepProjectn instead. MInject a term where the outermost layer is a sub signature. If the signature  g is compound of n atomic signatures, use injectn instead. KInject a term over a sub signature to a term over larger signature. If the  signature g is compound of n atomic signatures, use  deepInjectn  instead. <This function injects a whole context into another context. 4This function lifts the given functor to a context. 7This function applies the given context with hole type a to a  family f) of contexts (possibly terms) indexed by a . That is,  each hole h is replaced by the context f h. A     E     E     A     "non-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>None>This function transforms a function with a domain constructed A from a functor to a function with a domain constructed with the 1 same functor but with an additional annotation. AThis function annotates each sub term of the given term with the  given value (of type a). >This function transforms a function with a domain constructed A from a functor to a function with a domain constructed with the 1 same functor but with an additional annotation. 8This function strips the annotations from a term over a functor with annotations. This function is similar to  but applies to signatures + with an annotation which is then ignored.   #non-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>None Signature equality. An instance EqHF f gives rise to an instance   KEq (HTerm f). "4This function implements equality of values of type f a modulo the equality of a4 itself. If two functorial values are equal in this sense, eqMod returns a " value containing a list of pairs =consisting of corresponding components of the two functorial  values. From an EqF functor an  instance of the corresponding  term type can be derived. EqF is propagated through sums.  !" !" !"  !"Znon-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>None#Derive an instance of , for a type constructor of any higher-order ' kind taking at least two arguments. # !##$non-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>None$:This function returns a list of all subterms of the given + term. This function is similar to Uniplate's universe function. %?This function returns a list of all subterms of the given term 1 that are constructed from a particular functor. &>This function transforms every subterm according to the given = function in a bottom-up manner. This function is similar to  Uniplate's  transform function. 'Monadic version of &. +;This function computes the generic size of the given term, - i.e. the its number of subterm occurrences. ,<This function computes the generic depth of the given term. $%&'()*+, $%&'()*+, $%&'()*+, $%&'()*+,[non-portable (GHC Extensions) experimental:Patrick Bahr <paba@diku.dk>, Tom Hvitved <hvitved@diku.dk>None>?@ABCDEFGHI      !"$%&'()*+,\non-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>None-JDerive smart constructors for a type constructor of any higher-order kind J taking at least two arguments. The smart constructors are similar to the  ordinary constructors, but an  is automatically inserted. ---]non-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>None.FDerive smart constructors with products for a type constructor of any L parametric kind taking at least two arguments. The smart constructors are / similar to the ordinary constructors, but an  is automatically  inserted. ...%non-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>None/ Signature ordering. An instance OrdHF f gives rise to an instance   Ord (Term f). Ordering of terms. From an / difunctor an ) instance of the corresponding term type  can be derived. / is propagated through sums. /012/01212/0/012&non-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>None3BThis type is used for numbering components of a functorial value. 6=This function numbers the components of the given functorial 0 value with consecutive integers starting at 0. 3456345634563456^non-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>None7Derive an instance of /* for a type constructor of any parametric ) kind taking at least three arguments. 7/077_non-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>None8LGiven the name of a type class, where the first parameter is a higher-order 5 functor, lift it to sums of higher-order. Example: class HShowF f where ...  is lifted as <instance (HShowF f, HShowF g) => HShowF (f :+: g) where ... . 9MUtility function to case on a higher-order functor sum, without exposing the $ internal representation of sums. 898989non-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>NoneP_`a !#-./0789P !#/07_`a-.89`non-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>None'non-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>None:GThis multiparameter class defines functors with variables. An instance   HasVar f v denotes that values over f% might contain and bind variables of  type v. ;Indicates whether the f constructor is a variable. The  default implementation returns Nothing. <,Indicates the set of variables bound by the f constructor 9 for each argument of the constructor. For example for a  non-recursive let binding:   $ data Let i e = Let Var (e i) (e i)  instance HasVars Let Var where ? bindsVars (Let v x y) = Map.fromList [(y, (Set.singleton v))]   ? If, instead, the let binding is recursive, the methods has to  be implemented like this:   A bindsVars (Let v x y) = Map.fromList [(x, (Set.singleton v)), ? (y, (Set.singleton v))]   : This indicates that the scope of the bound variable also 9 extends to the right-hand side of the variable binding. 2The default implementation returns the empty map. @This function substitutes variables in a context according to a ,partial mapping from variables to contexts. AThis combinator pairs every argument of a given constructor with C the set of (newly) bound variables according to the corresponding  : type class instance. This combinator combines  with the mfmap function. This combinator combines  with the generic  function. 9Convert variables to holes, except those that are bound. ADThis function checks whether a variable is contained in a context. BFThis function computes the list of variables occurring in a context. MAlgebra for checking whether a variable is contained in a term, except those  that are bound. CEThis function computes the set of variables occurring in a context. DEThis function computes the set of variables occurring in a context. F)This function composes two substitutions s1 and s2 . That is, Dapplying the resulting substitution is equivalent to first applying s2 and then s1. :;<=>?@ABCDEF :;<=>?@ABCDEF :;<?>=@ACBDEF:;<=>?@ABCDEF(non-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>NoneG"The desugaring term homomorphism. JDesugar a term. K$Lift desugaring to annotated terms. Default desugaring instance. GHIJKGHIJKGHIJKGHIJK)non-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>NoneM&Remove annotations from a signature. NAThis class defines how to distribute an annotation over a sum of  signatures. O(Inject an annotation over a signature. P)Project an annotation from a signature. Q8This data type adds a constant product to a signature. S8Formal product of signatures (higher-order difunctors). ULSignature containment relation for automatic injections. The left-hand must L be an atomic signature, where as the right-hand side must have a list-like  structure. Examples include f :< : f :+: g and g :<: f :+: (g :+: h),  non-examples include  f :+: g :<: f :+: (g :+: h) and  f :<: (f :+: g) :+: h. X'Formal sum of signatures (difunctors). LMNOPQRSTUVWXYZ[\LMNOPQRSTUVWXYZ[\XZYUVWST[\QRNOPLMLMNOPQRSTUVWXZY[\anon-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>Nonebnon-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>None*non-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>NonefKProject the outermost layer of a term to a sub signature. If the signature  g is compound of n atomic signatures, use projectn instead. pTries to coerce a termcontext to a term!context over a sub-signature. If  the signature g is compound of n atomic signatures, use   deepProjectn instead. MInject a term where the outermost layer is a sub signature. If the signature  g is compound of n atomic signatures, use injectn instead. KInject a term over a sub signature to a term over larger signature. If the  signature g is compound of n atomic signatures, use  deepInjectn  instead. =This function injects a whole context into another context. 5This function lifts the given functor to a context. ?]^_`abcdefghijklmnopqrstuvwxyz{|}~@UVWX]^_`abcdefghijklmnopqrstuvwxyz{|}~@UVWX]^_`abcdefghijklmnopqrstuvwxyz{|}~?]^_`abcdefghijklmnopqrstuvwxyz{|}~+non-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>NoneMTransform a function with a domain constructed from a higher-order difunctor P to a function with a domain constructed with the same higher-order difunctor, & but with an additional annotation. MTransform a function with a domain constructed from a higher-order difunctor P to a function with a domain constructed with the same higher-order difunctor, & but with an additional annotation. EStrip the annotations from a term over a higher-order difunctor with  annotations. )Lift a term homomorphism over signatures f and g to a term homomorphism ; over the same signatures, but extended with annotations. 1Lift a monadic term homomorphism over signatures f and g to a monadic N term homomorphism over the same signatures, but extended with annotations. 5Annotate each node of a term with a constant value. This function is similar to f but applies to signatures - with an annotation which is then ignored. LMNOPQRSTQRSTNOPLM,non-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>None Signature equality. An instance EqHD f gives rise to an instance   Eq (Term f i),. The equality test is performed inside the   monad for ! generating fresh identifiers. IEquality on parametric values. The equality test is performed inside the   ) monad for generating fresh identifiers. Equality on terms. From an  difunctor an - instance of the corresponding term type can  be derived.  is propagated through sums. cnon-portable (GHC Extensions) experimental:Patrick Bahr <paba@diku.dk>, Tom Hvitved <hvitved@diku.dk>None       !"#$%&'()*+,-./0123456789:;<=LMNOPQRSTUVWX]^_`abcdefghijklmnopqrstuvwxyz{|}~dnon-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>NoneDerive an instance of * for a type constructor of any parametric ) kind taking at least three arguments. enon-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>NoneBDerive smart constructors for a higher-order difunctor. The smart > constructors are similar to the ordinary constructors, but a  'inject . hdimap Var id' is automatically inserted. -non-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>None Signature ordering. An instance OrdHD f gives rise to an instance   Ord (Term f). Ordering of parametric values. Ordering of terms. From an  difunctor an ) instance of the corresponding term type  can be derived.  is propagated through sums. fnon-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>NoneDerive an instance of * for a type constructor of any parametric ) kind taking at least three arguments. gnon-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>NoneMDerive smart constructors with annotations for a higher-order difunctor. The D smart constructors are similar to the ordinary constructors, but a  'injectA . hdimap Var id' is automatically inserted. hnon-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>NoneLGiven the name of a type class, where the first parameter is a higher-order B difunctor, lift it to sums of higher-order difunctors. Example:  class ShowHD f where ... is lifted as  <instance (ShowHD f, ShowHD g) => ShowHD (f :+: g) where ... . KUtility function to case on a higher-order difunctor sum, without exposing ( the internal representation of sums. non-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>NonePrstuPrstuinon-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>NonePrinting of terms. From an r higher-order difunctor an r instance of the + corresponding term type can be derived. rsrs.non-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>None"The desugaring term homomorphism. Desugar a term. $Lift desugaring to annotated terms. Default desugaring instance. /non-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>None ;Polymorphic definition of a term. This formulation is more  natural than 1, it leads to impredicative types in some cases,  though. %A term is a context with no holes. !Phantom type that signals that a  does not contain holes. !Phantom type that signals that a  might contain holes. BThis data type represents contexts over a signature. Contexts are Aterms containing zero or more holes. The first type parameter is (supposed to be one of the phantom types  and . The Fsecond parameter is the signature of the context. The third parameter is the type of the holes. CThis function converts a constant to a term. This assumes that the Bargument is indeed a constant, i.e. does not have a value for the argument type of the functor f. -Convert a functorial value into a context. DCast a term over a signature to a context over the same signature. >This function unravels the given term at the topmost layer.   0non-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>NoneK?This type represents a generalised cv-coalgebra over a functor f and  carrier a. ;This type represents a monadic cv-coalgebra over a functor f and carrier  a. 3This type represents a cv-coalgebra over a functor f and carrier a. 9This type represents a monadic cv-algebra over a functor f and carrier  a. 1This type represents a cv-algebra over a functor f and carrier a. :This type represents a monadic r-coalgebra over a functor f and carrier  a. 3This type represents an r-coalgebra over a functor f and carrier a. 8This type represents a monadic r-algebra over a functor f and carrier  a. 1This type represents an r-algebra over a functor f and carrier a. 8This type represents a monadic coalgebra over a functor f and carrier  a. 0This type represents a coalgebra over a functor f and carrier a. CThis type represents a monadic term homomorphism. It is similar to - but has monadic values also in the domain. 4This type represents a monadic term homomorphism. BThis type represents a monadic signature function. It is similar to - but has monadic values also in the domain. 4This type represents a monadic signature function. 1This type represents a monadic context function. +This type represents a term homomorphism. +This type represents a signature function. *This type represents a context function. 9This type represents a monadic algebra. It is similar to  but the return type is monadic. /This type represents an algebra over a functor f and carrier a. +Construct a catamorphism for contexts over f with holes of type a, from  the given algebra. 2Construct a catamorphism from the given algebra. A generalisation of  from terms over f to contexts over f, where 3 the holes have the type of the algebra carrier. =This function applies a whole context into another context. BConvert a monadic algebra into an ordinary algebra with a monadic  carrier. 3Construct a monadic catamorphism for contexts over f with holes of type  a#, from the given monadic algebra. BConstruct a monadic catamorphism from the given monadic algebra. A generalisation of  from terms over f to contexts over f, where ; the holes have the type of the monadic algebra carrier. 7This function applies the given term homomorphism to a term/ context. /Apply a term homomorphism recursively to a term/context. This is  a top-down variant of . !Compose two term homomorphisms. CCompose an algebra with a term homomorphism to get a new algebra. ECompose a term homomorphism with a coalgebra to get a cv-coalgebra. KCompose a term homomorphism with a cv-coalgebra to get a new cv-coalgebra. BThis function applies a signature function to the given context. 8This function applies a signature function to the given ( context. This is a top-down variant of . 1This function composes two signature functions. 8This function composes a signature function with a term  homomorphism. FThis function composes a term homomorphism with a signature function. =This function composes an algebra with a signature function. 9Lifts the given signature function to the canonical term  homomorphism. MLift the given signature function to a monadic signature function. Note that O term homomorphisms are instances of signature functions. Hence this function ' also applies to term homomorphisms. JLift the give monadic signature function to a monadic term homomorphism. CLift the given signature function to a monadic term homomorphism. 7Apply a monadic term homomorphism recursively to a term/ context. 3Apply a monadic term homomorphism recursively to a  term/$context. This a top-down variant of . BThis function constructs the unique monadic homomorphism from the 1initial term algebra to the given term algebra. JThis function applies a monadic signature function to the given context. @This function applies a monadic signature function to the given ( context. This is a top-down variant of . BThis function applies a signature function to the given context. )Compose two monadic term homomorphisms. )Compose two monadic term homomorphisms. )Compose two monadic term homomorphisms. HCompose a monadic algebra with a monadic term homomorphism to get a new  monadic algebra. HCompose a monadic algebra with a term homomorphism to get a new monadic  algebra. :This function composes two monadic signature functions. )Compose two monadic term homomorphisms. :This function composes two monadic signature functions. :This function composes two monadic signature functions. 4Construct an anamorphism from the given coalgebra. Shortcut fusion variant of . CConstruct a monadic anamorphism from the given monadic coalgebra. 4Construct a paramorphism from the given r-algebra. DConstruct a monadic paramorphism from the given monadic r-algebra. 6Construct an apomorphism from the given r-coalgebra. EConstruct a monadic apomorphism from the given monadic r-coalgebra. This function applies  at the tip of the term. 6Construct a histomorphism from the given cv-algebra. FConstruct a monadic histomorphism from the given monadic cv-algebra. 7Construct a futumorphism from the given cv-coalgebra. GConstruct a monadic futumorphism from the given monadic cv-coalgebra. CConstruct a futumorphism from the given generalised cv-coalgebra. FThis function applies a signature function after a term homomorphism. AThis function applies the given algebra bottom-up while applying : the given term homomorphism top-down. Thereby we have no & requirements on the source signature f. PFFP1non-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>None69This type represents transition functions of generalised B deterministic top-down tree acceptors (GDDTAs) which have access ;This type is needed to construct the product of two DDTAs. ;This type represents transition functions of deterministic " top-down tree acceptors (DDTAs). ;This type represents transition functions of deterministic $ top-down tree transducers (DDTTs).  9This type represents transition functions of generalised C deterministic bottom-up tree acceptors (GDUTAs) which have access  to an extended state space.  ;This type represents transition functions of deterministic # bottom-up tree acceptors (DUTAs).  ;This type represents transition functions of deterministic % bottom-up tree transducers (DUTTs).  @This type represents stateful term homomorphisms. Stateful term D homomorphisms have access to a state that is provided (separately) E by a bottom-up or top-down state transformation function (or both).  #left-biased union of two mappings. .This operator constructs a singleton mapping. This is the empty mapping. ?This function provides access to components of the states from  below. >This function provides access to components of the state from  above Turns the explicit parameters ?above and ?below into explicit  ones. 9This function turns a stateful homomorphism with a fully 9 polymorphic state type into a (stateless) homomorphism. <This function transforms a DUTT transition function into an  algebra. 5This function runs the given DUTT on the given term. This function is a variant of  that additionally % returns the final state of the run. This function generalises  to contexts. Therefore, > additionally, a transition function for the holes is needed. <This function composes two DUTTs. (see TATA, Theorem 6.4.5) /This function composes a DUTT with an algebra. BThis combinator composes a DUTT followed by a signature function. BThis combinator composes a signature function followed by a DUTT. <This combinator composes a DUTT followed by a homomorphism. <This combinator composes a homomorphism followed by a DUTT. AChanges the state space of the DUTA using the given isomorphism. BThis combinator runs the given DUTA on a term returning the final  state of the run. @This function combines the product DUTA of the two given DUTAs. ;This function constructs a DUTT from a given stateful term ; homomorphism with the state propagated by the given DUTA. >This function applies a given stateful term homomorphism with 7 a state space propagated by the given DUTA to a term. This is a variant of # that also returns the final state  of the run.  6This combinator turns an arbitrary DUTA into a GDUTA. !?This combinator turns a GDUTA with the smallest possible state  space into a DUTA. "(This combinator runs a GDUTA on a term. #5This combinator constructs the product of two GDUTA. %6Thsis function runs the given DDTT on the given tree. 5This function runs the given DDTT on the given tree. &;This function composes two DDTTs. (see Z. Fulop, H. Vogler  Syntax-Directed Semantics, Theorem 3.39) ':This function composes a signature function after a DDTT. (0This function composes a DDTT after a function. )4This function composes a homomorphism after a DDTT. *4This function composes a DDTT after a homomorphism. +AChanges the state space of the DDTA using the given isomorphism. ,BThis function constructs the product DDTA of the given two DDTAs. @This function constructs the pointwise product of two maps each  with a default value. ?Apply the given state mapping to the given functorial value by E adding the state to the corresponding index if it is in the map and . otherwise adding the provided default state. -=This function constructs a DDTT from a given stateful term-- ; homomorphism with the state propagated by the given DDTA. .@This function applies a given stateful term homomorphism with a 5 state space propagated by the given DDTA to a term. /6This combinator turns an arbitrary DDTA into a GDDTA. 0?This combinator turns a GDDTA with the smallest possible state  space into a DDTA. 1AThis combinator constructs the product of two dependant top-down  state transformations. 2This is a synonym for 1. 3:This combinator combines a bottom-up and a top-down state A transformations. Both state transformations can depend mutually  recursive on each other. 4@This combinator runs a stateful term homomorphisms with a state 9 space produced both on a bottom-up and a top-down state  transformation. B      !"#$%&'()*+,-./012341JK      !"#$%&'()*+,-./01234/ -.4    !"#$%&('*)+,/0123 <      !"#$%&'()*+,-./01234jnon-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>Noneknon-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>None2non-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>None>KProject the outermost layer of a term to a sub signature. If the signature  g is compound of n atomic signatures, use projectn instead. HTries to coerce a termcontext to a term!context over a sub-signature. If  the signature g is compound of n atomic signatures, use   deepProjectn instead. [MInject a term where the outermost layer is a sub signature. If the signature  g is compound of n atomic signatures, use injectn instead. eKInject a term over a sub signature to a term over larger signature. If the  signature g is compound of n atomic signatures, use  deepInjectn  instead. s=This function injects a whole context into another context. t5This function lifts the given functor to a context. u7This function applies the given context with hole type a to a family f) of contexts (possibly terms) indexed by a. That is, each hole h is replaced by the context f h. F56789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvF56789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvF56789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvF56789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuv3non-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>None wLTransform a function with a domain constructed from a functor to a function I with a domain constructed with the same functor, but with an additional  annotation. xLTransform a function with a domain constructed from a functor to a function J with a domain constructed with the same functor, but with an additional  annotation. yDStrip the annotations from a term over a functor with annotations. z)Lift a term homomorphism over signatures f and g to a term homomorphism ; over the same signatures, but extended with annotations. {2Lift a stateful term homomorphism over signatures f and g to J a stateful term homomorphism over the same signatures, but extended with  annotations. |1Lift a bottom-up tree transducer over signatures f and g to a B bottom-up tree transducer over the same signatures, but extended  with annotations. }0Lift a top-down tree transducer over signatures f and g to a A top-down tree transducer over the same signatures, but extended  with annotations. ~1Lift a monadic term homomorphism over signatures f and g to a monadic N term homomorphism over the same signatures, but extended with annotations. 5Annotate each node of a term with a constant value. This function is similar to > but applies to signatures +with an annotation which is then ignored. wxyz{|}~|}~wxyz{|}~~|}wxyz{|}~ wxyz{|}~non-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>None4This function implements equality of values of type f a modulo the equality of a4 itself. If two functorial values are equal in this sense,  returns a " value containing a list of pairs =consisting of corresponding components of the two functorial  values. v is propagated through sums. From an v functor an  instance of the corresponding  term type can be derived. vwvw4non-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>None:This function returns a list of all subterms of the given + term. This function is similar to Uniplate's universe function. ?This function returns a list of all subterms of the given term 1 that are constructed from a particular functor. >This function transforms every subterm according to the given = function in a bottom-up manner. This function is similar to  Uniplate's  transform function. Monadic version of . ;This function computes the generic size of the given term, - i.e. the its number of subterm occurrences. =This function computes the generic height of the given term.    lnon-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>NoneHGiven the name of a type class, where the first parameter is a functor, ( lift it to sums of functors. Example: class ShowF f where ... is lifted  as 9instance (ShowF f, ShowF g) => ShowF (f :+: g) where ... . IUtility function to case on a functor sum, without exposing the internal  representation of sums. non-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>NoneQRQRmnon-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>NoneIDerive smart constructors for a type constructor of any first-order kind I taking at least one argument. The smart constructors are similar to the  ordinary constructors, but an [ is automatically inserted. nnon-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>NoneFDerive smart constructors with products for a type constructor of any K parametric kind taking at least one argument. The smart constructors are / similar to the ordinary constructors, but an  is automatically  inserted. 5non-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>None <This type represents position representations for a functor  f<. It is a function that extracts a number of components (of  polymorphic type a-) from a functorial value and puts it into a  list. >This type represents algebras which have terms with thunks as  carrier. +This type represents contexts with thunks. (This type represents terms with thunks. 8This function turns a monadic computation into a thunk. =This function evaluates all thunks until a non-thunk node is  found. >This function first evaluates the argument term into whnf via  : and then projects the top-level signature to the desired > subsignature. Failure to do the projection is signalled as a  failure in the monad. 9This function inspects the topmost non-thunk node (using  #) according to the given function.  Variant of ! with flipped argument positions @This function inspects the topmost non-thunk nodes of two terms  (using #) according to the given function. $This function evaluates all thunks. 8This function evaluates all thunks while simultaneously ? projecting the term to a smaller signature. Failure to do the 9 projection is signalled as a failure in the monad as in . %This function inspects a term (using ) according to the  given function.  Variant of ! with flipped argument positions (This function inspects two terms (using  ) according  to the given function. BThis combinator runs a monadic catamorphism on a term with thunks ;This combinator runs a catamorphism on a term with thunks. :This combinator makes the evaluation of the given functor D application strict by evaluating all thunks of immediate subterms.  This combinator is a variant of  that only makes a subset = of the arguments of a functor application strict. The first D argument of this combinator specifies which positions are supposed  to be strict. 5This function decides equality of terms with thunks.   onon-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>NoneDerive an instance of   for a type constructor of any 2 first-order kind taking at least one argument.         non-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>NoneDerive an instance of + for a type constructor of any first-order & kind taking at least one argument. Derive an instance of  for a type constructor. &PQRSTUVWXYZ[\]^vwxyz{&PQRSvwxyz{TUVWXY[Z\]^pnon-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>Noney is propagated through sums. From an y functor an  instance of the corresponding  term type can be derived. yzyz6non-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>None3Fully evaluate a value over a foldable signature. \]\]qnon-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>None Instances of V" are closed under forming sums. This lifts instances of V to instances of  &for the corresponding context type. This lifts instances of V to instances of V for % the corresponding context functor. This lifts instances of V to instances of  "for the corresponding term type. VWXYVWXY7non-portable (GHC Extensions) experimental=Patrick Bahr <paba@diku.dk> and Tom Hvitved <hvitved@diku.dk>NoneGThis multiparameter class defines functors with variables. An instance   HasVar f v denotes that values over f% might contain and bind variables of  type v. Indicates whether the f constructor is a variable. The  default implementation returns Nothing. ,Indicates the set of variables bound by the f constructor 9 for each argument of the constructor. For example for a  non-recursive let binding:    data Let e = Let Var e e  instance HasVars Let Var where ? bindsVars (Let v x y) = Map.fromList [(y, (Set.singleton v))]   ? If, instead, the let binding is recursive, the methods has to  be implemented like this:   A bindsVars (Let v x y) = Map.fromList [(x, (Set.singleton v)), ? (y, (Set.singleton v))]   : This indicates that the scope of the bound variable also 9 extends to the right-hand side of the variable binding. 2The default implementation returns the empty map. BThis type represents substitutions of terms, i.e. finite mappings  from variables to terms. <This type represents substitutions of contexts, i.e. finite & mappings from variables to contexts. AThis multiparameter class defines substitution of values of type t for  variables of type v in values of type a. AThis combinator pairs every argument of a given constructor with C the set of (newly) bound variables according to the corresponding   type class instance. This combinator combines  with the generic  function.  This combinator combines  with the generic ! function. 9Convert variables to holes, except those that are bound. "MAlgebra for checking whether a variable is contained in a term, except those  that are bound. DThis function checks whether a variable is contained in a context. #LAlgebra for generating a set of variables contained in a term, except those  that are bound. FThis function computes the list of variables occurring in a context. EThis function computes the set of variables occurring in a context. FThis function computes the set of variables occurring in a constant. Apply the given substitution. )This function composes two substitutions s1 and s2 . That is, Dapplying the resulting substitution is equivalent to first applying s2 and then s1. $ "#%&'  $ "#%&'8non-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>None(/This is an auxiliary function for implementing  . It behaves  similarly as match3 but is oblivious to non-linearity. Therefore, the Esubstitution that is returned maps holes to non-empty lists of terms B(resp. contexts in general). This substitution is only a matching =substitution if all elements in each list of the substitution's range  are equal. This function takes a context c! as the first argument and tries to match it against the term t% (or in general a context with holes in a). The context c matches the term t if there is a matching substitution s6 that maps holes to terms (resp. contexts in general) &such that if the holes in the context c are replaced according to the substitution s , the term t$ is obtained. Note that the context c7 might be non-linear, i.e. has multiple holes that are Dequal. According to the above definition this means that holes with 5equal holes have to be instantiated by equal terms! This function is similar to  but instead of a context it 3matches a term with variables against a context. ((9non-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>None@This type represents a potential single step reduction from any @ input. If there is no single step then the return value is the  input together with False'. Otherwise, the successor is returned  together with True. @This type represents a potential single step reduction from any  input. BThis type represents term rewriting systems (TRSs) from signature f to signature g over variables of type v. 7This type represents term rewrite rules from signature f to  signature g over variables of type v  This type represents variables. This type represents recursive program schemes. CThis function tries to match the given rule against the given term D(resp. context in general) at the root. If successful, the function 9returns the right hand side of the rule and the matching substitution. @This function tries to match the rules of the given TRS against B the given term (resp. context in general) at the root. The first A rule in the TRS that matches is then used and the corresponding @ right-hand side as well the matching substitution is returned. ?This function tries to apply the given rule at the root of the Cgiven term (resp. context in general). If successful, the function 7returns the result term of the rewrite step; otherwise Nothing. BThis function tries to apply one of the rules in the given TRS at Ethe root of the given term (resp. context in general) by trying each rule one by one using % until one rule is applicable. If no rule is applicable Nothing is returned. 2This is an auxiliary function that turns function f of type  (t -> Maybe t) into functions f' of type  t -> (t,Bool). f' x  evaluates to (y,True) if f x evaluates to Just y , and to   (x,False) if f x evaluates to Nothing. This function is useful = to change the output of functions that apply rules such as . >This function performs a parallel reduction step by trying to Gapply rules of the given system to all outermost redexes. If the given term contains no redexes, Nothing is returned. >This function performs a parallel reduction step by trying to Bapply rules of the given system to all outermost redexes and then Crecursively in the variable positions of the redexes. If the given #term does not contain any redexes, Nothing is returned. BThis function applies the given reduction step repeatedly until a normal form is reached. :non-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>NoneAThis class specifies the decomposability of a functorial value. .This function decomposes a functorial value. 0This type represents decompositions of terms. ;This type represents decompositions of functorial values. =This function computes the structure of a functorial value. >This function computes the arguments of a functorial value. "This function decomposes a term. )  );non-portable (GHC Extensions) experimentalPatrick Bahr <paba@diku.dk>None BThis is the unification monad that is used to run the unification  algorithm. >This type represents the state for the unification algorithm. 8This type represents errors that might occur during the unification. )This type represents list of equations. =This type represents equations between terms over a specific  signature. =This is used in order to signal a failed occurs check during  unification. >This is used in order to signal a head symbol mismatch during  unification. ?This function applies a substitution to each term in a list of  equations. <This function returns the most general unifier of the given :equations using the algorithm of Martelli and Montanari. >This function runs a unification monad with the given initial  list of equations. **rnon-portable (GHC Extensions) experimental:Patrick Bahr <paba@diku.dk>, Tom Hvitved <hvitved@diku.dk>Nonevwyz|}~56789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~<non-portable (GHC Extensions) experimentalTom Hvitved <hvitved@diku.dk>None"The desugaring term homomorphism. Desugar a term. $Lift desugaring to annotated terms. +Default desugaring instance. +,+,-stusvwsxyz{|z{}z{~                                                                  ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^^_``abbcdefghijklmnopqrstuvwxyz{@|@}~~ABBBCDEEEEEEFFFGHIJKLLLMNOPQQSSSTUUUVVVyWWWWWW            !!!!!!!!!!!!!!!!!! ! ! ! ! !!!!!!!!!!!!!!!!!! !!!"!#!$!%!&!'!(!)!*!+!,!-!.!/!0!1!2!3!4!!!!!"5":"6"7"8";#####Z$$$$$$$$$\]%%%%&~&~&&^__'''''''''''''((((()))))))))))))))))****************** * * * * ****************** *!*"*#*$*%*&*'*(*)***+*,*-*.*/*0*1*2*3*4+5+6+7+8+9+:+;,,,>,?de---B-Cfghh...../////////z/{///00000000000000000000000000000000000000000000y00000000000000000000000000111111111111111111111111111111111 1 1 1 1 1111111111222222222222222222 2 2 2 2 222222222222222222 2!2"2#2$2%2&2'2(2)2*2+2,2-2.2/202122222223242235363738333393:3;444444444ll mn5E5G5I5J5K5L5M5!5"5#5O5Q5$5%5&5'5(5S5)5*o+o,o-./6077777717777777828394959697998999:9;9<9=9>9?9@:A:B:C:D:E::F:G:H;I;J;J;K;L;M;M;N;O;P;Q;R;S;T;U;V;W;X;Y;Z;[<<<<<\]^\]^_`abcdefghijk l m n o p q r=s=t=u>v>w>x y z { | }~    ~Flmno@@@@@@@@@@@AAAAAAAAAAAAAABCCDDEEEGHHHIILLLNNRRRRSSSVDabcdghiW a b c d    g h i   XsXtXuYvYwYxs######%%%%%%&&^D```````'''''''''1'''''''(()a)b)c)d)))g)h)i))asataubvbwbx*y*z*{,|,,,,,------fDiiii..///0000p000000 1 1 1 1 1111111111z11111jsjtjukvkwkx2y2z2{2 !"#5$o%o&o'o(o)p*pp+p,6-6.6/q0q1q2q3q4q57776st778sv97777778::;;<<<=>compdata-0.6.1.1Data.Comp.DeriveData.Comp.NumberData.Comp.MultiParam.AlgebraData.Comp.MultiParam.FreshMData.Comp.Param.FreshMData.Comp.Param.DifunctorData.Comp.Param.DitraversableData.Comp.Param.OpsData.Comp.Param.TermData.Comp.Param.AlgebraData.Comp.Param.SumData.Comp.Param.AnnotationData.Comp.Param.EqualityData.Comp.Param.OrderingData.Comp.Param.ThunkData.Comp.Multi.HFunctorData.Comp.Multi.HFoldableData.Comp.Multi.HTraversableData.Comp.MultiParam.HDifunctor#Data.Comp.MultiParam.HDitraversableData.Comp.MultiParam.TermData.Comp.Multi.TermData.Comp.Automata.ProductData.Comp.Param.DeriveData.Comp.ShowData.Comp.Multi.DeriveData.Comp.Param.DesugarData.Comp.MultiParam.DeriveData.Comp.Equality Data.Comp.OpsData.Comp.Multi.AlgebraData.Comp.Multi.OpsData.Comp.Multi.SumData.Comp.Multi.AnnotationData.Comp.Multi.EqualityData.Comp.Multi.GenericData.Comp.Multi.OrderingData.Comp.Multi.NumberData.Comp.Multi.VariablesData.Comp.Multi.DesugarData.Comp.MultiParam.OpsData.Comp.MultiParam.SumData.Comp.MultiParam.AnnotationData.Comp.MultiParam.EqualityData.Comp.MultiParam.OrderingData.Comp.MultiParam.DesugarData.Comp.TermData.Comp.AlgebraData.Comp.Automata Data.Comp.SumData.Comp.AnnotationData.Comp.GenericData.Comp.ThunkData.Comp.DeepSeqData.Comp.VariablesData.Comp.MatchingData.Comp.TermRewritingData.Comp.DecomposeData.Comp.UnificationData.Comp.Desugar"Data.Comp.Param.Derive.Projections!Data.Comp.Param.Derive.InjectionsData.Comp.Param!Data.Comp.Automata.Product.DeriveData.Comp.Derive.UtilsData.Comp.Derive.ShowData.Comp.Derive.FoldableData.Comp.Derive.TraversableData.Comp.Derive.ArbitraryData.Comp.Derive.DeepSeqData.Comp.Multi.Derive.HFunctor Data.Comp.Multi.Derive.HFoldable#Data.Comp.Multi.Derive.HTraversableData.Comp.Param.Derive.EqualityData.Comp.Param.Derive.OrderingData.Comp.Param.Derive.Show Data.Comp.Param.Derive.Difunctor$Data.Comp.Param.Derive.Ditraversable(Data.Comp.Param.Derive.SmartConstructors)Data.Comp.Param.Derive.SmartAConstructorsData.Comp.Param.Derive.LiftSumData.Comp.Param.Show Data.Comp.MultiParam.Derive.Show&Data.Comp.MultiParam.Derive.HDifunctorData.Comp.Derive.EqualityData.Comp.Derive.OrderingData.Comp.Multi.Derive.Show"Data.Comp.Multi.Derive.Projections!Data.Comp.Multi.Derive.InjectionsData.Comp.Multi.Derive.EqualityData.Comp.Multi(Data.Comp.Multi.Derive.SmartConstructors)Data.Comp.Multi.Derive.SmartAConstructorsData.Comp.Multi.Derive.OrderingData.Comp.Multi.Derive.LiftSumData.Comp.Multi.Show'Data.Comp.MultiParam.Derive.Projections&Data.Comp.MultiParam.Derive.InjectionsData.Comp.MultiParam$Data.Comp.MultiParam.Derive.Equality-Data.Comp.MultiParam.Derive.SmartConstructors$Data.Comp.MultiParam.Derive.Ordering.Data.Comp.MultiParam.Derive.SmartAConstructors#Data.Comp.MultiParam.Derive.LiftSumData.Comp.MultiParam.ShowData.Comp.Derive.ProjectionsData.Comp.Derive.InjectionsData.Comp.Derive.LiftSum"Data.Comp.Derive.SmartConstructors#Data.Comp.Derive.SmartAConstructorsData.Comp.Derive.HaskellStrictData.Comp.OrderingData.Comp.Arbitrary Data.CompbaseGHC.BaseFunctor Data.FoldableFoldableData.Traversable TraversableQuickCheck-2.5.1.1Test.QuickCheck.Arbitraryshrink arbitrary Arbitrarydeepseq-1.3.0.1Control.DeepSeqrnfNFDatatransformers-0.3.0.0Data.Functor.Compose getComposeComposeNameFreshM nameCoercewithName evalFreshM Difunctordimapdifmap DitraversabledimapM disequenceRemAremADistAnninjectAprojectA:&::*::<:injproj:+:InrInlffstfsnd ParamFunctortermMTermunTermTrmContextNoHoleHoleCxtVarInsimpCxttoCxtcxtMapCVCoalg'CVCoalgMCVCoalgCVAlgMCVAlgRCoalgMRCoalgRAlgMRAlgCoalgMCoalgHomMDHomMSigFunMDCxtFunMSigFunMHomSigFunCxtFunAlgMAlgfreecatacata'appCxtalgMfreeMcataMcataM'appHomappHom'compHomcompAlg compAlgSigFun appSigFun appSigFun' compSigFun compHomSigFun compSigFunHomhomsigFunMhomMappHomMappTHomMappHomM' appTHomM'homMD appSigFunM appTSigFunM appSigFunM' appTSigFunM' appSigFunMD appTSigFunMDcompHomM compHomM'compSigFunHomMcompSigFunHomM'compAlgM compAlgM'compAlgSigFunMcompAlgSigFunM' compSigFunManaanaMparaparaMapoapoMhistohistoMfutufutuMfutu'proj2proj3proj4proj5proj6proj7proj8proj9proj10projectproject2project3project4project5project6project7project8project9 project10 deepProject deepProject2 deepProject3 deepProject4 deepProject5 deepProject6 deepProject7 deepProject8 deepProject9 deepProject10inj2inj3inj4inj5inj6inj7inj8inj9inj10injectinject'inject2inject3inject4inject5inject6inject7inject8inject9inject10 deepInject deepInject2 deepInject3 deepInject4 deepInject5 deepInject6 deepInject7 deepInject8 deepInject9 deepInject10 injectCxtliftCxtliftAliftA'stripApropAnnpropAnnMannproject'EqDeqDPEqpeqOrdDcompareDPOrdpcomparecompListAlgTThunkCxtTTrmTTermTthunkwhnfwhnf'whnfPrnfTnfnfTPrnfPr evalStrictstrictstrict':.:CompHFunctorhfmapNatM:=>:->AunAEunEKunKIunI HFoldablehfoldhfoldMaphfoldrhfoldlhfoldr1hfoldl1htoListkfoldrkfoldl HTraversablehmapM htraverse HDifunctorhdimapHDitraversablehdimapMhfmapCxt hdimapMCxtAlgM'freeM'hom'Const constTerm:<prNumbered unNumberednumberderiveShowFshowF makeShowF makeFoldablemakeTraversable ArbitraryF arbitraryF' arbitraryFshrinkF makeArbitrarymakeArbitraryFNFDataFrnfF makeNFDataF makeHFunctor makeHFoldablemakeHTraversablemakeEqDmakeOrdDShowDshowD makeShowD makeDifunctormakeDitraversablesmartConstructorssmartAConstructorsliftSumcaseDDesugardesugHom desugHom'desugardesugarAShowHDshowHD makeShowHDmakeHDifunctorEqFeqFmakeEqFOrdFcompareFmakeOrdFliftMAlgKShowkshowShowHFshowHFshowHF' makeShowHFfstsnd substHoles injectConst injectConst2 injectConst3 projectConstEqHFeqHFKEqkeqheqModmakeEqHFsubterms subterms' transform transformMquerysubssubs'sizedepthOrdHF compareHFKOrdkcompare makeOrdHFcaseHHasVarsisVar bindsVarsSubstCxtSubstGSubst varsToHoles containsVar variableList variables variables'appSubst compSubstEqHDeqHDmakeEqHDOrdHD compareHD makeOrdHDcaseHDPTerm compCoalg compCVCoalgcompHomSigFunMana' DDownState DownState DownTransDUpStateUpStateUpTransQHom&|->obelowabovepureHom runUpTrans compUpTranscompAlgUpTranscompSigUpTranscompUpTransSigcompHomUpTranscompUpTransHom tagUpState runUpState prodUpStateupTransrunUpHom runUpHomStdUpStateupState runDUpState prodDUpState<*> runDownTrans compDownTranscompSigDownTranscompDownTransSigcompHomDownTranscompDownTransHom tagDownState prodDownState downTrans runDownHom dDownState downStateprodDDownState>*< runDStaterunQHom substHoles'propAnnQ propAnnUp propAnnDowneqMod transform'gsizeheightcaseFeval#>eval2deepEval#>> deepEval2cataTMcataTstrictAteqT haskellStricthaskellStrict'makeHaskellStrict makeFunctor makeNFDatarnfF' substVarsmatchCxt matchTermBStepStepTRSRuleRPS matchRule matchRulesappRuleappTRSbStep parTopStep parallelStepreduce Decomposedecomp DecompTermDecompFun structure arguments decomposeUnifyM UnifyStateusEqsusSubst UnifErrorHeadSymbolMismatchFailedOccursCheck EquationsEquationfailedOccursCheckheadSymbolMismatch appSubstEqunify runUnifyM withNextEqputEqs putBindingrunUnify unifyStepunFreshM $fOrdName $fShowName$fDifunctor(->) $fFunctorf$fDistAnn:+:p:+:$fDistAnnfp:&: $fRemA:&:f $fRemA:+::+:$fDitraversable:&:$fDifunctor:&: $f:<:f:+: $f:<:f:+:0$f:<:ff$fDitraversable:+:$fDifunctor:+: coerceTermM$fParamFunctor[]$fParamFunctorEither$fParamFunctorMaybe projectTipfmapCxt dimapMCxtprojnprojectn deepProjectninjninjectn deepInjectn$fEq:+:$fOrd:+: $fShow:+:$fEqTerm$fEqDCxtghc-prim GHC.ClassesEq$fEqD:+:$fPEqCxt$fPEqa$fPEq[] $fOrdTerm $fOrdDCxtOrd $fOrdD:+: $fPOrdCxt$fPOrda$fPOrd[]$fOrdK$fEqK $fFunctorK $fHFunctorf$fHTraversableCxt$fHFoldableCxt $fHFunctorCxtDirRL genAllInstsgenDirsgenInstgenTypegenPatgenEx genPatExppairT$f: