zP      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                             (c) 2008 University of MinhoBSD3hpacheco@di.uminho.pt experimental non-portableNone!"+234<=HJKM)3The final object. The only possible value of type  is .PThe bottom value for any type. It is many times used just for type annotations.'Creates a point to the terminal object.Converts elements into points.The infix split combinator. %Injects a value to the left of a sum. &Injects a value to the right of a sum. The infix either combinator. The infix sum combinator. #Alias for the infix sum combinator.The application combinator.#The left exponentiation combinator.$The right exponentiation combinator.*The infix combinator for a constant point.3Guard combinator that operates on Haskell booleans.9Infix guard combinator that simulates the postfix syntax.The uncurried split combinator. The uncurried either combinator.%The uncurried composition combinator.Binary or of boolean functions.Binary and of boolean functions.Binary or point-free combinator.Binary and point-free combinator.&Binary equality point-free combinator.(Binary inequality point-free combinator.Swap the elements of a product.Swap the elements of a sum. *Distribute products over the left of sums.!*Distribute sums over the left of products."+Distribute products over the right of sums.#+Distribute sums over the right of products.$&Associate nested products to the left.%(Associates nested products to the right.&#Associates nested sums to the left.'$Associates nested sums to the right.(4Shifts the an element to the right of a nested pair.)3Shifts the an element to the left of a nested pair.*.Shifts an option to the right of a nested sum.+-Shifts an option to the left of a nested sum.,#The product distribution combinator- The sum distribution combinator.1  !"#$%&'()*+,-./0.  !"#$%&'()*+,-10/.  !"#$%&'()*+,-1  !"#$%&'()*+,-./0   (c) 2008 University of MinhoBSD3hpacheco@di.uminho.pt experimental non-portableNone!"+234<=HJKM#3Semantically, we can say that Q f :@!: Q g = Q (f ':@: g).6Semantically, we can say that Q f :*!: Q g = Q (f :*: g).9Semantically, we can say that Q f :+!: Q g = Q (f :+: g).<Semantically, we can say that < t = Q (\ t).?In order to simplify type-level composition of functors, we can create fixpoint combinators that implicitely assume fixpoint application.Semantically, we can say that ? = Q _.AThe Ah class provides the value-level translation between data types and their sum of products representationsB5Packs a sum of products into one equivalent data typeC7unpacks a data type into the equivalent sum of productsDUShort alias to express the structurally equivalent sum of products for some data typeE Polytypic  " class for functor representationsM A specific Show class for functor representations that receives a show function for recursive instances. This avoids infinite loops in the type inference of fixpoints.O"Family of functor representations.The O~ family implements the implicit coercion between the application of a functor and the structurally equivalent sum of products.AFunctors applied to types can be represented as sums of products.P*Family of patterns functors of data types.mThe type function is not necessarily injective, this is, different data types can have the same base functor.Semantically, we can say that a = Q f.QExplicit fixpoint operator.SRThe unfolding of the fixpoint of a functor is the functor applied to its fixpoint.unFix( is specialized with the application of O( in order to subsume functor applicationTComposition of functors.WProduct of functors.YSum of functors.\Constant functor._Identity functor.cPolytypic map function{ ExpandingAcontracting the fixed point of a functor is the same as consuming%applying it's single type constructor|#The list functor maps the specific  function over lists of types}iThe composition functor applies in the nesting of the mapping function to the nested functor applicationsJThe product functor recursively applies the mapping function to both sidesLThe sum functor recursively applies the mapping function to each alternative0The constant functor preserves the argument typeCThe identity functor applies the mapping function the argument typeUThe application of the list functor to some type returns a list of the argument type.yThe application of a composition of functors to some type is the nested application of the functors to the argument type.nThis particular instance requires that nexted type function application is enabled as a type system extension.sThe application of a product of functors to some type is the product of applying the functors to the argument type.kThe application of a sum of functors to some type is the sum of applying the functors to the argument type.SThe constant functor applied to some type is the type parameterized by the functor.=The identity functor applied to some type is the type itself.GThe pattern functor of the fixpoint of a functor is the functor itself.s123456789:;<=>?@ABCDEF`For desambiguation purposes, the type of the functor must be passed as an explicit parameter to F The mapping over representationsG`The polytypic functor zipping combinator. Gives preference to the abstract (first) F-structure.HIJKLMNOPQRSTUVWXYZ[\]^_`abcEA value of a data type that is the fixed point of the desired functor/The mapping over the equivalent sum of productsdefghijklmnopqrstuvwxyz{|}~@123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopb_`a\]^Y[ZWXTUVQRSPOMNHIJKLEFG~}|bDcABCde{?@z<=>y9:;x678w345vufg12thisjklmrnoqpU123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXY[Z\]^_`abcdefghijklmnopqrstuvwxyz{|}~3 69T WY(c) 2011 University of MinhoBSD3hpacheco@di.uminho.pt experimental non-portableNone!"+234<=HJKM Polymorphic monoid class\Annotations of higher-order functors, only to provide type-level information to the compiler<The fixpoint of an higher-order functor is a regular functor=Composition of a regular functor with an higher-order functorProduct higher-order functorSum higher-order functorParameter higher-order functorConstant higher-order functorIdentity higher-order functor#The type of natural transformationsB     &1-      (c) 2009 University of MinhoBSD3hpacheco@di.uminho.pt experimental non-portableNone!"+234<=HJKM Class of representable functors.UFunctor GADT for polytypic recursive functions. At the moment it does not rely on a Typeable instance for constants.(The fixpoint of a representable functor.>The representation of the fixpoint of a representable functor.  (c) 2008 University of MinhoBSD3hpacheco@di.uminho.pt experimental non-portableNone!"+234<=HJKM2In futumorphisms we add an alternative annotation c to the base functor of type b.-In histomorphisms we add an extra annotation c to the base functor of type a.,In accumulations we add an extra annotation b to the base functor of type a.XIn zygomorphisms we extend the recursive occurences in the base functor functor of type a with an extra annotation b.\The functor of the intermediate type of an apomorphism is the functor of the generated type bD with an alternative annotation to itself in recursive definitions.[The functor of the intermediate type of a paramorphism is the functor of the consumed type aG extended with an extra annotation to itself in recursive definitions.Definition of an hylomorphism0Definition of a catamorphism as an hylomorphism.Catamorphisms model the fundamental pattern of iteration, where constructors for recursive datatypes are repeatedly consumed by arbitrary functions. They are usually called folds.'Recursive definition of a catamorphism.0Definition of an anamorphism as an hylomorphism.Anamorphisms resembles the dual of iteration and, hence, dene the inverse of catamorphisms. Instead of consuming recursive types, they produce values of those types.'Recursive definition of an anamorphism.Definition of a paramorphism.^Paramorphisms supply the gene of a catamorphism with a recursively computed copy of the input.7The first introduction to paramorphisms is reported in  >http://www.cs.uu.nl/research/techreps/repo/CS-1990/1990-04.pdf.'Recursive definition of a paramorphism.0Definition of an apomorphism as an hylomorphism.Apomorphisms are the dual recursion patterns of paramorphisms, and therefore they can express functions defined by primitive corecursion.&They were introduced independently in  .http://www.cs.ut.ee/~varmo/papers/nwpt97.ps.gz and HProgram Construction and Generation Based on Recursive Types, MSc thesis.'Recursive definition of an apomorphism.0Definition of a zygomorphism as an hylomorphism.!Zygomorphisms were introduced in  Bhttp://dissertations.ub.rug.nl/faculties/science/1990/g.r.malcolm/.They can be seen as the asymmetric form of mutual iteration, where both a data consumer and an auxiliary function are defined ( 0http://www.fing.edu.uy/~pardo/papers/njc01.ps.gz).1Definition of an accumulation as an hylomorphism.Accumulations  1http://www.fing.edu.uy/~pardo/papers/wcgp02.ps.gzR are binary functions that use the second parameter to store intermediate results.The so called "accumulation technique" is tipically used in functional programming to derive efficient implementations of some recursive functions.nDefinition of an histomorphism as an hylomorphism (as long as the catamorphism is defined as an hylomorphism).Histomorphisms ( (http://cs.ioc.ee/~tarmo/papers/inf.ps.gz) capture the powerfull schemes of course-of-value iteration, and differ from catamorphisms for being able to apply the gene function at a deeper depth of recursion. In other words, they allow to reuse sub-sub constructor results.The combinator D unpacks the functor of an histomorphism and selects the annotation.The combinator E unpacks the functor of an histomorphism and discards the annotation.kDefinition of a futumorphism as an hylomorphism (as long as the anamorphism is defined as an hylomorphism).AFutumorphisms are the dual of histomorphisms and are proposed as 'cocourse-of-argument' coiterators by their creators ( (http://cs.ioc.ee/~tarmo/papers/inf.ps.gz).In the same fashion as histomorphisms, it allows to seed the gene with multiple levels of depth instead of having to do 'all at once' with an anamorphism.The combinator ; packs the functor of a futumorphism from the base functor.The combinator 9 packs the functor of an futumorphism from an annotation.1Definition of a dynamorphism as an hylomorphisms.Dynamorphisms ( 1http://math.ut.ee/~eugene/kabanov-vene-mpc-06.pdf]) are a more general form of histomorphisms for capturing dynaming programming constructions.+Instead of following the recursion pattern of the input via structural recursion (as in histomorphisms), dynamorphisms allow us to reuse the annotated structure in a bottom-up approach and avoiding rebuilding it every time an annotation is needed, what provides a more efficient dynamic algorithm.2Definition of a chronomorphism as an hylomorphism.ZThis recursion pattern subsumes histomorphisms, futumorphisms and dynamorphisms and can be seen as the natural hylomorphism generalization from composing an histomorphism after a futumorphism. Therefore, chronomorphisms can 'look back' when consuming a type and 'jump forward' when generating one, via it's fold/unfold operations, respectively.The notion of chronomorphism is a recent recursion pattern (at least known as such). The first and single reference available is  8http://comonad.com/reader/2008/time-for-chronomorphisms/.+The Fixpoint combinator as an hylomorphism. is a fixpoint combinator if  =   (  )."After expanding the denitions of ,  and A we see that this corresponds to the expected pointwise equation  f = f ( f).3The combinator for isomorphic type transformations.;It can translate between types that share the same functor.(c) 2008 University of MinhoBSD3hpacheco@di.uminho.pt experimental non-portableNone!"+234<=HJKM<Class for mapping observations over functor representations.eDerives a type representation for a functor. This is used for showing the functor for reursion trees.dWatch values of a functor. Since the fixpoint of a functor recurses over himself, we cannot use the 7 instance for functor values applied to their fixpoint.2Maps an observation over a functor representation."Polytypic mapping of observations.(c) 2008 University of MinhoBSD3hpacheco@di.uminho.pt experimental non-portableNone!"+234<=HJKM MRedefinition of hylomorphisms with observation of the intermediate data type.:Redefinition of catamorphisms as observable hylomorphisms.9Redefinition of anamorphisms as observable hylomorphisms.:Redefinition of paramorphisms as observable hylomorphisms.9Redefinition of apomorphisms as observable hylomorphisms.:Redefinition of zygomorphisms as observable hylomorphisms.:Redefinition of accumulations as observable hylomorphisms.;Redefinition of histomorphisms as observable hylomorphisms. :Redefinition of futumorphisms as observable hylomorphisms. :Redefinition of dynamorphisms as observable hylomorphisms. <Redefinition of chronomorphisms as observable hylomorphisms.             (c) 2008 University of MinhoBSD3hpacheco@di.uminho.pt experimental non-portableNone!"+234<=HJKMq $Datatype declaration of a rose tree.$Datatype declaration of a leaf tree.&Datatype declaration of a binary tree.'The fixpoint of the functor of streams.The fixpoint of the functor that represents a virtual matrix used to accumulate and look up values for the edit distance algorithm.Since matrixes are not inductive types, a walk-through of a matrix is used, consisting in a list of values from the matrix ordered predictability.1For a more detailed explanation, please refer to  1http://math.ut.ee/~eugene/kabanov-vene-mpc-06.pdf.BThe fixpoint of the list functor with a specific terminal element.TThe fixpoint of the functor representing trees with maximal branching factor of two.4The fixpoint of the functor for a binary shape tree.MThe fixpoint of the functor that is either a constant or defined recursively. The number 1.Pre-defined algebraic addition. KDefinition of algebraic addition as an anamorphism in the point-wise style.!1Defition of algebraic addition as an anamorphism."4Definition of algebraic addition as an hylomorphism.#4Definition of algebraic addition as an accumulation.%3Definition of algebraic addition as an apomorphism.&Pre-defined algebraic product.'2Definition of algebraic product as an hylomorphism(&Pre-defined 'greater than' comparison.)0Definition of 'greater than' as an hylomorphism.*6Native recursive definition of the factorial function.+GRecursive definition of the factorial function in the point-free style.,aRecursive definition of the factorial function in the point-free style with structural recursion.-8Definition of the factorial function as an hylomorphism..7Definition of the factorial function as a paramorphism./7Definition of the factorial function as a zygomorphism.06Native recursive definition of the fibonacci function.1GRecursive definition of the fibonacci function in the point-free style.2aRecursive definition of the fibonacci function in the point-free style with structural recursion.38Definition of the fibonacci function as an hylomorphism.49Definition of the fibonacci function as an histomorphism.57Definition of the fibonacci function as a dynamorphism.6BNative recursive definition for the binary partitions of a number.The number of binary partitions for a number n is the number of unique ways to partition this number (ignoring the order) into powers of 2. | Definition of the binary partitioning of a number as an hylomorphism.7EDefinition of the binary partitioning of a number as an hylomorphism.8DDefinition of the binary partitioning of a number as a dynamorphism.99Recursive definition of the average of a set of integers.:ADefinition of the average of a set of integers as a catamorphism.;/Pre-defined wrapping of an element into a list.</Definition of wrapping in the point-free style.=5Definition of the tail of a list as a total function.>9Definition of the tail of a list in the point-free style.?3Definition of the tail of a list as an anamorphism.@3Definition of the tail of a list as a paramorphism.A+Native recursion definition of list length.B<Recursive definition of list length in the point-free style.CVRecursive definition of list length in the point-free style with structural recursion.D-Definition of list length as an hylomorphism.E,Definition of list length as an anamorphism.F,Definition of list length as a catamorphism.G.Native recursive definition of list filtering.H0Definition of list filtering as an catamorphism.I/Generation of infinite lists as an anamorphism.J3Finite replication of an element as an anamorphism.K1Generation of a downwards list as an anamorphism.L)Ordered list insertion as an apomorphism.M)Ordered list insertion as a paramorphism.N:Append an element to the end of a list as an hylomorphism.O9Append an element to the end of a list as an apomorphism.P@Creates a bubble from a list. Used in the bubble sort algorithm.QAExtraction of a number of elements from a list as an anamorphism.RKNative recursive definition for partitioning a list at a specified element.SMDefinition for partitioning a list at a specified element as an hylomorphism.T(Incremental summation as a catamorphism.UMIncrementation the elements of a list by a specified value as a catamorphism.WuIncrementation the elements of a list by a specified value as an accumulation. The result is always a non-empty listY-Definition of list mapping as a catamorphism.Z/Definition of list reversion as a catamorphism.[-Linear version of reverse using accumulations^9Definition of the quicksort algorithm as an hylomorphism._:Definition of the bubble sort algorithm as an anamorphism.`=Definition of the insertion sort algorithm as a catamorphism.c9Definition of the heap sort algorithm as an hylomorphism.e)Malcolm downwards accumulations on lists.f:Malcom downwards accumulations on lists as an anamorphism.gOUncurried version of Malcom downwards accumulations on lists as an anamorphism.h;Definition of the zip for lists of pairs as an anamorphism.i;Definition of the subsequences of a list as a catamorphism.jPre-defined list concatenation.k%List concatenation as a catamorphism.l&List concatenation as an hylomorphism.m<Native recursive definition of lists-of-lists concatenation.n=Definition of lists-of-lists concatenation as an anamorphism.o5Sorted concatenation of two lists as an hylomorphism.p2Definition of integerr addition as a catamorphism.q3Definition of integerr addition as an accumulation.r6Native recursive definition of integer multiplication.s7Definition of integer multiplication as a catamorphism.u;Native recursive definition of the edit distance algorithm.Edit distance is a classical dynamic programming algorithm that calculates a measure of distance  or dierence  between lists with comparable elements.v/The edit distance algorithm as an hylomorphism.w.The edit distance algorithm as a dynamorphism.x Stream head.y Stream tail.z=Definition of a stream sequence generator as an anamorphism. {%Identity o streams as an anamorphism.|'Mapping over streams as an anamorphism.}+Malcolm downwards accumulations on streams.~<Malcom downwards accumulations on streams as an anamorphism.QUncurried version of Malcom downwards accumulations on streams as an anamorphism.;Promotes streams elements to streams of singleton elements.<Definition of parwise exchange on streams as a futumorphism.ACounting the number of leaves in a binary tree as a catamorphism.@Counting the number of nodes in a binary tree as a catamorphism.FGeneration of a binary tree with a specified height as an anamorphism.9The preorder traversal on binary trees as a catamorphism.:The postorder traversal on binary trees as a catamorphism.4Extract the leaves of a leaf tree as a catamorphism.CGeneration of a leaft tree of a specified height as an anamorphism.6Calculate the height of a leaf tree as a catamorphism.8The postorder traversal on rose trees as a catamorphism.BGeneration of a rose tree of a specified height as an anamorphism.The functor of a rose tree.The functor of a leaf tree.The functor of a binary tree.   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ (c) 2008 University of MinhoBSD3hpacheco@di.uminho.pt experimental non-portableNone!"+234<=HJKM @Definition of the observable length function as an hylomorphism.?Definition of the observable length function as an anamorphism.?Definition of the observable length function as a catamorphism.CDefinition of the observable factorial function as an hylomorphism.BDefinition of the observable factorial function as a paramorphism.BDefinition of the observable factorial function as a zygomorphism.CDefinition of the observable fibonacci function as an hylomorphism.DDefinition of the observable fibonacci function as an histomorphism.BDefinition of the observable fibonacci function as a dynamorphism.CDefinition of the observable quicksort function as an hylomorphism.=Definition of the observable tail function as a paramorphism.=Definition of the observable add function as an accumulation.     (c) 2009 University of MinhoBSD3hpacheco@di.uminho.pt experimental non-portableNone!"+234<=HJKM -The left-to-right monadic binding combinator.Higher-order monadic binding.+The monadic left exponentiation combinator.,The monadic right exponentiation combinator.The monadic sum combinator.WThe strength combinator for strong monads. In Haskell, every monad is a strong monad:  ?http://comonad.com/reader/2008/deriving-strength-from-laziness/.eThe monadic fusion combinator. Performs left-to-right distribution of a strong monad over a product.The monadic split combinator.The monadic product combinator.     (c) 2009 University of MinhoBSD3hpacheco@di.uminho.pt experimental non-portableNone!"+234<=HJKMThe polytypic bifunctor zipping combinator. Just maps over the polymorphic parameter. To map over the recursive parameter we can use fzip.&Representation of bifunctors with the BRep bifunctor representation class.&Representation of bifunctors with the Rep functor representation class.J !"#$%&'(),80 !"#$%&'()   (c) 2009 University of MinhoBSD3hpacheco@di.uminho.pt experimental non-portableNone!"+234<=HJKM"Class of representable bifunctors.WFunctor GADT for polytypic recursive bifunctions. At the moment it does not rely on a Typeable instance for constants.*The fixpoint of a representable bifunctor.>The representation of the fixpoint of a representable functor.  * !"#$%&'()*+,-./0123456789:;<=>?@@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~AGDJM      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                          ! " # $ % & ' ( ) * +,pointless-haskell-0.0.9Generics.Pointless.CombinatorsGenerics.Pointless.FunctorsGenerics.Pointless.HFunctorsGenerics.Pointless.Fctrable$Generics.Pointless.RecursionPatterns#Generics.Pointless.Observe.Functors,Generics.Pointless.Observe.RecursionPatterns$Generics.Pointless.Examples.Examples#Generics.Pointless.Examples.Observe#Generics.Pointless.MonadCombinatorsGenerics.Pointless.BifunctorsGenerics.Pointless.BifctrablePreludeFunctorOneAnnannvnn_Lbangpnt/\><inlinr\/-|-<>applexprexp!grd???spliteithrcomporfandforandeqneqswapcoswapdistlundistldistrundistrassoclassocrcoassoclcoassocrsubrsublcosubrcosubldistpdists$fEqOne $fShowOne $fShowAnnNat:@!:FixComp unFixComp:*!:FixProd unFixProd:+!:FixSumunFixSumKFixConst unFixConstIFixIdMuinnoutFfmapfzipToReprepfunvalunrepShowRepshowrepRepPFFixInnouT:@:CompFunCompF:*:ProdF:+:InrFInlFConstConsFunConsFIdIdFunIdFlzippmapinn'out'nilconsnzeronsucczerosucknatIntintNattruefalse maybe2bool $fMuMaybe$fMuBool$fMuInt$fMuNat$fMu[]$fMu:@!:$fMu:*!:$fMu:+!:$fMuK$fMuI$fMuFix $fFunctor[] $fFunctor:@: $fFunctor:@:0 $fFunctor:*: $fFunctor:*:0 $fFunctor:+: $fFunctor:+:0$fFunctorConst$fFunctorConst0 $fFunctorId $fFunctorId0 $fToRep:@: $fToRep:+: $fToRep:*: $fToRepConst $fToRepId $fToRep[] $fShowRep:@: $fShowRep:+: $fShowRep:*:$fShowRepConst $fShowRepId $fShowFix HFoldablereducereduce'FMonoidfzerofplusHuhinnhoutHHFAppHRepAnnHHFixHInnhOut:@~:CompHunCompH:*~:ProdH:+~:InrHInlHHFununFunHHParamHParunParHHConstConsHunConsHHIdIdHunIdH:~>$fHFoldable:*~:$fHFoldable:+~:$fHFoldableHFun$fHFoldableHParam$fHFoldableHConst$fHFoldableHId $fFMonoid[] $fFMonoid:@: $fFMonoid:*:$fHuHFix$fHu[]FctrablefctrFctrLfixFfctrF $fFctrable:@: $fFctrable:+: $fFctrable:*: $fFctrable[]$fFctrableConst $fFctrableIdFutuHistoAccumZygoApoParahylocatacataRecanaanaRecparaparaRecapoapoReczygoaccumhistooutloutrfutuinnlinnrdynachronofixnuFunctorO functorOfwatchfmapOomap$fObservableFix$fObservable:@!:$fObservable:*!:$fObservable:+!: $fObservableK $fObservableI$fObservableOne $fFunctorO:@: $fFunctorO:*: $fFunctorO:+:$fFunctorOConst $fFunctorOIdhyloOcataOanaOparaOapoOzygoOaccumOhistoOfutuOdynaOchronoORoseForestLTreeBranchLeafTreeNodeEmptyStream EditDistLEditDistNeListSomeInsertWrapBTreeBSTreeFromoneaddaddAnaPWaddAnaaddHyloaddAccumaddApoPWaddApoprodprodHylogtgtHylofactfactPFfactPF'factHylofactParafactZygofibfibPFfibPF'fibHylofibHistofibDynabpbpHylobpDynaaverage averageCatawrapwrapPFtailtailPFtailCatatailParalengthlengthPF lengthPF' lengthHylo lengthAna lengthCatafilter filterCata repeatAna replicateAna downtoAna insertApo insertParasnocsnocApobubbletakeAna partition partitionHyloisumfisumneCons isumsAccumisumsAnamapCata reverseCata reverseAccum reverseAccum' reverseHyloqsortbsortisortmsplitmsorthsorthsplitmalcolm malcolmAna malcolmAna'zipAna subsequencescatcatCatacatHyloconcat concatCatamergesumCatasumAccummultmultCatasortededitdist editdistHylo editDistDynaheadStailSgenerateidStream mapStreammalcolmS malcolmSAna malcolmSAna'initsexchFutunleavesnnodesgenTreepreTreepostTreeleavesgenLTreeheightpreRosepostRosegenRose$fMuRose $fMuLTree$fMuTree$fMuSome lengthHyloO lengthAnaO lengthCataO factHyloO factParaO factZygoOfibHyloO fibHistoOfibDynaO qsortHyloO tailParaO addAccumO<<=bindmlexpmrexp-||- mstrengthmfuse/|\>|<:@!|FixBComp unFixBComp:*!|FixBProd unFixBProd:+!|FixBSum unFixBSumBK FixBConst unFixBConstBIFixBIdBimubinnboutB BifunctorbmapbzipBRepBFBFixunBFix:@|BCompunBComp:*|BProd:+|BInrBInlBParParunParBConstunBConstBIdunBIdpbmap$fBimu[] $fBimu:@!| $fBimu:*!| $fBimu:+!|$fBimuBK$fBimuBI$fBifunctor:@|$fBifunctor:*|$fBifunctor:+|$fBifunctorBPar$fBifunctorBConst$fBifunctorBId BifctrablebctrBifctrBPfixBfctrB$fBifctrable:+|$fBifctrable:*|$fBifctrableBPar$fBifctrableBConst$fBifctrableBIdbaseGHC.Basemap TFCo:R:Rep[]xTFCo:R:Rep:@:xTFCo:R:Rep:*:xTFCo:R:Rep:+:xTFCo:R:RepConstx TFCo:R:RepIdx TFCo:R:PFFixTFCo:R:PFMaybe TFCo:R:PFBool TFCo:R:PFInt TFCo:R:PFNat TFCo:R:PF[] TFCo:R:PF:@!: TFCo:R:PF:*!: TFCo:R:PF:+!: TFCo:R:PFK TFCo:R:PFI TFCo:R:HFHFix TFCo:R:HF[] TFCo:R:HF:@:TFCo:R:App:@~:hTFCo:R:App:+~:hTFCo:R:App:*~:hTFCo:R:AppHFungTFCo:R:AppHParamgTFCo:R:AppHConstgTFCo:R:AppHIdgTFCo:R:HRep:@~:fTFCo:R:HRep:*~:fTFCo:R:HRep:+~:fTFCo:R:HRepHFunfTFCo:R:HRepHParamfTFCo:R:HRepHConstfTFCo:R:HRepHIdf.idGHC.ShowShow TFCo:R:PFRoseTFCo:R:PFLTree TFCo:R:PFTree TFCo:R:PFSomeTFCo:R:BRepBIdaTFCo:R:RepBIdx TFCo:R:BF[] TFCo:R:BF:@!| TFCo:R:BF:*!| TFCo:R:BF:+!| TFCo:R:BFBK TFCo:R:BFBITFCo:R:BRep:@|aTFCo:R:BRep:*|aTFCo:R:BRep:+|aTFCo:R:BRepBParaTFCo:R:BRepBConstaTFCo:R:Rep:@|xTFCo:R:Rep:*|xTFCo:R:Rep:+|xTFCo:R:RepBParxTFCo:R:RepBConstx