!zW      !"#$%&'()*+,-./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 vwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portableSafe&'HSVX' data-categoryAn instance of  Category k declares the arrow k as a category. data-category\Whenever objects are required at value level, they are represented by their identity arrows. data-categoryKThe category with Haskell types as objects and Haskell functions as arrows.  data-categoryOp k& is opposite category of the category k.8 BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portableSafe&'>HUV*  data-category#The product category of categories c1 and c2.   BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portableSafe&',=>?HSUVXgD_% data-category<The constant functor with the same domain and codomain as f., data-categorydWe need a wrapper here because objects need to be of kind *, and categories are of kind * -> * -> *.- data-category(Functors are arrows in the category Cat.0 data-category Functors map objects and arrows.1 data-category/The domain, or source category, of the functor.2 data-category1The codomain, or target category, of the functor.3 data-category:% maps objects.4 data-category% maps arrows.8 data-category#The contravariant functor Hom(--,X)9 data-categoryThe covariant functor Hom(X,--): data-category) tuples with a fixed object on the right.; data-categoryswap5 swaps the 2 categories of the product of categories.< data-category( tuples with a fixed object on the left.= data-categoryThe identity functor on k> data-category The composition of two functors.? data-categoryCatB is the category with categories as objects and funtors as arrows.@ data-categoryThe constant functor.A data-categoryThe dual of a functorB data-categoryThe  Op (Op x) = x functor.C data-categoryThe  x = Op (Op x) functor.D data-categoryC is a bifunctor that projects out the first component of a product.E data-categoryD is a bifunctor that projects out the second component of a product.F data-category f1 :***: f2 is the product of the functors f1 and f2.G data-category& is the diagonal functor for products.H data-categoryrThe Hom functor, Hom(--,--), a bifunctor contravariant in its first argument and covariant in its second argument.0  !"#$%&'()*+,-./0132456789:;<0-.,01324/*+()&'%#$!" <:;9876 539 49  BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portableSafe&'=>?HRSUVXg^O 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.P 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.S data-category)Composition of endofunctors is a functor.T data-categoryThe category of endofunctors.W data-categoryA component for an object z is an arrow from F z to G z.X data-categoryINatural transformations are built up of components, one for each object z in the domain category of f and g.Z data-categoryf :~> g9 is a natural transformation from functor f to functor g.] data-category-'n ! a' returns the component for the object a of a natural transformation nL. This can be generalized to any arrow (instead of just identity arrows).^ data-category2Horizontal composition of natural transformations._ data-category1The identity natural transformation of a functor.l data-categorykFunctor category D^C. Objects of D^C are functors from C to D. Arrows of D^C are natural transformations.m data-category%Composition of functors is a functor.n 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.o data-categoryK is a bifunctor, Apply :% (f, a) applies f to a, i.e. f :% a.p data-categoryI converts an object a to the functor  a.#IJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijk#ZW]^_`aXYTRQbcdefghijkUVSP\O[MNKLIJ]9  BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portableSafeHSUVXc| data-category@An initial universal property, a universal morphism from x to u.} data-category@A terminal universal property, a universal morphism from u to x. qrstxwvuyz{|} stxwvuyz{r|q} BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portableSafe &'>HSUVXg9 data-categoryBThe category with categories as objects and adjunctions as arrows.~~ BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portableSafe&'j7 data-category! is the category with one object. BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portableNone &'>HMUVxY  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-categoryb projects out to the left category, replacing a value from the right category with a fixed object. data-categoryb 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-portableSafe &'HUV_f}* 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-portableNone&'=>?@AHSUVX̯9 data-categoryAn instance of HasColimits j k says that k has all colimits of type j. data-category, returns the limiting co-cone for a functor f. data-categoryJ shows that the limiting co-cone is universal  i.e. any other co-cone of fS factors through it by returning the morphism between the vertices of the cones. data-categoryColimits in a category k by means of a diagram of type j, which is a functor from j to k. data-categoryAn instance of  HasLimits j k says that k has all limits of type j. data-category) returns the limiting cone for a functor f. data-categoryD shows that the limiting cone is universal  i.e. any other cone of fS factors through it by returning the morphism between the vertices of the cones. data-categoryLimits in a category k by means of a diagram of type j, which is a functor from j to k. data-categoryVA co-cone from F to N is a natural transformation from F to the constant functor to N. data-categorySA 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-category<The colimit functor is left adjoint to the diagonal functor. data-category5A specialisation of the limit adjunction to products. data-category9A specialisation of the colimit adjunction to coproducts. data-category3The diagonal functor from (index-) category J to k. data-category,The limit of a single object is that object. data-categoryIf every diagram of type j has a limit in kH there exists a limit functor. It can be seen as a generalisation of (***). data-category.The colimit of a single object is that object. data-categoryIf every diagram of type j has a colimit in kJ there exists a colimit functor. It can be seen as a generalisation of (+++). data-categoryXThe colimit of any diagram with a terminal object, has the limit at the terminal object. data-categoryjThe terminal object of the direct coproduct of categories is the terminal object of the terminal category. data-category\The terminal object of the product of 2 categories is the product of their terminal objects. data-category>The category of one object has that object as terminal object. data-categorybThe 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-categoryUThe 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-categorygThe 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-categoryZThe initial object of the product of 2 categories is the product of their initial objects. data-category`The 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-categoryZThe 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 kA has binary products, we can take the limit of 2 joined diagrams. data-categoryBinary product as a bifunctor. data-categoryThe functor product - is the binary product in functor categories. data-categorylThe 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-category^The 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 kE 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-categorypThe 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-portableNone %&'=?HSUVX ) 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.1 data-categoryMonoidObject f a defines a monoid a, in a monoidal category with tensor product f.7 data-category{A monoidal category is a category with some kind of tensor product. A tensor product is a bifunctor, with a unit object.I data-category3Every adjunction gives rise to an associated monad.J data-category?Every adjunction gives rise to an associated monad transformer.K data-category5Every adjunction gives rise to an associated comonad.L data-categoryAEvery adjunction gives rise to an associated comonad transformer.M data-categorycFunctor composition makes the category of endofunctors monoidal, with the identity functor as unit.N data-category~If a category has all coproducts, then the coproduct functor makes it a monoidal category, with the initial object as unit.O data-category{If a category has all products, then the product functor makes it a monoidal category, with the terminal object as unit.R data-category'A monoid as a category with one object.$)*+,-.0/1243567?>=<;:98@ABCDEFGHIJKL$7?>=<;:98561243@A-.0/BC+,*DEF)GHIJKL  BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portableNone &'HSUVXc data-category The maps 0 -> 1 and 2 -> 1) form a monoid, which is universal, c.f. S.d data-category The ordinal 10 is the terminal object of the simplex category.e data-category The ordinal 0/ is the initial object of the simplex category.f data-category^The (augmented) simplex category is the category of finite ordinals and order preserving maps.g data-categoryTurn  Simplex x y arrows into Fin x -> Fin y functions.h data-categoryFOrdinal addition makes the simplex category a monoidal category, with 0 as unit.i data-categoryEOrdinal addition is a bifuntor, it concattenates the maps as it were.j data-category%Replicate a monoid a number of times.STUVWXYZ[\]^_`abc\]^_a`bWXYZ[UVcST  BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portableNone&'=>?HSUVXs data-categoryThe category of Kleisli arrows.klmnopqropqmnklr BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portableNone%&'=>?HUVX^ } data-categoryQA anamorphism of an F-coalgebra is the arrow from it to the terminal F-coalgebra.~ data-categoryMA catamorphism of an F-algebra is the arrow to it from the initial F-algebra. data-categoryPThe terminal F-coalgebra is the terminal object in the category of F-coalgebras. data-categoryJThe 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-category[The category for defining the natural numbers and primitive recursion can be described as  Dialg(F,G), with  F(A)=<1,A> and  G(A)=<A,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.vwxyz|{}~~}z|{xyvw BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portableNone &'HSUVXF data-categoryTurn Cube x y arrows into ACube x -> ACube y functions. data-categoryEOrdinal addition is a bifuntor, it concattenates the maps as it were. BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portableNone&'=>?@AHUVX  data-category!The comma category T \downarrow S   BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portableSafe HSUVXgA 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-portableNone&'=?HSUVXgS data-categoryCFrom every adjunction we get a monad, in this case the State monad. data-categoryWA category is cartesian closed if it has all products and exponentials for all objects. data-category@The 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-portableNone 1=?HMUVg+  data-category Take the X category, add a new disctinct object, and an arrow from that object to every object in , and you get  again. 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. 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).   BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portableNone&'HUV.  BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portableNone&'=?@AHUVX_HSUVXgkT5 data-categoryThe enriched functor k(-, x)7 data-categoryThe enriched functor k(x, -)9 data-category!Enriched natural transformations.L data-categoryEnriched functors.M data-category/The domain, or source category, of the functor.N data-category1The codomain, or target category, of the functor.O data-category:%% maps objects at the type levelP data-category%% maps object at the value levelQ data-categoryQ maps arrows.] data-categoryArrows as elements of k^ data-categoryThe elements of k as a functor from V k to (->) _ data-categoryAn enriched category` data-category;The tensor product of the category V which k is enriched ina data-categoryThe hom object in V from a to bl data-category/The underlying category of an enriched categorym data-category$The opposite of an enriched categoryn data-category5The enriched product category of enriched categories c1 and c2.o data-categorySelf enrichmentp data-category2Any regular category is enriched in (->), aka Haskq data-categoryThe identity functor on kr data-category The composition of two functors.s data-categoryThe constant functor.t data-categoryThe dual of a functoru data-categoryf1 : *: f2 is the product of the functors f1 and f2.v data-category?& is the diagonal functor for products.w data-category.The underlying functor of an enriched functor f| data-categoryThe enriched functor category [a, b] data-categoryYoneda embedding[ !$"#%&'()*+,-./2103456789:;<=>?@ABCDEFGHIJKLPQOMNRSTUVWXYZ[\]^_dcba`efghijk[_dcba`^e]f[\YZWXTUVghRSLPQOMNKIJGHEFCDAB?@=>;<9:785643/210,-.*+)i'(&%!$"# jk  !"#$%&''()*++,,--..//001123344556789:;<=>"#$?@()*ABCDEFGHIJKLMMNNOOPQRSTUVVWXXYPQZ[\]^_`abcdefghijklmnoppqrstuvwxyzz{{|}~                                                                        ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 8 9 9 : : ; < = > ? @ A B ? C D E F G H I J K L L M M N N O P Q R STTUUV?BWXYZ[\]^_`aabcdefghi99::jklmnopq?B@ArstB?uvHIJwxyz{|}}~B?OOB?kV?Bd@@++11334455     )data-category-0.7.2-WCNQnZww6Y7HJ95zgopcH Data.CategoryData.Category.ProductData.Category.Functor#Data.Category.NaturalTransformation"Data.Category.RepresentableFunctorData.Category.AdjunctionData.Category.UnitData.Category.CoproductData.Category.VoidData.Category.LimitData.Category.MonoidalData.Category.SimplexData.Category.KleisliData.Category.DialgData.Category.CubeData.Category.CommaData.Category.YonedaData.Category.CartesianClosedData.Category.FixData.Category.NNOData.Category.BooleanData.Category.EnrichedOpunOpCategorysrctgt.Obj $fCategory-> $fCategoryOp:**:$fCategory:**:CostarStarHomF:-*::*-:HomTuple2SwapTuple1DiagProd:***:Proj2Proj1OpOpInvOpOpOppositeConstFConst:.:IdCatWCatCatA FunctorOfFunctorDomCod:%%Hom_XHomX_ $fFunctorId $fFunctor:.: $fCategoryCat$fFunctorConst$fFunctorOpposite $fFunctorOpOp$fFunctorOpOpInv$fFunctorProj1$fFunctorProj2$fFunctor:***:$fFunctorDiagProd $fFunctorHomTupleApplyWrap Postcompose Precompose Profunctors PresheavesEndoFunctorComposeEndoFunctorCompose ComponentNat:~>!onatIdsrcFtgtF compAssoc compAssocInv idPrecomp idPrecompInv idPostcomp idPostcompInvconstPrecompInconstPrecompOutconstPostcompInconstPostcompOut $fCategoryNat$fFunctorFunctorCompose $fFunctorWrap$fFunctorApply$fFunctorTupleTerminalUniversalInitialUniversal RepresentablerepresentedFunctorrepresentingObject representuniversalElement unrepresentcovariantHomReprcontravariantHomReprinitialUniversalterminalUniversalAdjArrow Adjunction leftAdjoint rightAdjoint leftAdjunctN rightAdjunctN mkAdjunctionmkAdjunctionUnits leftAdjunct rightAdjunctadjunctionUnitadjunctionCounitadjunctionInitialPropadjunctionTerminalPropinitialPropAdjunctionterminalPropAdjunctionidAdj composeAdj precomposeAdjpostcomposeAdjcontAdj$fCategoryAdjArrowUnit$fCategoryUnit NatAsFunctor:>>:DCCographI1AI2AI12Cotuple2Cotuple1 CodiagCoprod:+++:Inj2Inj1:++:I1I2$fCategory:++: $fFunctorInj1 $fFunctorInj2$fFunctor:+++:$fFunctorCodiagCoprod$fFunctorCotuple1$fFunctorCotuple2$fCategoryCograph$fFunctorNatAsFunctor$fCategory:>>:MagicVoidmagicvoidNat$fCategoryVoid$fFunctorMagic:+:CoproductFunctorHasBinaryCoproductsBinaryCoproductinj1inj2|||+++:*:ProductFunctorHasBinaryProducts BinaryProductproj1proj2&&&***ZeroHasInitialObject InitialObject initialObject initializeHasTerminalObjectTerminalObjectterminalObject terminateColimitFunctor HasColimitscolimitcolimitFactorizerColimit ColimitFam LimitFunctor HasLimitslimitlimitFactorizerLimitLimitFamCoconeConeDiagFDiag coneVertex coconeVertexlimitAdjrightAdjointPreservesLimitsrightAdjointPreservesLimitsInv colimitAdjleftAdjointPreservesColimitsleftAdjointPreservesColimitsInvprodAdj coprodAdj $fFunctorDiag$fHasLimitsUnitk$fFunctorLimitFunctor$fHasColimitsUnitk$fFunctorColimitFunctor$fHasColimits:>>:k$fHasTerminalObject:>>:$fHasTerminalObject:**:$fHasTerminalObjectUnit$fHasTerminalObjectNat$fHasTerminalObjectCat$fHasTerminalObject->$fHasLimitsVoidk$fHasLimits:>>:k$fHasInitialObjectOp$fHasTerminalObjectOp$fHasInitialObject:>>:$fHasInitialObjectUnit$fHasInitialObject:**:$fHasInitialObjectNat$fHasInitialObjectCat$fHasColimitsVoidk$fHasInitialObject->$fHasBinaryProducts:>>:$fHasBinaryProducts:**:$fHasBinaryProductsUnit$fHasBinaryProductsCat$fHasBinaryProducts->$fHasLimits:++:k$fFunctorProductFunctor$fHasBinaryProductsNat $fFunctor:*:$fHasBinaryCoproductsOp$fHasBinaryProductsOp$fHasBinaryCoproducts:>>:$fHasBinaryCoproducts:**:$fHasBinaryCoproductsUnit$fHasBinaryCoproductsCat$fHasColimits:++:k$fFunctorCoproductFunctor$fHasBinaryCoproductsNat $fFunctor:+:$fHasLimits->->$fHasColimits->->ComonadMonadMonoidAsCategory MonoidValueComonoidObjectcounit comultiply MonoidObjectunitmultiplySymmetricTensorProductswap TensorProduct unitObject leftUnitor leftUnitorInv rightUnitorrightUnitorInv associator associatorInv trivialMonoidcoproductMonoidtrivialComonoidproductComonoidmkMonad monadFunctoridMonad mkComonad idComonadadjunctionMonadadjunctionMonadTadjunctionComonadadjunctionComonadT$fTensorProductFunctorCompose$fTensorProductCoproductFunctor$fTensorProductProductFunctor($fSymmetricTensorProductCoproductFunctor&$fSymmetricTensorProductProductFunctor$fCategoryMonoidAsCategory ReplicateAddForgetFinFzFsSimplexZYXSsucuniversalMonoid$fHasTerminalObjectSimplex$fHasInitialObjectSimplex$fCategorySimplex$fFunctorForget$fTensorProductAdd $fFunctorAdd$fFunctorReplicate KleisliAdjG KleisliAdjFKleisli kleisliId kleisliAdj$fCategoryKleisli$fFunctorKleisliAdjF$fFunctorKleisliAdjG ForgetAlgFreeAlgNatNumAnaCataTerminalFAlgebraInitialFAlgebra CoalgebraCoalgAlgebraAlgDialgDialgA DialgebradialgId dialgebraprimReceilenbergMooreAdj$fCategoryDialg$fHasInitialObjectDialg$fFunctorFreeAlg$fFunctorForgetAlgACubeNilConsSign0SMS0SPCubeSignMP$fHasTerminalObjectCube$fCategoryCube ObjectsOver ObjectsUnder ObjectsFOver ObjectsFUnder:/\:CommaACommaOcommaIdinitialUniversalCommaterminalUniversalComma$fCategory:/\:M1YonedaYonedaEmbedding fromYonedatoYonedahaskUnit haskIsTotal$fFunctorYoneda $fFunctorM1ContextStatePShExponential ExpFunctorCartesianClosed Exponentialapplytuple^^^PshExponentialflipcurryAdjcurryuncurrystateMonadReturnstateMonadJoincontextComonadExtractcontextComonadDuplicate$fCartesianClosedCat$fCartesianClosedUnit$fCartesianClosed->$fFunctorExpFunctor$fCartesianClosedNatOmega WrapTensorUnwrapFixz2s$fFunctorUnwrap$fTensorProduct:.:$fCartesianClosedFix$fHasBinaryCoproductsFix$fHasBinaryProductsFix$fHasTerminalObjectFix$fHasInitialObjectFix $fCategoryFixHasNaturalNumberObjectNaturalNumberObjectzerosucc$fHasNaturalNumberObject->ArrowBooleanFlsF2TTrutrueProductMonoidfalseCoproductComonoidtrueProductComonoidfalseCoproductMonoidtrueCoproductMonoidfalseProductComonoid$fHasColimitsBooleank$fHasLimitsBooleank$fCartesianClosedBoolean$fHasBinaryCoproductsBoolean$fHasBinaryProductsBoolean$fHasTerminalObjectBoolean$fHasInitialObjectBoolean$fCategoryBoolean$fFunctorArrowPoset3 PosetTestOneTwoThree colimitObj colimitInvColimWeigtedColimitlimitObjlimitInvLim WeigtedLimit EndFunctor:->>:FunCatFArrHaskEnd getHaskEndHasEndsend endCounit endFactorizerEnd VProfunctorEHom_XEHomX_ENatEHom UnderlyingF:<*>: EFunctorOfEFunctorEDomECod:%%%%mapInHaskSelfgetSelf:<>:EOp UnderlyingArrElem ECategoryV$homidcompelemcompArrtoSelffromSelf->>yoneda yonedaInv$fCategoryUnderlying$fECategoryEOp$fECategory:<>:$fECategorySelf$fECategoryInHask $fEFunctorId $fEFunctor:.:$fEFunctorConst$fEFunctorOpposite$fEFunctor:<*>:$fEFunctorDiagProd$fFunctorUnderlyingF$fEFunctorEHom$fEFunctorEHomX_$fEFunctorEHom_X $fHasEnds->$fECategoryFunCat$fEFunctorEndFunctor$fHasLimitsSelf $fEFunctorY$fECategoryPosetTestR:ExponentialFixyzR:BinaryCoproductFixxyR:BinaryProductFixxyR:TerminalObjectFixR:InitialObjectFix