h&      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                               BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portable Safe-Inferred )*04$ data-categoryKind k, is the kind of the objects of the category k. data-categoryAn instance of  Category k declares the arrow k as a category.  data-categoryWhenever objects are required at value level, they are represented by their identity arrows.  data-categoryFor m ~ Many: The category with Haskell types as objects and Haskell functions as arrows, i.e. (->). For m ~ One: The category with Haskell types as objects and Haskell linear functions as arrows, i.e. (%1->). data-categoryOp k& is opposite category of the category k.       8 BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portable Safe-Inferred)* data-category#The product category of categories c1 and c2. BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portable Safe-Inferred)*/0" data-categoryA functor wrapper in case of conflicting family instance declarations( data-category data-categoryCat is the category with categories as objects and funtors as arrows.? data-categoryThe constant functor.@ data-categoryThe  Op (Op x) = x functor.A data-categoryThe  x = Op (Op x) functor.B data-category  is a bifunctor that projects out the first component of a product.C data-category is a bifunctor that projects out the second component of a product.D data-category f1 :***: f2 is the product of the functors f1 and f2.E data-category& is the diagonal functor for products.F data-categoryThe Hom functor, Hom(--,--), a bifunctor contravariant in its first argument and covariant in its second argument.* !"#$%&'()*+,-./0125346789:;*/0253461-.+,)*(&'$%"# !;9:8759 69  BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portable Safe-Inferred)*$X data-categoryPostcompose f c is the functor such that Postcompose f c :% g = f :.: g, for functors g that compose with f and with domain c.Y data-categoryPrecompose f e is the functor such that Precompose f e :% g = g :.: f, for functors g that compose with f and with codomain e.\ data-category)Composition of endofunctors is a functor.] data-categoryThe category of endofunctors.` data-categoryA component for an object z is an arrow from F z to G z.a data-categoryNatural transformations are built up of components, one for each object z in the domain category of f and g.c data-categoryf :~> g9 is a natural transformation from functor f to functor g.d data-category#The contravariant functor Hom(F-,X)e data-categoryThe covariant functor Hom(X,F-)i data-categoryThe dual of a functorj data-categoryCurry on the second "argument" of a functor from a product category.k data-categoryCurry on the first "argument" of a functor from a product category.o data-category-'n ! a' returns the component for the object a of a natural transformation n. This can be generalized to any arrow (instead of just identity arrows).p data-category2Horizontal composition of natural transformations.q data-category1The identity natural transformation of a functor.~ data-categoryFunctor category D^C. Objects of D^C are functors from C to D. Arrows of D^C are natural transformations. data-category%Composition of functors is a functor. data-categoryWrap f h is the functor such that Wrap f h :% g = f :.: g :.: h, for functors g that compose with f and h. data-categoryR is a bifunctor, Apply :% (f, a) applies f to a, i.e. f :% a. data-categoryP converts an object a to the functor  a. data-category>Turning a functor into its dual is contravariantly functorial.6HIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}6c`opqnrsab][Ztuvwxyz{|}^_\YmXlWkVjTURSPQNOMiLhKgJfIeHdo9  BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portable Safe-Inferred )*&{ data-category0Make an adjunction from the hom-set isomorphism. data-category,Make an adjunction from the unit and counit. data-category6Make an adjunction from an initial universal property. data-category6Make an adjunction from a terminal universal property. data-categoryThe category with categories as objects and adjunctions as arrows. BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portable Safe-Inferred( data-categoryAn initial universal property, a universal morphism from x to u. data-categoryA terminal universal property, a universal morphism from u to x. data-categoryFor an adjunction F -| G, each pair (FY, unit_Y) is an initial morphism from Y to G. data-categoryFor an adjunction F -| G, each pair (GX, counit_X) is a terminal morphism from F to X. BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portable Safe-Inferred)*) data-category! is the category with one object.  BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portable Safe-Inferred )*-  data-category.The directed coproduct category of categories c1 and c2. data-category%The coproduct category of categories c1 and c2. data-category3 is a functor which injects into the left category. data-category4 is a functor which injects into the right category. data-category f1 :+++: f2" is the coproduct of the functors f1 and f2. data-category* is the codiagonal functor for coproducts. data-category projects out to the left category, replacing a value from the right category with a fixed object. data-category projects out to the right category, replacing a value from the left category with a fixed object. data-categoryThe cograph of the profunctor f. data-categoryA natural transformation Nat c d! is isomorphic to a functor from c :**: 2 to d.  BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portable Safe-Inferred )*/ data-category! is the category with no objects. data-category!Since there is nothing to map in 2, there's a functor from it to any other category. BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portable Safe-Inferred)*-014F; data-categoryAn instance of HasColimits j k says that k has all colimits of type j. data-categoryColimits in a category k by means of a diagram of type j, which is a functor from j to k. data-category, returns the limiting co-cone for a functor f. data-category shows that the limiting co-cone is universal @ i.e. any other co-cone of f factors through it by returning the morphism between the vertices of the cones. data-categoryAn instance of  HasLimits j k says that k has all limits of type j. data-categoryLimits in a category k by means of a diagram of type j, which is a functor from j to k. data-category) returns the limiting cone for a functor f. data-category shows that the limiting cone is universal @ i.e. any other cone of f factors through it by returning the morphism between the vertices of the cones. data-categoryA co-cone from F to N is a natural transformation from F to the constant functor to N. data-categoryA cone from N to F is a natural transformation from the constant functor to N to F. data-category:The diagonal functor with the same domain and codomain as f. data-categoryThe vertex (or apex) of a cone. data-category"The vertex (or apex) of a co-cone. data-category;The limit functor is right adjoint to the diagonal functor. data-categoryThe category of one object has that object as terminal object. data-categoryThe constant functor to the terminal object is itself the terminal object in its functor category. data-categoryUnit is the terminal category. data-category() is the terminal object in Hask. data-category3A terminal object is the limit of the functor from 0 to k. data-category7The terminal object in the category of linear types is . data-categoryThe limit of any diagram with an initial object, has the limit at the initial object. data-category1Terminal objects are the dual of initial objects. data-category1Terminal objects are the dual of initial objects. data-categoryThe initial object of the direct coproduct of categories is the initial object of the initial category. data-category=The category of one object has that object as initial object. data-categoryThe initial object of the product of 2 categories is the product of their initial objects. data-categoryThe constant functor to the initial object is itself the initial object in its functor category. data-category,The empty category is the initial object in Cat. data-category5An initial object is the colimit of the functor from 0 to k. data-category,Any empty data type is an initial object in Hask. data-categoryThe binary product of the product of 2 categories is the product of their binary products. data-category=In the category of one object that object is its own product. data-categoryThe product of categories  is the binary product in /. data-category#The tuple is the binary product in Hask. data-categoryIf k has binary products, we can take the limit of 2 joined diagrams. data-categoryThe product in the category of linear types is a & b, where you have access to a and b, but not both at the same time. data-categoryBinary product as a bifunctor. data-categoryThe functor product - is the binary product in functor categories. data-categoryThe product of two functors, passing the same object to both functors and taking the product of the results. data-category2Binary products are the dual of binary coproducts. data-category2Binary products are the dual of binary coproducts. data-categoryThe binary coproduct of the product of 2 categories is the product of their binary coproducts. data-category?In the category of one object that object is its own coproduct. data-categoryThe coproduct of categories  is the binary coproduct in /. data-categoryIf k has binary coproducts, we can take the colimit of 2 joined diagrams. data-category Binary coproduct as a bifunctor. data-categoryThe functor coproduct / is the binary coproduct in functor categories. data-categoryThe coproduct of two functors, passing the same object to both functors and taking the coproduct of the results.2233  BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portable Safe-Inferred)*N data-categoryAn instance of HasLeftKan p k says there are left Kan extensions for all functors with codomain k. data-category$The left Kan extension of a functor p for functors f with codomain k. data-category gives the defining natural transformation of the left Kan extension of f along p. data-category( shows that this extension is universal. data-categoryAn instance of HasRightKan p k says there are right Kan extensions for all functors with codomain k. data-category%The right Kan extension of a functor p for functors f with codomain k. data-category gives the defining natural transformation of the right Kan extension of f along p. data-category( shows that this extension is universal. data-categoryThe right Kan extension along p) is right adjoint to precomposition with p. data-categoryThe left Kan extension along p( is left adjoint to precomposition with p. data-categoryRan (q . p) = Ran q . Ran p data-category Ran id = id data-categoryThe right Kan extension of f6 along a functor to the unit category is the limit of f. data-categoryLan (q . p) = Lan q . Lan p data-category Lan id = id data-categoryThe left Kan extension of f8 along a functor to the unit category is the colimit of f.  BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portable Safe-Inferred()*01Tp data-category8A comonad is a comonoid in the category of endofunctors. data-category4A monad is a monoid in the category of endofunctors. data-categoryComonoidObject f a defines a comonoid a. in a comonoidal category with tensor product f. data-categoryMonoidObject f a defines a monoid a, in a monoidal category with tensor product f. data-categoryDay convolution data-categoryA monoidal category is a category with some kind of tensor product. A tensor product is a bifunctor, with a unit object. data-category3Every adjunction gives rise to an associated monad. data-category?Every adjunction gives rise to an associated monad transformer. data-category5Every adjunction gives rise to an associated comonad. data-categoryEvery adjunction gives rise to an associated comonad transformer. data-categoryFunctor composition makes the category of endofunctors monoidal, with the identity functor as unit. data-categoryIf a category has all coproducts, then the coproduct functor makes it a monoidal category, with the initial object as unit. data-categoryIf a category has all products, then the product functor makes it a monoidal category, with the terminal object as unit. data-category'A monoid as a category with one object.((  BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portable Safe-Inferred )*X  data-category The maps 0 -> 1 and 2 -> 1) form a monoid, which is universal, c.f. . data-category The ordinal 10 is the terminal object of the simplex category. data-category The ordinal 0/ is the initial object of the simplex category. data-categoryThe (augmented) simplex category is the category of finite ordinals and order preserving maps. data-categoryTurn  Simplex x y arrows into Fin x -> Fin y functions. data-categoryOrdinal addition makes the simplex category a monoidal category, with 0 as unit. data-categoryOrdinal addition is a bifuntor, it concattenates the maps as it were. data-category%Replicate a monoid a number of times. data-categoryThe cobar construction BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portable Safe-Inferred)*Y data-categoryThe category of Kleisli arrows. BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portable Safe-Inferred()*^  data-categoryA anamorphism of an F-coalgebra is the arrow from it to the terminal F-coalgebra. data-categoryA catamorphism of an F-algebra is the arrow to it from the initial F-algebra. data-categoryThe terminal F-coalgebra is the terminal object in the category of F-coalgebras. data-categoryThe initial F-algebra is the initial object in the category of F-algebras. data-category-Arrows of Dialg(F,G) are (F,G)-homomorphisms. data-category+Objects of Dialg(F,G) are (F,G)-dialgebras. data-category!The category of (F,G)-dialgebras. data-categoryThe category for defining the natural numbers and primitive recursion can be described as  Dialg(F,G), with  F(A)=<1,A> and  G(A)=. data-categoryFreeAlg M takes x to the free algebra  (M x, mu_x) of the monad M. data-category ForgetAlg m is the forgetful functor for Alg m. BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portable Safe-Inferred )*_ data-categoryTurn Cube x y arrows into ACube x -> ACube y functions. data-categoryOrdinal addition is a bifuntor, it concattenates the maps as it were. BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portable Safe-Inferred)*a data-categoryTaking the target of an arrow is left adjoint to taking the identity of an object data-categoryTaking the source of an arrow is right adjoint to taking the identity of an object data-category!The comma category T \downarrow S BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portable Safe-Inferred)*ds data-categoryw#-weighted colimits in the category k. data-categoryw!-weighted limits in the category k. data-categoryRegular limits as weigthed limits, weighted by the constant functor to (). data-categoryEnds as Hom-weighted limits data-categoryRegular colimits as weigthed colimits, weighted by the constant functor to (). data-category!Coends as OpHom-weighted colimits data-category)The Hom-functor but with opposite domain.'' BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portable Safe-Inferred f data-categoryThe Yoneda embedding functor, C -> Set^(C^op). data-category and 3 are together the isomophism from the Yoneda lemma. data-category converts a functor f9 into a natural transformation from the hom functor to f.   BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portable Safe-Inferred)*01j] data-categoryFrom every adjunction we get a monad, in this case the State monad. data-categoryA category is cartesian closed if it has all products and exponentials for all objects. data-categoryThe product functor is left adjoint the the exponential functor. data-categoryFrom the adjunction between the product functor and the exponential functor we get the curry and uncurry functions, generalized to any cartesian closed category. data-categoryExponentials in Cat are the functor categories. data-categoryExponentials in Hask are functions. data-categoryThe exponential as a bifunctor. data-category)The category of presheaves on a category C is cartesian closed for any C. BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portable Safe-Inferred 5n  data-category Take the  category, add a new disctinct object, and an arrow from that object to every object in , and you get  again. data-categoryFix f inherits its exponentials from  f (Fix f). data-categoryFix f inherits its (co)limits from  f (Fix f). data-categoryFix f inherits its (co)limits from  f (Fix f). data-categoryFix f inherits its (co)limits from  f (Fix f). data-categoryFix f inherits its (co)limits from  f (Fix f). data-categoryThe  functor wraps  around  f (Fix f). data-categoryThe  functor unwraps Fix f to  f (Fix f). data-categoryFix f inherits tensor products from  f (Fix f). data-category f7 is the fixed point category for a category combinator f.   BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portable Safe-Inferred)*o^ Safe-Inferred)*01o   BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portable Safe-Inferred)*/r  data-categoryArrows as elements of k data-categoryAn enriched category data-category%The category V which k is enriched in data-categoryThe hom object in V from a to b data-category/The underlying category of an enriched category data-category$The opposite of an enriched category data-category5The enriched product category of enriched categories c1 and c2. data-categorySelf enrichment data-category2Any regular category is enriched in (->), aka Hask BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portable Safe-Inferred)*/x0 data-category!Enriched natural transformations. data-categoryThe enriched functor k(-, x) data-categoryThe enriched functor k(x, -) data-categoryEnriched functors. data-category/The domain, or source category, of the functor. data-category1The codomain, or target category, of the functor. data-category:%% maps objects at the type level data-category%% maps object at the value level data-category maps arrows. data-categoryA V-enrichment on a functor  F: V -> V) is the same thing as tensorial strength (a, f b) -> f (a, b). data-categoryThe identity functor on k data-category The composition of two functors. data-categoryThe constant functor. data-categoryThe dual of a functor data-categoryf1 : *: f2 is the product of the functors f1 and f2. data-category& is the diagonal functor for products. data-category.The underlying functor of an enriched functor f data-category0A regular functor is a functor enriched in Hask. data-category.The underlying functor of an enriched functor f enriched in Hask.$$ BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portable Safe-Inferred)*/y data-categoryThe enriched functor category [a, b] Safe-Inferred )*z{ data-category4`ordExp a b` is the largest x such that min x a <= b BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portable Safe-Inferred)*/{v data-categoryYoneda embedding BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portable Safe-Inferred)* data-categoryThe target functor sends arrows (as functors from the Boolean category) to their target. data-categoryThe source functor sends arrows (as functors from the Boolean category) to their source. data-category Terminator( is right adjoint to the source functor. data-category Initializer' is left adjoint to the target functor. data-categoryThe colimit of a functor from the Boolean category is the target of the arrow it points to. data-categoryThe limit of a functor from the Boolean category is the source of the arrow it points to. data-category8Implication makes the Boolean category cartesian closed. data-category is the functor that sends an object to its terminating arrow. data-category Initializer k? is the functor that sends an object to its initializing arrow. BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portable Safe-Inferred)*/n ! " #$%%&'()*+,-.//0123445678899::;;<<==>>?@@AABBCDEFGHIJKL567MNOPQRSTUVWXYZ[\]^__``aabbcdefghijkklmmnop[\]^cdefqrstuvwxyz{|}~                                                                                                                                                              bbm88^^@@AABB+)data-category-0.11-A2DCjde1a8UEe4FHs10U5MData.Category.Limit Data.CategoryData.Category.ProductData.Category.Functor#Data.Category.NaturalTransformationData.Category.Adjunction"Data.Category.RepresentableFunctorData.Category.UnitData.Category.CoproductData.Category.VoidData.Category.KanExtensionData.Category.MonoidalData.Category.SimplexData.Category.KleisliData.Category.DialgData.Category.CubeData.Category.CommaData.Category.WeightedLimitData.Category.YonedaData.Category.CartesianClosedData.Category.FixData.Category.NNOData.Category.FinData.Category.EnrichedData.Category.Enriched.FunctorData.Category.Enriched.LimitData.Category.PreorderData.Category.Enriched.YonedaData.Category.BooleanData.Category.Enriched.Poset3base Data.EitherEitherLeftRightKindOpunOpCategorysrctgt.Objobj$fCategoryTYPEFUN $fCategorykOp:**:$fCategoryTYPE:**: ProfunctorOf:-*::*-:HomTuple2SwapTuple1DiagProd:***:Proj2Proj1AnyOpOpInvOpOpConstFConst:.:IdCatCatA FunctorOfFunctorDomCod:%%Hom_XHomX_ $fFunctorId $fFunctor:.:$fCategoryFUNCat$fFunctorConst $fFunctorOpOp$fFunctorOpOpInv$fFunctorProj1$fFunctorProj2$fFunctor:***:$fFunctorDiagProd $fFunctorHom $fFunctorAny:%*::*%:CostarStarHomFOppositeOppTupleApplyWrapCurry2Curry1 Postcompose Precompose Profunctors PresheavesEndoFunctorComposeEndoFunctorCompose ComponentNat:~>HomFXHomXFNatId!onatIdsrcFtgtF compAssoc compAssocInv idPrecomp idPrecompInv idPostcomp idPostcompInvconstPrecompInconstPrecompOutconstPostcompInconstPostcompOut$fCategoryTYPENat$fFunctorFunctorCompose $fFunctorWrap$fFunctorApply$fFunctorTuple $fFunctorOppAdjArrow Adjunction leftAdjoint rightAdjoint leftAdjunctN rightAdjunctN mkAdjunctionmkAdjunctionUnitsmkAdjunctionInitmkAdjunctionTerm leftAdjunct rightAdjunctadjunctionUnitadjunctionCounitidAdj composeAdj precomposeAdjpostcomposeAdjcontAdj$fCategoryFUNAdjArrowTerminalUniversalInitialUniversal RepresentablerepresentedFunctorrepresentingObject representuniversalElement unrepresentcovariantHomReprcontravariantHomReprinitialUniversalterminalUniversaladjunctionInitialPropadjunctionTerminalPropinitialPropAdjunctionterminalPropAdjunctionUnit$fCategoryTYPEUnit NatAsFunctor:>>:DCCographI1AI2AI12Cotuple2Cotuple1 CodiagCoprod:+++:Inj2Inj1:++:I1I2$fCategoryTYPE:++: $fFunctorInj1 $fFunctorInj2$fFunctor:+++:$fFunctorCodiagCoprod$fFunctorCotuple1$fFunctorCotuple2$fCategoryTYPECograph$fFunctorNatAsFunctor$fCategoryTYPE:>>:MagicVoidmagicvoidNat$fCategoryTYPEVoid$fFunctorMagic:+:CoproductFunctorHasBinaryCoproductsBinaryCoproductinj1inj2|||+++:*:ProductFunctor&AddConjHasBinaryProducts BinaryProductproj1proj2&&&***ZeroHasInitialObject InitialObject initialObject initializeHasTerminalObjectTerminalObjectterminalObject terminateColimitFunctorColimit HasColimits ColimitFamcolimitcolimitFactorizer LimitFunctorLimit HasLimitsLimitFamlimitlimitFactorizerCoconeConeDiagFDiag coneVertex coconeVertexlimitAdjadjLimitadjLimitFactorizerrightAdjointPreservesLimitsrightAdjointPreservesLimitsInv colimitAdj adjColimitadjColimitFactorizerleftAdjointPreservesColimitsleftAdjointPreservesColimitsInvprodAdj coprodAdj $fFunctorDiag$fHasLimitsUnitk$fFunctorLimitFunctor$fHasColimitsUnitk$fFunctorColimitFunctor$fHasColimits:>>:k$fHasTerminalObjectTYPE:>>:$fHasTerminalObjectTYPE:**:$fHasTerminalObjectTYPEUnit$fHasTerminalObjectTYPENat$fHasTerminalObjectFUNCat$fHasTerminalObjectTYPEFUN$fHasLimitsVoidk$fHasTerminalObjectTYPEFUN0$fHasLimits:>>:k$fHasInitialObjectkOp$fHasTerminalObjectkOp$fHasInitialObjectTYPE:>>:$fHasInitialObjectTYPEUnit$fHasInitialObjectTYPE:**:$fHasInitialObjectTYPENat$fHasInitialObjectFUNCat$fHasColimitsVoidk$fHasInitialObjectTYPEFUN$fHasBinaryProductsTYPE:>>:$fHasBinaryProductsTYPE:**:$fHasBinaryProductsTYPEUnit$fHasBinaryProductsFUNCat$fHasBinaryProductsTYPEFUN$fHasLimits:++:k$fHasBinaryProductsTYPEFUN0$fFunctorProductFunctor$fHasBinaryProductsTYPENat $fFunctor:*:$fHasBinaryCoproductskOp$fHasBinaryProductskOp$fHasBinaryCoproductsTYPE:>>:$fHasBinaryCoproductsTYPE:**:$fHasBinaryCoproductsTYPEUnit$fHasBinaryCoproductsFUNCat$fHasBinaryCoproductsTYPEFUN$fHasColimits:++:k$fFunctorCoproductFunctor$fHasBinaryCoproductsTYPENat $fFunctor:+:$fHasLimitsFUNFUN$fHasColimitsFUNFUNLanHaskFLanHaskRanHaskFRanHask LanFunctorLan HasLeftKanLanFamlan lanFactorizer RanFunctorRan HasRightKanRanFamran ranFactorizerranFranF'ranAdjlanFlanF'lanAdj$fHasRightKan:.:k$fHasRightKanIdk$fHasRightKanConstk$fFunctorRanFunctor$fHasLeftKan:.:k$fHasLeftKanIdk$fHasLeftKanConstk$fFunctorLanFunctor$fHasRightKanAnyFUN$fFunctorRanHaskF$fHasLeftKanAnyFUN$fFunctorLanHaskFComonadMonadMonoidAsCategory MonoidValueComonoidObjectcounit comultiply MonoidObjectunitmultiplyDay LinearTensorSymmetricTensorProductswap TensorProduct unitObject leftUnitor leftUnitorInv rightUnitorrightUnitorInv associator associatorInv trivialMonoidcoproductMonoidtrivialComonoidproductComonoidmkMonad monadFunctoridMonad mkComonad idComonadadjunctionMonadadjunctionMonadTadjunctionComonadadjunctionComonadT$fTensorProductFunctorCompose$fTensorProductCoproductFunctor$fTensorProductProductFunctor($fSymmetricTensorProductCoproductFunctor&$fSymmetricTensorProductProductFunctor$$fSymmetricTensorProductLinearTensor$fTensorProductLinearTensor$fFunctorLinearTensor$fTensorProductDay $fFunctorDay$fCategoryTYPEMonoidAsCategory ReplicateAddForgetFinFzFsSimplexZYXSsucuniversalMonoid$fHasTerminalObjectTYPESimplex$fHasInitialObjectTYPESimplex$fCategoryTYPESimplex$fFunctorForget$fTensorProductAdd $fFunctorAdd$fFunctorReplicate$fFunctorCobar KleisliForget KleisliFreeKleisli kleisliId kleisliAdj$fCategoryTYPEKleisli$fFunctorKleisliFree$fFunctorKleisliForget ForgetAlgFreeAlgNatNumAnaCataTerminalFAlgebraInitialFAlgebra CoalgebraCoalgAlgebraAlgDialgDialgA DialgebradialgId dialgebraprimRecfreeAlgeilenbergMooreAdj$fCategoryTYPEDialg$fHasInitialObjectTYPEDialg$fFunctorFreeAlg$fFunctorForgetAlgACubeNilConsSign0SMS0SPCubeSignMP$fHasTerminalObjectTYPECube$fCategoryTYPECubeTgtSrcIdArrowArrows ObjectsOver ObjectsUnder ObjectsFOver ObjectsFUnder:/\:CommaACommaOcommaIdinitialUniversalCommaterminalUniversalCommatgtIdAdjidSrcAdj$fCategoryTYPE:/\:$fFunctorIdArrow $fFunctorSrc $fFunctorTgt HaskCoend CoendFunctorOpHom HasCoendsCoendcoend coendCounitcoendFactorizerWColimit HasWColimitsWeightedColimit colimitObjWeightedCoconeHaskEnd getHaskEnd EndFunctorHasEndsEndend endCounit endFactorizerWLimit HasWLimits WeightedLimitlimitObj WeightedCone$fHasWLimitskConst$fHasWLimitskHom$fFunctorEndFunctor $fHasEndsFUN$fHasWColimitskConst$fHasWColimitskOpHom$fFunctorOpHom$fFunctorCoendFunctor$fHasCoendsFUNM1YonedaYonedaEmbedding fromYonedatoYonedahaskUnit haskIsTotal$fFunctorYoneda $fFunctorM1ContextStatePShExponential ExpFunctorCartesianClosed Exponentialapplytuple^^^PshExponentialflipcurryAdjcurryuncurrystateMonadReturnstateMonadJoincontextComonadExtractcontextComonadDuplicate$fCartesianClosedFUNCat$fCartesianClosedTYPEUnit$fCartesianClosedTYPEFUN$fFunctorExpFunctor$fCartesianClosedTYPENatOmega WrapTensorUnwrapFixz2s$fCartesianClosedTYPEFix$fHasBinaryCoproductsTYPEFix$fHasBinaryProductsTYPEFix$fHasTerminalObjectTYPEFix$fHasInitialObjectTYPEFix$fFunctorUnwrap$fTensorProduct:.:$fCategoryTYPEFixHasNaturalNumberObjectNaturalNumberObjectzerosucc$fHasNaturalNumberObjectFUNProofLTEZEQZLTSLTFZFSproof$fCartesianClosedFinLTE$fHasBinaryProductsFinLTE$fHasBinaryProductsFinLTE0$fHasBinaryCoproductsFinLTE$fHasBinaryCoproductsFinLTE0$fHasTerminalObjectFinLTE$fHasTerminalObjectFinLTE0$fHasInitialObjectFinLTE$fCategoryFinLTE$fCartesianClosedFinLTE0InHaskSelfgetSelf:<>:EOp UnderlyingArr ECategoryV$homidcompcompArrtoSelffromSelf$fCategoryTYPEUnderlying$fECategoryEOp$fECategory:<>:$fECategorySelf$fECategoryInHaskENatEHom_XEHomX_EHomUnderlyingHask InHaskToHaskInHaskF UnderlyingF:<*>: EFunctorOfEFunctorEDomECod:%%%%mapstrength $fEFunctorId $fEFunctor:.:$fEFunctorConst$fEFunctorOpposite$fEFunctor:<*>:$fEFunctorDiagProd$fFunctorUnderlyingF$fEFunctorInHaskF$fEFunctorInHaskToHask$fFunctorUnderlyingHask$fEFunctorEHom$fEFunctorEHomX_$fEFunctorEHom_X colimitInvColimWeigtedColimitlimitInvLim WeigtedLimit:->>:FunCatFArr VProfunctor->>$fECategoryFunCat$fEFunctorEndFunctor$fHasLimitsInHaskInHaskToHask$fHasLimitsSelfw FromIntegerFloorEnd'EnumObjsenumObjsPreorder:<=:unObjordExpglbfloorGaloisConnection$fCartesianClosedTYPEPreorder!$fHasBinaryCoproductsTYPEPreorder$fHasBinaryProductsTYPEPreorder$fHasTerminalObjectTYPEPreorder$fHasInitialObjectTYPEPreorder$fCategoryTYPEPreorder$fFunctorFloor$fFunctorFromIntegeryoneda yonedaInv $fEFunctorY Initializer Terminator TgtFunctor SrcFunctorArrowBooleanFlsF2TTrutrueProductMonoidfalseCoproductComonoidtrueProductComonoidfalseCoproductMonoidtrueCoproductMonoidfalseProductComonoidterminatorLimitAdjinitializerColimitAdj$fHasColimitsBooleank$fHasLimitsBooleank$fCartesianClosedTYPEBoolean $fHasBinaryCoproductsTYPEBoolean$fHasBinaryProductsTYPEBoolean$fHasTerminalObjectTYPEBoolean$fHasInitialObjectTYPEBoolean$fCategoryTYPEBoolean$fFunctorArrow$fFunctorTerminator$fFunctorInitializerPoset3 PosetTestOneTwoThree$fECategoryPosetTestTop