!6u"      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqr s t u v w x y z { | } ~        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,- . / 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'{'|(}(~(((((((((((((((((((=(c) 2010-2011 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None<G[ compdata This is the Q$-lifted version of 'abstractNewtype. compdataThis function abstracts away newtype# declaration, it turns them into data declarations. compdataoThis function provides the name and the arity of the given data constructor, and if it is a GADT also its type. compdata-Same as normalCon' but expands type synonyms.compdata9Same as normalConExp' but retains strictness annotations.compdataAuxiliary function to extract the first argument of a binary type application (the second argument of this function). If the second argument is NothingI or not of the right shape, the first argument is returned as a default.compdataAuxiliary function to extract the first argument of a type application (the second argument of this function). If the second argument is NothingI or not of the right shape, the first argument is returned as a default.compdataLThis function provides the name and the arity of the given data constructor.compdata7This function returns the name of a bound type variablecompdata]This function provides a list (of the given length) of new names based on the given string.compdata~Helper function for generating a list of instances for a list of named signatures. For example, in order to derive instances  and ShowF for a signature Exp5, use derive as follows (requires Template Haskell): *$(derive [makeFunctor, makeShowF] [''Exp])compdataNApply a class name to type arguments to construct a type class constraint.compdataThis function checks whether the given type constraint is an equality constraint. If so, the types of the equality constraint are returned. compdataThis function lifts type class instances over sums 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 that is used to construct sums. Since this function is generic it assumes as its first argument the name of the function that is used to lift methods over sums i.e. a function of type D(f t1 .. tn -> t) -> (g t1 .. tn -> t) -> ((f :+: g) t1 .. tn -> t) where :+: is the sum type constructor. The second argument to this function is expected to be the name of that constructor. The last argument is the name of the class whose instances should be lifted over sums.  )(c) 2010-2011 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None<KcompdataDerive an instance of P for a type constructor of any first-order kind taking at least one argument. *(c) 2010-2011 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None<S1compdataConstructor printing. compdata Signature printing. An instance ShowF f gives rise to an instance  Show (Term f). "compdataDerive an instance of  P for a type constructor of any first-order kind taking at least one argument. #compdataDerive an instance of P for a type constructor of any first-order kind taking at least one argument.  !"#+(c) 2010-2011 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None<V$compdataDerive an instance of P for a type constructor of any first-order kind taking at least one argument. $,(c) 2010-2011 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None<\%compdata Signature equality. An instance EqF f gives rise to an instance  Eq (Term f). 'compdataDerive an instance of %P for a type constructor of any first-order kind taking at least one argument. %&'-(c) 2010-2011 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None<aB(compdata Signature ordering. An instance OrdF f gives rise to an instance  Ord (Term f). *compdataDerive an instance of (P for a type constructor of any first-order kind taking at least one argument. ()*.(c) 2011 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None<f+compdata#Signature normal form. An instance  NFDataF f gives rise to an instance NFData (Term f). -compdataDerive an instance of +P for a type constructor of any first-order kind taking at least one argument. +,-/(c) 2011 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None&'<yj.compdata#Signature arbitration. An instance  ArbitraryF f gives rise to an instance Arbitrary (Term f). 2compdataDerive an instance of . for a type constructor of any first-order kind taking at least one argument. It is necessary that all types that are used by the data type definition are themselves instances of . compdata4This function generates a declaration of the method , for the given list of constructors using .compdataThis function generates a declaration of a generator having the given name using the given constructors, i.e., something like this: % <name> :: Gen <type> <name> = ... where <type> 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 .compdata5This function generates a declaration for the method 1Z using the given constructors. The constructors are supposed to belong to the same type../012(c) 2014 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None 345<>?AKN5compdata"left-biased union of two mappings.6compdata-This operator constructs a singleton mapping.7compdataThis is the empty mapping.8compdataVThis function constructs the pointwise product of two maps each with a default value.9compdatakReturns the value at the given key or returns the given default when the key is not an element of the map.:compdataAThis type is used for numbering components of a functorial value.=compdatalThis function numbers the components of the given functorial value with consecutive integers starting at 0.>compdataVThis function constructs the pointwise product of two maps each with a default value.3475968:;<=>?@:;<=475968>?@35061(c) 2011 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)Safe345;<=>?CFQSTVEcompdata?This data type denotes the composition of two functor families.Gcompdata~This class represents higher-order functors (Johann, Ghani, POPL '08) which are endofunctors on the category of endofunctors.HcompdataA higher-order functor f% also maps a natural transformation g :-> h to a natural transformation  f g :-> f hJcompdata#This type represents co-cones from f to a. f :=> a is isomorphic to f :-> K aKcompdata-This type represents natural transformations.Rcompdata"The parametrised constant functor.UcompdataThe identity Functor.EFGHIJKLMNOPQRSTUVWXGHKJIUVWRSTLMNOPQXEFE5J0K0(c) 2011 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)Safe&';<=>?QSTVxbcompdata)Higher-order functors that can be folded.Minimal complete definition: d or e. bcdefghijk bcdefghjki0(c) 2011 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None<blcompdataDerive an instance of GR for a type constructor of any higher-order kind taking at least two arguments. Gl1(c) 2011 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None<mcompdataDerive an instance of bR for a type constructor of any higher-order kind taking at least two arguments. bm(c) 2011 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)Safe&';<=>?QSTVocompdatayMap each element of a structure to a monadic action, evaluate these actions from left to right, and collect the results.PAlternative type in terms of natural transformations using functor composition :.:: ;hmapM :: Monad m => (a :-> m :.: b) -> t a :-> m :.: (t b) nopnop2(c) 2011 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None<8qcompdataDerive an instance of nR for a type constructor of any higher-order kind taking at least two arguments. nq (c) 2014 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None <>?AFKNSTscompdata"left-biased union of two mappings.tcompdata-This operator constructs a singleton mapping.ucompdataThis is the empty mapping.vcompdataVThis function constructs the pointwise product of two maps each with a default value.wcompdatakReturns the value at the given key or returns the given default when the key is not an element of the map.xcompdataAThis type is used for numbering components of a functorial value.{compdatalThis function numbers the components of the given functorial value with consecutive integers starting at 0. nruswtvxyz{| xyz{nruswtv|s0t1 (c) 2011 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None &'<EFQSTVccompdata1A (higher-order) term is a context with no holes.compdataA context might contain holes.compdata!Phantom type that signals that a  does not contain holes.compdata!Phantom type that signals that a  might contain holes.compdataThis data type represents contexts over a signature. Contexts are terms containing zero or more holes. The first type parameter is supposed to be one of the phantom types  and . The second parameter is the signature of the context. The third parameter is the type family of the holes. The last parameter is the index/label.compdataThis function converts a constant to a term. This assumes that the argument is indeed a constant, i.e. does not have a value for the argument type of the functor f.compdata;This function unravels the given term at the topmost layer.compdataCCast a term over a signature to a context over the same signature.  3(c) 2014 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)Safe ,-<FSTcompdataThis type family returns TrueX if the first argument is true; otherwise it checks the second argument for duplicates.compdataUThis type family checks whether its first argument is contained its second argument.compdatadThis type family checks whether the list of positions given as an argument contains any duplicates.compdataHThis type checks whether the argument (atomic) position has duplicates.compdata!This type family turns a list of atomic position into a list of simple positions5 by recursively splitting each position of the form  Sum p1 p2 into p1 and p2.compdataHelper type family for .compdataIf the argument is not L, this type family is the identity. Otherwise, the argument is of the form Found p?, and this type family does two things: (1) it checks whether p1 the contains duplicates; and (2) it compresses p using . If (1) finds no duplicates, Found (ComprPos p) is returned; otherwise  Ambiguous is returned.For (1) it is assumed that p does not contain  nested underneath a  or ) (i.e. only at the root or underneath a ,). We will refer to such positions below as atomic position. Positions not containing  are called simple positions.compdata lifted to .compdata lifted to .compdataHelper type family for .compdataHelper type family for .compdataHelper type family for . Note that we could have defined this as a type synonym. But if we do that, performance becomes abysmal. I presume that the reason for this huge impact on performance lies in the fact that right-hand side of the defining equation duplicates the two arguments l and r.compdatakThis type family takes a position type and compresses it. That means it replaces each nested occurrence of - Sum (prefix (Le Here)) (prefix (Ri Here))@ compdatalThis type is used in its promoted form only. It represents possible results for checking for subsumptions. % indicates a subsumption was found; + indicates no such subsumption was found. J indicates that there are duplicates on the left- or the right-hand side.compdataThis type is used in its promoted form only. It represents pointers from the left-hand side of a subsumption to the right-hand side. (c) 2014 Patrick BahrBSD3Patrick Bahr <paba@di.ku.dk> experimentalnon-portable (GHC Extensions)Safe+-;<=>?FSTV compdataThe constraint e :< p expresses that e is a component of the type p . That is, p. is formed by binary products using the type e. The occurrence of e% must be unique. For example we have Int :< (Bool,(Int,Bool)) but not Bool :< (Bool,(Int,Bool)).compdata-This function projects the component of type e$ out or the compound value of type p.5 '(c) 2010-2011 Patrick Bahr, Tom HvitvedBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)Safe&'+,-;<=>?AFSTV compdata%Remove annotations from a signature. compdataMThis class defines how to distribute an annotation over a sum of signatures. compdata'Inject an annotation over a signature. compdata(Project an annotation from a signature. compdataDThis data type adds a constant product (annotation) to a signature. compdata(Formal product of signatures (functors).compdata A constraint f :<: g expresses that the signature f is subsumed by g, i.e. f& can be used to construct elements in g.compdata$Formal sum of signatures (functors).compdatacUtility function to case on a functor sum, without exposing the internal representation of sums. 7788556 (c) 2011 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None &'<FQSTVE0compdata6This type represents monadic cv-coalgebras over monad m and functor f, and with domain a.compdata0This type represents cv-coalgebras over functor f and with domain a.compdata5This type represents monadic r-coalgebras over monad m and functor f with domain a.compdata/This type represents r-coalgebras over functor f and with domain a.compdata3This type represents monadic r-algebras over monad m and functor f and with domain a.compdata-This type represents r-algebras over functor f and with domain a.compdata+This type represents monadic term algebras.compdata.This type represents monadic context function.compdata1This type represents monadic signature functions.compdata(This type represents term homomorphisms.compdata&This type represents context function.compdata>This type represents uniform signature function specification.compdata9This type represents a monadic algebra. It is similar to ! but the return type is monadic.compdata!This type represents multisorted f-algebras with a family e of carriers.compdata+Construct a catamorphism for contexts over f with holes of type b, from the given algebra.compdata0Construct a catamorphism from the given algebra.compdataA generalisation of  from terms over f to contexts over f7, where the holes have the type of the algebra carrier.compdata;This function applies a whole context into another context.compdata>This function lifts a many-sorted algebra to a monadic domain.compdata3Construct a monadic catamorphism for contexts over f with holes of type b!, from the given monadic algebra.compdataThis is a monadic version of .compdataEThis function applies the given term homomorphism to a term/context.compdatafThis function applies the given term homomorphism to a term/context. This is the top-down variant of .compdata)This function composes two term algebras.compdata6This function composes a term algebra with an algebra.compdatabThis function applies a signature function to the given context. This is the top-down variant of .compdata@This function applies a signature function to the given context.compdata/This function composes two signature functions.compdataFLifts the given signature function to the canonical term homomorphism.compdataThis 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.compdataSThis function lifts the give monadic signature function to a monadic term algebra.compdataLThis function lifts the given signature function to a monadic term algebra.compdataUThis function applies the given monadic term homomorphism to the given term/context.compdatatThis function applies the given monadic term homomorphism to the given term/context. This is a top-down variant of .compdataQThis function applies the given monadic signature function to the given context.compdatapThis function applies the given monadic signature function to the given context. This is a top-down variant of .compdata1This function composes two monadic term algebras.compdataEThis function composes a monadic term algebra with a monadic algebra compdataFThis function composes a monadic term algebra with a monadic algebra.compdata9This function composes two monadic signature functions. compdatavThis function unfolds the given value to a term using the given 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. compdataThis 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.compdata@This function constructs a paramorphism from the given r-algebracompdataQThis function constructs a monadic paramorphism from the given monadic r-algebracompdataDThis function constructs an apomorphism from the given r-coalgebra.compdataSThis function constructs a monadic apomorphism from the given monadic r-coalgebra.compdatabThis function constructs the unique futumorphism from the given cv-coalgebra to the term algebra.compdatarThis function constructs the unique monadic futumorphism from the given monadic cv-coalgebra to the term algebra.334(c) 2011 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None<STLcompdata Signature printing. An instance ShowHF f gives rise to an instance KShow (HTerm f). compdataDerive an instance of R for a type constructor of any higher-order kind taking at least two arguments. (c) 2011 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)Safe&'+,-;<=>?AFQSTVYcompdataMThis class defines how to distribute an annotation over a sum of signatures.compdata5This function injects an annotation over a signature.compdatakThis data type adds a constant product to a signature. Alternatively, this could have also been defined as 0data (f :&: a) (g :: * -> *) e = f g e :&: a e .This is too general, however, for example for  productHHom.compdata A constraint f :<: g expresses that the signature f is subsumed by g, i.e. f& can be used to construct elements in g.compdataData type defining coproducts.compdatapUtility function to case on a higher-order functor sum, without exposing the internal representation of sums.       77556(c) 2011 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None &'+<QSTVkcompdataLProject the outermost layer of a term to a sub signature. If the signature g is compound of n atomic signatures, use projectn instead.compdataTries to coerce a termcontext to a term0context over a sub-signature. If the signature g is compound of n atomic signatures, use  deepProjectn instead.compdataNInject a term where the outermost layer is a sub signature. If the signature g is compound of n atomic signatures, use injectn instead.compdataVInject 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.compdata;This function injects a whole context into another context. compdata3This function lifts the given functor to a context.!compdata7This 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.   !"#  "# !(c) 2011 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None &'+<CQSTVx?$compdatahThis function returns a list of all subterms of the given term. This function is similar to Uniplate's universe function.%compdataoThis function returns a list of all subterms of the given term that are constructed from a particular functor.&compdataThis function transforms every subterm according to the given function in a bottom-up manner. This function is similar to Uniplate's  transform function.'compdataMonadic version of &.+compdatagThis function computes the generic size of the given term, i.e. the its number of subterm occurrences.,compdata;This function computes the generic depth of the given term. $%&'()*+, $%&'()*+,5(c) 2011 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None<}-compdataDerive smart constructors for a type constructor of any higher-order kind taking at least two arguments. The smart constructors are similar to the ordinary constructors, but an  is automatically inserted. -(c) 2014 Patrick BahrBSD3Patrick Bahr <paba@di.ku.dk> experimentalnon-portable (GHC Extensions)Safe+-;<=>?FSTV.compdataThe constraint e :< p expresses that e is a component of the type p . That is, p. is formed by binary products using the type e. The occurrence of e% must be unique. For example we have Int :< (Bool,(Int,Bool)) but not Bool :< (Bool,(Int,Bool))./compdata-This function projects the component of type e$ out or the compound value of type p..//..5(c) Patrick Bahr, 2011BSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None&';<=ST4compdata Signature equality. An instance EqHF f gives rise to an instance  KEq (HTerm f). 8compdata4This function implements equality of values of type f a modulo the equality of a; itself. If two functorial values are equal in this sense, eqMod returns a g value containing a list of pairs consisting of corresponding components of the two functorial values. ;compdataFrom an EqF functor an : instance of the corresponding term type can be derived.>compdataEqF is propagated through sums.4567845678"(c) 2011 Patrick Bahr, Tom HvitvedBSD3Tom Hvitved <hvitved@diku.dk> experimentalnon-portable (GHC Extensions)None &';<=STN?compdata Signature ordering. An instance OrdHF f gives rise to an instance  Ord (Term f). EcompdataOrdering of terms. GcompdataFrom an ? difunctor an ; instance of the corresponding term type can be derived. Hcompdata? is propagated through sums. ?@ABAB?@6"(c) 2011 Patrick Bahr, Tom HvitvedBSD3Tom Hvitved <hvitved@diku.dk> experimentalnon-portable (GHC Extensions)None;<=VdIcompdataDerive an instance of ?R for a type constructor of any parametric kind taking at least three arguments. ?@I7(c) 2011 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None;<=JcompdataDerive an instance of 4R for a type constructor of any higher-order kind taking at least two arguments. 4567J(c) 2011 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None&'+;<=>?QSTVKcompdataThis function transforms a function with a domain constructed from a functor to a function with a domain constructed with the same functor but with an additional annotation.LcompdataZThis function annotates each sub term of the given term with the given value (of type a).McompdataThis function transforms a function with a domain constructed from a functor to a function with a domain constructed with the same functor but with an additional annotation.NcompdataRThis function strips the annotations from a term over a functor with annotations. PcompdataThis function is similar to projectE but applies to signatures with an annotation which is then ignored. KLMNOP KLMNOP8"(c) 2011 Patrick Bahr, Tom HvitvedBSD3Tom Hvitved <hvitved@diku.dk> experimentalnon-portable (GHC Extensions)None<QcompdataDerive smart constructors with products for a type constructor of any parametric kind taking at least two arguments. The smart constructors are similar to the ordinary constructors, but an  is automatically inserted. Q(c) 2010-2011 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None<RcompdataGiven the name of a type class, where the first parameter is a higher-order 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 ... .Gblmnq-4567?@IJQR4567J?@IGlbmnq-QR(c) 2011 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None&';<=>?FQSTV;ScompdataIThis multiparameter class defines functors with variables. An instance  HasVar f v denotes that values over f, might contain and bind variables of type v. TcompdataIndicates whether the f@ constructor is a variable. The default implementation returns Nothing.Ucompdata,Indicates the set of variables bound by the fa constructor for each argument of the constructor. For example for a non-recursive let binding: rdata Let i e = Let Var (e i) (e i) instance HasVars Let Var where bindsVars (Let v x y) = y |-> Set.singleton v XIf, instead, the let binding is recursive, the methods has to be implemented like this: b bindsVars (Let v x y) = x |-> Set.singleton v & y |-> Set.singleton v qThis indicates that the scope of the bound variable also extends to the right-hand side of the variable binding.1The default implementation returns the empty map.compdatakThis function substitutes variables in a context according to a partial mapping from variables to contexts.compdataSame as T but it returns Nothing instead of Just v if .v@ is contained in the given set of variables.YcompdataThis combinator pairs every argument of a given constructor with the set of (newly) bound variables according to the corresponding S type class instance.compdataThis combinator combines Y with the mfmap function.compdataThis combinator combines Y with the generic f function.compdata8Convert variables to holes, except those that are bound.[compdataCThis function checks whether a variable is contained in a context. \compdataEThis function computes the list of variables occurring in a context. compdata]Algebra for checking whether a variable is contained in a term, except those that are bound.]compdataDThis function computes the set of variables occurring in a context. ^compdataDThis function computes the set of variables occurring in a context. `compdata)This function composes two substitutions s1 and s2O. That is, applying the resulting substitution is equivalent to first applying s2 and then s1. utsSTUVWXYZ[\]^_`STUXWVZ[]\^_`Ystu(c) 2011 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None &';<=ST9(c) 2011 Patrick BahrBSD3:Patrick Bahr <paba@diku.dk>, Tom Hvitved <hvitved@diku.dk> experimentalnon-portable (GHC Extensions)None<}EFGHIJKLMNOPQRSTUVWX   !"#$%&'()*+,45678KLMNOP"(c) 2011 Patrick Bahr, Tom HvitvedBSD3Tom Hvitved <hvitved@diku.dk> experimentalnon-portable (GHC Extensions)None;<=>?STkcompdata!The desugaring term homomorphism.ncompdataDesugar a term.ocompdata#Lift desugaring to annotated terms.pcompdataDefault desugaring instance.kmlnokmlno'(c) 2010-2011 Patrick Bahr, Tom HvitvedBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None &';<=EFQV rcompdataIPolymorphic definition of a term. This formulation is more natural than s9, it leads to impredicative types in some cases, though.scompdata$A term is a context with no holes. ucompdata!Phantom type that signals that a w does not contain holes.vcompdata!Phantom type that signals that a w might contain holes. wcompdataThis data type represents contexts over a signature. Contexts are terms containing zero or more holes. The first type parameter is supposed to be one of the phantom types v and uf. The second parameter is the signature of the context. The third parameter is the type of the holes. zcompdata{compdataThis function converts a constant to a term. This assumes that the argument is indeed a constant, i.e. does not have a value for the argument type of the functor f. |compdata,Convert a functorial value into a context. }compdataCCast a term over a signature to a context over the same signature. ~compdata=This function unravels the given term at the topmost layer. rstuvwxyz{|}~ wxyvutsrz~|}{(c) 2010-2011 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None&'<STcompdata4This function implements equality of values of type f a modulo the equality of a; itself. If two functorial values are equal in this sense,  returns a g value containing a list of pairs consisting of corresponding components of the two functorial values. compdata% is propagated through sums.compdataFrom an % functor an : instance of the corresponding term type can be derived.%&%&'(c) 2010-2011 Patrick Bahr, Tom HvitvedBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None &'<>?QSTVc[Jcompdata?This type represents a generalised cv-coalgebra over a functor f and carrier a. compdata;This type represents a monadic cv-coalgebra over a functor f and carrier a. compdata3This type represents a cv-coalgebra over a functor f and carrier a. compdata9This type represents a monadic cv-algebra over a functor f and carrier a. compdata1This type represents a cv-algebra over a functor f and carrier a. compdata:This type represents a monadic r-coalgebra over a functor f and carrier a. compdata3This type represents an r-coalgebra over a functor f and carrier a. compdata8This type represents a monadic r-algebra over a functor f and carrier a. compdata1This type represents an r-algebra over a functor f and carrier a. compdata8This type represents a monadic coalgebra over a functor f and carrier a. compdata0This type represents a coalgebra over a functor f and carrier a. compdataCThis type represents a monadic term homomorphism. It is similar to , but has monadic values also in the domain. compdata3This type represents a monadic term homomorphism. compdataEThis type represents a monadic signature function. It is similar to , but has monadic values also in the domain. compdata3This type represents a monadic signature function. compdata0This type represents a monadic context function.compdata*This type represents a term homomorphism. compdata*This type represents a signature function.compdata)This type represents a context function. compdata9This type represents a monadic algebra. It is similar to " but the return type is monadic. compdata/This type represents an algebra over a functor f and carrier a. compdata+Construct a catamorphism for contexts over f with holes of type a, from the given algebra. compdata1Construct a catamorphism from the given algebra. compdataA generalisation of  from terms over f to contexts over f:, where the holes have the type of the algebra carrier. compdata<This function applies a whole context into another context. compdataMConvert a monadic algebra into an ordinary algebra with a monadic carrier. compdata3Construct a monadic catamorphism for contexts over f with holes of type a", from the given monadic algebra. compdataAConstruct a monadic catamorphism from the given monadic algebra. compdataA generalisation of  from terms over f to contexts over fB, where the holes have the type of the monadic algebra carrier. compdataEThis function applies the given term homomorphism to a term/context. compdataXApply a term homomorphism recursively to a term/context. This is a top-down variant of .compdata Compose two term homomorphisms. compdataBCompose an algebra with a term homomorphism to get a new algebra. compdataDCompose a term homomorphism with a coalgebra to get a cv-coalgebra. compdataJCompose a term homomorphism with a cv-coalgebra to get a new cv-coalgebra.compdataAThis function applies a signature function to the given context. compdata`This function applies a signature function to the given context. This is a top-down variant of .compdata0This function composes two signature functions. compdataFThis function composes a signature function with a term homomorphism.compdataEThis function composes a term homomorphism with a signature function.compdata<This function composes an algebra with a signature function.compdataGLifts the given signature function to the canonical term homomorphism.compdataLift the given signature function to a monadic signature function. Note that term homomorphisms are instances of signature functions. Hence this function also applies to term homomorphisms. compdataILift the give monadic signature function to a monadic term homomorphism. compdataBLift the given signature function to a monadic term homomorphism. compdataAApply a monadic term homomorphism recursively to a term/context. compdata]Apply a monadic term homomorphism recursively to a term/context. This a top-down variant of .compdatarThis function constructs the unique monadic homomorphism from the initial term algebra to the given term algebra. compdataIThis function applies a monadic signature function to the given context. compdatahThis function applies a monadic signature function to the given context. This is a top-down variant of .compdataAThis function applies a signature function to the given context. compdata(Compose two monadic term homomorphisms. compdata(Compose two monadic term homomorphisms. compdata[Compose a monadic algebra with a monadic term homomorphism to get a new monadic algebra. compdataSCompose a monadic algebra with a term homomorphism to get a new monadic algebra. compdata9This function composes two monadic signature functions. compdata(Compose two monadic term homomorphisms. compdata9This function composes two monadic signature functions. compdata9This function composes two monadic signature functions. compdata3Construct an anamorphism from the given coalgebra. compdataShortcut fusion variant of .compdataBConstruct a monadic anamorphism from the given monadic coalgebra. compdata3Construct a paramorphism from the given r-algebra. compdataCConstruct a monadic paramorphism from the given monadic r-algebra. compdata5Construct an apomorphism from the given r-coalgebra. compdataDConstruct a monadic apomorphism from the given monadic r-coalgebra. compdataThis function applies  at the tip of the term.compdata5Construct a histomorphism from the given cv-algebra. compdataEConstruct a monadic histomorphism from the given monadic cv-algebra. compdata6Construct a futumorphism from the given cv-coalgebra. compdataFConstruct a monadic futumorphism from the given monadic cv-coalgebra. compdataBConstruct a futumorphism from the given generalised cv-coalgebra. compdataEThis function applies a signature function after a term homomorphism.compdataThis 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.FF'(c) 2010-2011 Patrick Bahr, Tom HvitvedBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None&'+;<=>?QSTV compdataLProject the outermost layer of a term to a sub signature. If the signature g is compound of n atomic signatures, use projectn instead.compdataLProject the outermost layer of a term to a sub signature. If the signature g is compound of n atomic signatures, use projectn instead.compdataTries to coerce a termcontext to a term0context over a sub-signature. If the signature g is compound of n atomic signatures, use  deepProjectn instead.compdataTries to coerce a termcontext to a term0context over a sub-signature. If the signature g is compound of n atomic signatures, use  deepProjectn instead.compdataNInject a term where the outermost layer is a sub signature. If the signature g is compound of n atomic signatures, use injectn instead.compdataNInject a term where the outermost layer is a sub signature. If the signature g is compound of n atomic signatures, use injectn instead.compdataVInject 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.compdataVInject 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.compdata<This function injects a whole context into another context. compdata4This function lifts the given functor to a context. compdata7This 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. :(c) 2010-2011 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None<compdataDerive smart constructors for a type constructor of any first-order kind taking at least one argument. The smart constructors are similar to the ordinary constructors, but an  is automatically inserted. (c) 2011 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None &'+<STV?compdatabThis function returns the subterm of a given term at the position specified by the given path or Nothing' if the input term has no such subtermcompdatahThis function returns a list of all subterms of the given term. This function is similar to Uniplate's universe function.compdataoThis function returns a list of all subterms of the given term that are constructed from a particular functor.compdataThis function transforms every subterm according to the given function in a bottom-up manner. This function is similar to Uniplate's  transform function.compdataMonadic version of .compdatagThis function computes the generic size of the given term, i.e. the its number of subterm occurrences.compdata<This function computes the generic height of the given term.  (c) 2010-2013 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None&'+;<=>?QSTVcompdataTransform a function with a domain constructed from a functor to a function with a domain constructed with the same functor, but with an additional annotation. compdataTransform a function with a domain constructed from a functor to a function with a domain constructed with the same functor, but with an additional annotation. compdataCStrip the annotations from a term over a functor with annotations. compdata)Lift a term homomorphism over signatures f and gR to a term homomorphism over the same signatures, but extended with annotations. compdata1Lift a monadic term homomorphism over signatures f and g[ to a monadic term homomorphism over the same signatures, but extended with annotations. compdata4Annotate each node of a term with a constant value. compdataThis function is similar to projectE but applies to signatures with an annotation which is then ignored. ;"(c) 2011 Patrick Bahr, Tom HvitvedBSD3Tom Hvitved <hvitved@diku.dk> experimentalnon-portable (GHC Extensions)None<)compdataDerive smart constructors with products for a type constructor of any parametric kind taking at least one argument. The smart constructors are similar to the ordinary constructors, but an  is automatically inserted. (c) 2011 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None+<QSTVcompdata=This type represents position representations for a functor fN. It is a function that extracts a number of components (of polymorphic type a3) from a functorial value and puts it into a list.compdataGThis type represents algebras which have terms with thunks as carrier.compdata*This type represents contexts with thunks.compdata'This type represents terms with thunks.compdata7This function turns a monadic computation into a thunk.compdataDThis function evaluates all thunks until a non-thunk node is found.compdata?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.compdata:This function inspects the topmost non-thunk node (using ") according to the given function.compdata Variant of  with flipped argument positionscompdataHThis function inspects the topmost non-thunk nodes of two terms (using ") according to the given function.compdata#This function evaluates all thunks. compdataThis function evaluates all thunks while simultaneously projecting the term to a smaller signature. Failure to do the projection is signalled as a failure in the monad as in . compdata%This function inspects a term (using #) according to the given function. compdata Variant of   with flipped argument positions compdata(This function inspects two terms (using #) according to the given function. compdataAThis combinator runs a monadic catamorphism on a term with thunkscompdata:This combinator runs a catamorphism on a term with thunks.compdata}This combinator makes the evaluation of the given functor application strict by evaluating all thunks of immediate subterms.compdata This combinator is a variant of  that only makes a subset of the arguments of a functor application strict. The first argument of this combinator specifies which positions are supposed to be strict.compdata4This function decides equality of terms with thunks.          1 1<(c) 2011 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None+<STҔcompdataDerive an instance of P for a type constructor of any first-order kind taking at least one argument. (c) 2010-2011 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None<compdatapGiven 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 ... . $ !"#$%&'()*+,-./012$ !"#%&'()*$./012+,-'(c) 2010-2011 Patrick Bahr, Tom HvitvedBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None &';<ST[ ! !(c) 2010-2011 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None&'<ST߂compdata( is propagated through sums.!compdataFrom an ( functor an : instance of the corresponding term type can be derived.()()='(c) 2010-2011 Patrick Bahr, Tom HvitvedBSD3:Patrick Bahr <paba@diku.dk>, Tom Hvitved <hvitved@diku.dk> experimentalnon-portable (GHC Extensions)None< %&()rstuvwxyz{|}~ None;<-compdataThe /` algebra of a functor. The default instance creates a tree with the same structure as the term./compdataConvert a term to a 0compdataShow a term using ASCII art1compdataPrint a term using ASCII art2compdata0Write a term to an HTML file with foldable nodes-./012-./012!"(c) 2011 Patrick Bahr, Tom HvitvedBSD3Tom Hvitved <hvitved@diku.dk> experimentalnon-portable (GHC Extensions)None +;<=>?ST4compdata!The desugaring term homomorphism.7compdataDesugar a term.8compdata#Lift desugaring to annotated terms.9compdataDefault desugaring instance.4657846578"(c) 2010-2011 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None &';<=ST+,+,#(c) 2011 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None &';<=ST<Acompdata Instances of .! are closed under forming sums. BcompdataThis lifts instances of . to instances of & for the corresponding context type. CcompdataThis lifts instances of . to instances of .) for the corresponding context functor.EcompdataThis lifts instances of . to instances of " for the corresponding term type. ./01./01$(c) 2010-2011 Patrick BahrBSD3=Patrick Bahr <paba@diku.dk> and Tom Hvitved <hvitved@diku.dk> experimentalnon-portable (GHC Extensions)None &';<=>?ST (QcompdataIThis multiparameter class defines functors with variables. An instance  HasVar f v denotes that values over f, might contain and bind variables of type v. RcompdataIndicates whether the f@ constructor is a variable. The default implementation returns Nothing.Scompdata,Indicates the set of variables bound by the fa constructor for each argument of the constructor. For example for a non-recursive let binding: hdata Let e = Let Var e e instance HasVars Let Var where bindsVars (Let v x y) = y |-> Set.singleton v XIf, instead, the let binding is recursive, the methods has to be implemented like this: b bindsVars (Let v x y) = x |-> Set.singleton v & y |-> Set.singleton v qThis indicates that the scope of the bound variable also extends to the right-hand side of the variable binding.1The default implementation returns the empty map.Tcompdata[This type represents substitutions of terms, i.e. finite mappings from variables to terms.UcompdataaThis type represents substitutions of contexts, i.e. finite mappings from variables to contexts.compdataAThis multiparameter class defines substitution of values of type t for variables of type v in values of type a. compdataSame as R but it returns Nothing instead of Just v if .v@ is contained in the given set of variables.WcompdataThis combinator pairs every argument of a given constructor with the set of (newly) bound variables according to the corresponding Q type class instance.compdataThis combinator combines W with the generic  function.compdataThis combinator combines W with the generic  function.Xcompdata8Convert variables to holes, except those that are bound.compdata]Algebra for checking whether a variable is contained in a term, except those that are bound.YcompdataCThis function checks whether a variable is contained in a context. compdata\Algebra for generating a set of variables contained in a term, except those that are bound.ZcompdataEThis function computes the list of variables occurring in a context. [compdataDThis function computes the set of variables occurring in a context. \compdataEThis function computes the set of variables occurring in a constant. ]compdataApply the given substitution.^compdata)This function composes two substitutions s1 and s2O. That is, applying the resulting substitution is equivalent to first applying s2 and then s1. 765QRSTUVWXYZ[\]^QRSTUXY[Z\V]^W567%(c) 2010-2011 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None&'<>?3compdata/This is an auxiliary function for implementing c. It behaves similarly as match but is oblivious to non-linearity. Therefore, the substitution that is returned maps holes to non-empty lists of terms (resp. contexts in general). This substitution is only a matching substitution if all elements in each list of the substitution's range are equal. ccompdataThis 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 s\ 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 c might be non-linear, i.e. has multiple holes that are equal. According to the above definition this means that holes with equal holes have to be instantiated by equal terms! dcompdataThis function is similar to cO but instead of a context it matches a term with variables against a context. 756QRSTUVWXYZ[\]^cdcd&(c) 2010-2011 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None&'<QV\ecompdataThis 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 False6. Otherwise, the successor is returned together with True.fcompdataGThis type represents a potential single step reduction from any input.gcompdataBThis type represents term rewriting systems (TRSs) from signature f to signature g over variables of type v. hcompdata7This type represents term rewrite rules from signature f to signature g over variables of type v icompdataThis type represents variables.jcompdataThis type represents recursive program schemes. kcompdataThis function tries to match the given rule against the given term (resp. context in general) at the root. If successful, the function returns the right hand side of the rule and the matching substitution. lcompdataThis function tries to match the rules of the given TRS against the given term (resp. context in general) at the root. The first rule in the TRS that matches is then used and the corresponding right-hand side as well the matching substitution is returned.mcompdataThis function tries to apply the given rule at the root of the given term (resp. context in general). If successful, the function returns the result term of the rewrite step; otherwise Nothing. ncompdataThis function tries to apply one of the rules in the given TRS at the root of the given term (resp. context in general) by trying each rule one by one using m8 until one rule is applicable. If no rule is applicable Nothing is returned. ocompdata2This 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 NothingW. This function is useful to change the output of functions that apply rules such as n. pcompdataThis function performs a parallel reduction step by trying to apply rules of the given system to all outermost redexes. If the given term contains no redexes, Nothing is returned. qcompdataThis function performs a parallel reduction step by trying to apply rules of the given system to all outermost redexes and then recursively in the variable positions of the redexes. If the given term does not contain any redexes, Nothing is returned. rcompdataZThis function applies the given reduction step repeatedly until a normal form is reached. efghijklmnopqrjihgfeklmnopqr'(c) 2010-2011 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None+;<=>?escompdata@This class specifies the decomposability of a functorial value. tcompdata/This type represents decompositions of terms. ucompdata:This type represents decompositions of functorial values. xcompdata<This function computes the structure of a functorial value. ycompdata=This function computes the arguments of a functorial value. {compdata!This function decomposes a term. stuwvxyz{ uwvtszxy{((c) 2010-2011 Patrick BahrBSD3Patrick Bahr <paba@diku.dk> experimentalnon-portable (GHC Extensions)None<>?tv |compdataMThis is the unification monad that is used to run the unification algorithm.}compdata=This type represents the state for the unification algorithm.compdataFThis type represents errors that might occur during the unification. compdata(This type represents list of equations. compdataHThis type represents equations between terms over a specific signature. compdataJThis is used in order to signal a failed occurs check during unification.compdataKThis is used in order to signal a head symbol mismatch during unification.compdataJThis function applies a substitution to each term in a list of equations.compdatauThis function returns the most general unifier of the given equations using the algorithm of Martelli and Montanari. compdataQThis function runs a unification monad with the given initial list of equations.|}~}~|>?@>ABCDECDFCDGHIJHIKLLMNOPQRSTUVWXYZ[\]^_`)a*b*c*d*e*f*g+h,i,j,k-l-m-n.o.p.q/r/s/t/u/vwxyz{|}~~012 x y z { } ~ ~                                                                       4 4!4"4#4$4%&'()*+,-./0123456789:;<=>?@ABC5DEFGHIJKLMNOPQRSTUVWXYZ[\6]7^_`abcd8efghijklmnopqrstuvwxyz{|}~O     123459:678:D;<=>?B_abc`d;e<<<fyY       !!!!!!!""""""################$g$h$i$j$k$$m$n$o$p$q$r$s$t$$u$v$w%%&& & & & & &&&&&&&&'''' '''''(((( (!("(#($("(%(&('((()(*(+(,(-(.(/(0>12/3/4/5363738393:3;3<3=3>3?3@3A3B>1C3D3E3F3G3H3I3J3K3L3M3N3O3P>1QRSTRSUVWXYZ[\]^_`K<abcd$V$W$e>1f$g>?h$Z$[%ij$compdata-0.12-CeFRmeS8zRuKuhc6rRWnMzData.Comp.DeriveData.Comp.MappingData.Comp.Derive.UtilsData.Comp.EqualityData.Comp.Multi.HFunctorData.Comp.Multi.HFoldableData.Comp.Multi.DeriveData.Comp.Multi.HTraversableData.Comp.Multi.MappingData.Comp.Multi.TermData.Comp.Projection Data.Comp.OpsData.Comp.Multi.AlgebraData.Comp.Multi.OpsData.Comp.Multi.SumData.Comp.Multi.GenericData.Comp.Multi.ProjectionData.Comp.Multi.EqualityData.Comp.Multi.OrderingData.Comp.Multi.AnnotationData.Comp.Multi.VariablesData.Comp.Multi.ShowData.Comp.Multi.DesugarData.Comp.TermData.Comp.Algebra Data.Comp.SumData.Comp.GenericData.Comp.AnnotationData.Comp.ThunkData.Comp.ShowData.Comp.OrderingData.Comp.RenderData.Comp.DesugarData.Comp.DeepSeqData.Comp.ArbitraryData.Comp.VariablesData.Comp.MatchingData.Comp.TermRewritingData.Comp.DecomposeData.Comp.UnificationData.Comp.Derive.TraversableData.Comp.Derive.ShowData.Comp.Derive.FoldableData.Comp.Derive.EqualityData.Comp.Derive.OrderingData.Comp.Derive.DeepSeqData.Comp.Derive.ArbitraryData.Comp.Multi.Derive.HFunctor Data.Comp.Multi.Derive.HFoldable#Data.Comp.Multi.Derive.HTraversableData.Comp.SubsumeCommonData.Comp.Multi.Derive.Show(Data.Comp.Multi.Derive.SmartConstructorsData.Comp.Multi.Derive.OrderingData.Comp.Multi.Derive.Equality)Data.Comp.Multi.Derive.SmartAConstructorsData.Comp.Multi"Data.Comp.Derive.SmartConstructors#Data.Comp.Derive.SmartAConstructorsData.Comp.Derive.HaskellStrict Data.Compbase Data.FoldableFoldableData.Traversable Traversable(QuickCheck-2.12.4-3d2YDDqfPBn4BfmTJbpJXKTest.QuickCheck.Arbitraryshrink arbitrary Arbitrarydeepseq-1.4.3.0Control.DeepSeqrnfNFDataDataInfoabstractNewtypeQabstractNewtype normalCon normalCon' normalConExpnormalConStrExp getBinaryFArg getUnaryFArgabstractConType tyVarBndrName containsType containsType'newNames tupleTypesderivemkClassPisEqualP mkInstanceD liftSumGenfindSigmakeTraversable ShowConstr showConstrShowFshowF makeShowFmakeShowConstr makeFoldableEqFeqFmakeEqFOrdFcompareFmakeOrdFNFDataFrnfF makeNFDataF ArbitraryF arbitraryF' arbitraryFshrinkFmakeArbitraryFNumMapMapping&|->empty prodMapWithfindWithDefaultNumbered unNumberednumberprodMap lookupNumMap lookupNumMap'$fMappingNumMapNumbered$fFunctorNumMap$fFoldableNumMap$fTraversableNumMap:.:CompHFunctorhfmapNatM:=>:->AunAEunEKunKIunIrunE$fOrdK$fEqK$fHFunctorCompose $fFunctorI $fFoldableI$fTraversableI $fFunctorK $fFoldableK$fTraversableK HFoldablehfoldhfoldMaphfoldrhfoldlhfoldr1hfoldl1htoListkfoldrkfoldl makeHFunctor makeHFoldable HTraversablehmapM htraversemakeHTraversableTermContextNoHoleHoleCxtConst constTermunTermsimpCxttoCxt$fHTraversableCxt$fHFoldableCxt $fHFunctorCxt:<pr$fProjFound(,)g$fProjFoundf(,)$fProjFoundf(,)0 $fProjFoundffRemAremADistAnninjectAprojectA:&::*::=::<:Subsumeinj'prj'Elem:+:InlInrfromInlfromInrcaseFinjprojsplffstfsnd$fTraversable:+: $fFoldable:+: $fFunctor:+:$fSubsumeFound:+:g$fSubsumeFoundf:+:$fSubsumeFoundf:+:0$fSubsumeFoundff$fTraversable:*: $fFoldable:*: $fFunctor:*:$fTraversable:&: $fFoldable:&: $fFunctor:&:$fDistAnnk:+:p:+:$fDistAnnkfp:&: $fRemAk:&:f $fRemAk:+::+:CVCoalgMCVCoalgRCoalgMRCoalgRAlgMRAlgCoalgMCoalgHomMCxtFunMSigFunMHomCxtFunSigFunAlgMAlgfreecatacata'appCxtliftMAlgfreeMcataMcataM'appHomappHom'compHomcompAlg appSigFun' appSigFun compSigFunhomsigFunMhom'homMappHomMappHomM' appSigFunM appSigFunM'compHomMcompAlgM compAlgM' compSigFunManaanaMparaparaMapoapoMfutufutuMKShowkshowShowHFshowHFshowHF' makeShowHFcaseH$fHTraversable:+:$fHFoldable:+: $fHFunctor:+:$fHTraversable:&:$fHFoldable:&: $fHFunctor:&:$fDistAnn:+:p:+:$fDistAnnfp:&: $fRemA:&:f $fRemA:+::+:project deepProjectinject deepInjectsplit injectCxtliftCxt substHoles injectConst projectConstsubterms subterms' transform transformMquerysubssubs'sizedepthsmartConstructors$fProjFound:*:g$fProjFoundf:*:$fProjFoundf:*:0EqHFeqHFKEqkeqheqMod$fEqE$fKEqK$fEqCxt$fKEqCxt $fEqHFCxt $fEqHF:+:OrdHF compareHFKOrdkcompare$fKOrdK$fOrdE$fOrdCxt $fKOrdCxt $fOrdHFCxt $fOrdHF:+: makeOrdHFmakeEqHFliftAannliftA'stripApropAnnproject'smartAConstructorsliftSumHasVarsisVar bindsVarsSubstCxtSubstGSubst getBoundVars varsToHoles containsVar variableList variables variables'appSubst compSubst $fHasVars:+:v$fSubstVarsvtf$fSubstVarsvCxtCxt $fShowHF:&: $fShowCxt $fKShowCxt $fShowHFCxt$fKShowK $fKShowK0 $fShowHF:+:DesugardesugHom desugHom'desugardesugarA $fDesugarfg $fDesugar:+:hPTerm$fTraversableCxt $fFoldableCxt $fFunctorCxt $fMonadCxt$fApplicativeCxteqMod$fEqF:+:$fEqFCxt$fEqF(,,,,,,,,,)$fEqF(,,,,,,,,)$fEqF(,,,,,,,) $fEqF(,,,,,,) $fEqF(,,,,,) $fEqF(,,,,) $fEqF(,,,) $fEqF(,,)$fEqF(,)$fEqF[] $fEqFMaybeCVCoalg'CVAlgMCVAlgHomMDSigFunMDalgM compCoalg compCVCoalg compSigFunHom compHomSigFun compAlgSigFunhomMD appSigFunMDcompSigFunHomMcompHomSigFunMcompAlgSigFunMana'histohistoMfutu'project_ deepProject_inject_ deepInject_ substHoles'$fEq:+:$fOrd:+: $fShow:+: getSubterm transform'gsizeheightpropAnnMAlgTCxtTTermTthunkwhnfwhnf'whnfPreval#>eval2nfnfPrdeepEval#>> deepEval2cataTMcataTstrictstrictAteqT haskellStricthaskellStrict'makeHaskellStrict $fShowF:&: $fShowFCxt $fShowF:+:$fShowConstr:&: $fShowF(,) $fShowF[] $fShowFMaybe$fShowConstr:+: $fOrdF:+: $fOrdFCxt$fOrdF(,,,,,,,,,)$fOrdF(,,,,,,,,)$fOrdF(,,,,,,,)$fOrdF(,,,,,,) $fOrdF(,,,,,) $fOrdF(,,,,) $fOrdF(,,,) $fOrdF(,,) $fOrdF(,)$fOrdF[] $fOrdFMaybeRender stringTreeAlg stringTreeshowTermdrawTerm writeHtmlTerm $fRender:+: $fNFDataF:&: $fNFDataCxt $fNFDataF:+: $fNFDataF(,) $fNFDataF[]$fNFDataFMaybe$fArbitraryF:+:$fArbitraryCxt$fArbitraryFCxt$fArbitraryF:&:$fArbitraryCxt0$fArbitraryF(,,,,,,,,,)$fArbitraryF(,,,,,,,,)$fArbitraryF(,,,,,,,)$fArbitraryF(,,,,,,)$fArbitraryF(,,,,,)$fArbitraryF(,,,,)$fArbitraryF(,,,)$fArbitraryF(,,)$fArbitraryF(,)$fArbitraryF[]$fArbitraryFMaybe substVars $fHasVars:&:vmatchCxt matchTermBStepStepTRSRuleVarRPS matchRule matchRulesappRuleappTRSbStep parTopStep parallelStepreduce Decompose DecompTermDecompFun structure argumentsdecomp decomposeUnifyM UnifyStateusEqsusSubst UnifErrorFailedOccursCheckHeadSymbolMismatch EquationsEquationfailedOccursCheckheadSymbolMismatch appSubstEqunify runUnifyM withNextEqputEqs putBindingrunUnify unifyStepGHC.BaseFunctorgenerateArbitraryFDeclgenerateGenDeclgenerateShrinkFDeclOrDupl'FindDupl'DuplToListCheckComprEmbFoundComprPosSumLeRiLe'MaybeRi'Combine CombineMaybe CombineRecEmbNotFound AmbiguousPosSum'ChooseProxyPHereJustghc-prim GHC.ClassesEqOrd SubstVarsisVar'hfmapBoundVarshfoldlBoundVarscontainsVarAlg variablesAlg compHomM'compSigFunHomM' projectTip appSigFunHom appAlgHomM HaskellStrictcontainers-0.5.11.0 Data.TreeTree fmapBoundVarsfmapfoldlBoundVarsfoldl matchCxt'