!L      !"#$%&'()*+,-./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 { | } ~       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portableSafe &'-HSVX+ 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-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-portableNone&',-=>?HMSUVXgH  data-categoryEA functor wrapper in case of conflicting family instance declarations( data-category<The constant functor with the same domain and codomain as f./ data-category(Functors are arrows in the category Cat.2 data-category Functors map objects and arrows.3 data-category/The domain, or source category, of the functor.4 data-category1The codomain, or target category, of the functor.5 data-category:% maps objects.6 data-category% maps arrows.: data-category#The contravariant functor Hom(--,X); 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.A data-categoryCatB is the category with categories as objects and funtors as arrows.B data-categoryThe constant functor.C data-categoryThe dual of a functorD data-categoryThe  Op (Op x) = x functor.E data-categoryThe  x = Op (Op x) functor.F data-categoryC is a bifunctor that projects out the first component of a product.G data-categoryD is a bifunctor that projects out the second component of a product.H data-category f1 :***: f2 is the product of the functors f1 and f2.I data-category& is the diagonal functor for products.J data-categoryrThe Hom functor, Hom(--,--), a bifunctor contravariant in its first argument and covariant in its second argument.1 !"#$%&'()*+,-./0123546789:;<=>1/0235461-.+,)*(&'$%"# !><=;:98759 69  BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portableNone&'=>?HRSUVXgbLR 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.S 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.V data-category)Composition of endofunctors is a functor.W data-categoryThe category of endofunctors.Z data-categoryA component for an object z is an arrow from F z to G z.[ data-categoryINatural transformations are built up of components, one for each object z in the domain category of f and g.] 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).a data-category2Horizontal composition of natural transformations.b data-category1The identity natural transformation of a functor.o data-categorykFunctor category D^C. Objects of D^C are functors from C to D. Arrows of D^C are natural transformations.p data-category%Composition of functors is a functor.q 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.r data-categoryN is a bifunctor, Apply :% (f, a) applies f to a, i.e. f :% a.s data-categoryL converts an object a to the functor  a.#LMNOPQRSTUVWXYZ[\]^_`abcdefghijklmn#]Z`abcd[\WUTefghijklmnXYVS_R^PQNOLM`9  BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portableNone &'>HSUVXj| 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-categoryBThe category with categories as objects and adjunctions as arrows.tuvwxyz{|}~vwxyz{|}~tu BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portableNoneHSUVXry 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. data-categoryTFor an adjunction F -| G, each pair (FY, unit_Y) is an initial morphism from Y to G. data-categoryVFor 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-portableSafe&'uG data-category! is the category with one object. BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portableNone &'>HMUVi  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-portableNone &'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&'-.=>?@AHSUVX9 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-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-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-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-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 2 data-category8A comonad is a comonoid in the category of endofunctors.3 data-category4A monad is a monoid in the category of endofunctors.6 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-category{A monoidal category is a category with some kind of tensor product. A tensor product is a bifunctor, with a unit object.R data-category3Every adjunction gives rise to an associated monad.S data-category?Every adjunction gives rise to an associated monad transformer.T data-category5Every adjunction gives rise to an associated comonad.U data-categoryAEvery adjunction gives rise to an associated comonad transformer.V data-categorycFunctor composition makes the category of endofunctors monoidal, with the identity functor as unit.W data-category~If a category has all coproducts, then the coproduct functor makes it a monoidal category, with the initial object as unit.X data-category{If 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.$23456798:;=<>?@HGFEDCBAIJKLMNOPQRSTU$@HGFEDCBA>?:;=<IJ6798KL453MNO2PQRSTU  BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portableNone &'HSUVX7l data-category The maps 0 -> 1 and 2 -> 1) form a monoid, which is universal, c.f. \.m data-category The ordinal 10 is the terminal object of the simplex category.n data-category The ordinal 0/ is the initial object of the simplex category.o data-category^The (augmented) simplex category is the category of finite ordinals and order preserving maps.p data-categoryTurn  Simplex x y arrows into Fin x -> Fin y functions.q data-categoryFOrdinal addition makes the simplex category a monoidal category, with 0 as unit.r data-categoryEOrdinal addition is a bifuntor, it concattenates the maps as it were.s data-category%Replicate a monoid a number of times.\]^_`abcdefghijklefghjik`abcd^_l\]  BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portableNone&'=>?HSUVXO| data-categoryThe category of Kleisli arrows.tuvwxyz{xyzvwtu{ BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portableNone&'=?@AHSUVX+ data-categoryAn instance of HasLeftKan p kC 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-categoryH 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 kD 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-categoryI 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-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. BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portableNone &'HSUVX* 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-Z data-category!The comma category T \downarrow S   BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portableNone HSUVXg3 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&'-.=?HSUVXg@7 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=?HMUVgM  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-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-portableNone&'HUVO$&%'*)+('*)+($&% BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portableNone&'=?@AHUVX_f11 data-categoryXThe target functor sends arrows (as functors from the Boolean category) to their target.2 data-categoryXThe source functor sends arrows (as functors from the Boolean category) to their source.A data-category Terminator( is right adjoint to the source functor.B data-category Initializer' is left adjoint to the target functor.C data-category[The colimit of a functor from the Boolean category is the target of the arrow it points to.D data-categoryYThe limit of a functor from the Boolean category is the source of the arrow it points to.E data-category8Implication makes the Boolean category cartesian closed.F data-category<Disjunction is the binary coproduct in the Boolean category.G data-category:Conjunction is the binary product in the Boolean category.H data-category4True is the terminal object in the Boolean category.I data-category4False is the initial object in the Boolean category.J data-categoryBooleanQ is the category with true and false as objects, and an arrow from false to true.K data-categoryPAny functor from the Boolean category points to an arrow in its target category.L data-category Terminator k> is the functor that sends an object to its terminating arrow.M data-category Initializer k? is the functor that sends an object to its initializing arrow.-./0123457869:;<=>?@AB:95786;<=>?@3421/0A-.B BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portableNone&',>HSUVXg}r data-categoryThe enriched functor k(-, x)t data-categoryThe enriched functor k(x, -)v data-category!Enriched natural transformations. 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-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 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-categoryThe enriched functor category [a, b] data-categoryYoneda embeddingYNORQPSTUVWX[YZ\]^a_`bcdefghijklponmqrstuvwxyz{|}~Y~|}z{xyvwtursqlponmijkghfdecb^a_`]\X[YZVWUTSORQPN !""#$%&'())*+,--..//001122334456677889:;<=>?@$%&AB*+,CDEFGHIJKLMNOPPQQRRSTUVWXYYZ[[\ST]^_`abcdefghijklmnopqqrrstuvwxyz{|}~                                                                      ! ! " # $ % &  ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A A B B C C D E F G H I J K H L M N O P Q R S T U U V V W W X Y Z [ \]]^^__``aabcdefgghijklmnopqrstuvwxyz{|}~HKBBCCHKIJKHQRSKHRRKHnHKII      --44667788 !"##$$%&&''(()*+,-./0123456789:;<=>?@ABCDEFGHIJK)data-category-0.10-86UpYbY19qo6ZB0w89OAfu Data.CategoryData.Category.ProductData.Category.Functor#Data.Category.NaturalTransformationData.Category.Adjunction"Data.Category.RepresentableFunctorData.Category.UnitData.Category.CoproductData.Category.VoidData.Category.LimitData.Category.MonoidalData.Category.SimplexData.Category.KleisliData.Category.KanExtensionData.Category.DialgData.Category.CubeData.Category.CommaData.Category.YonedaData.Category.CartesianClosedData.Category.FixData.Category.NNOData.Category.BooleanData.Category.EnrichedKindOpunOpCategorysrctgt.Obj$fCategoryTYPE-> $fCategorykOp:**:$fCategoryTYPE:**:CostarStarHomF:-*::*-:HomTuple2SwapTuple1DiagProd:***:Proj2Proj1AnyOpOpInvOpOpOppositeConstFConst:.:IdCatCatA FunctorOfFunctorDomCod:%%Hom_XHomX_ $fFunctorId $fFunctor:.:$fCategory->Cat$fFunctorConst$fFunctorOpposite $fFunctorOpOp$fFunctorOpOpInv$fFunctorProj1$fFunctorProj2$fFunctor:***:$fFunctorDiagProd $fFunctorHom $fFunctorAnyTupleApplyWrap Postcompose Precompose Profunctors PresheavesEndoFunctorComposeEndoFunctorCompose ComponentNat:~>!onatIdsrcFtgtF compAssoc compAssocInv idPrecomp idPrecompInv idPostcomp idPostcompInvconstPrecompInconstPrecompOutconstPostcompInconstPostcompOut$fCategoryTYPENat$fFunctorFunctorCompose $fFunctorWrap$fFunctorApply$fFunctorTupleAdjArrow Adjunction leftAdjoint rightAdjoint leftAdjunctN rightAdjunctN mkAdjunctionmkAdjunctionUnitsmkAdjunctionInitmkAdjunctionTerm leftAdjunct rightAdjunctadjunctionUnitadjunctionCounitidAdj composeAdj precomposeAdjpostcomposeAdjcontAdj$fCategory->AdjArrowTerminalUniversalInitialUniversal RepresentablerepresentedFunctorrepresentingObject representuniversalElement unrepresentcovariantHomReprcontravariantHomReprinitialUniversalterminalUniversaladjunctionInitialPropadjunctionTerminalPropinitialPropAdjunctionterminalPropAdjunctionUnit$fCategoryTYPEUnit NatAsFunctor:>>:DCCographI1AI2AI12Cotuple2Cotuple1 CodiagCoprod:+++:Inj2Inj1:++:I1I2$fCategoryTYPE:++: $fFunctorInj1 $fFunctorInj2$fFunctor:+++:$fFunctorCodiagCoprod$fFunctorCotuple1$fFunctorCotuple2$fCategoryTYPECograph$fFunctorNatAsFunctor$fCategory:>>:MagicVoidmagicvoidNat$fCategoryTYPEVoid$fFunctorMagic:+:CoproductFunctorHasBinaryCoproductsBinaryCoproductinj1inj2|||+++:*:ProductFunctorHasBinaryProducts 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$fHasTerminalObject->Cat$fHasTerminalObjectTYPE->$fHasLimitsVoidk$fHasLimits:>>:k$fHasInitialObjectkOp$fHasTerminalObjectkOp$fHasInitialObjectTYPE:>>:$fHasInitialObjectTYPEUnit$fHasInitialObjectTYPE:**:$fHasInitialObjectTYPENat$fHasInitialObject->Cat$fHasColimitsVoidk$fHasInitialObjectTYPE->$fHasBinaryProductsTYPE:>>:$fHasBinaryProductsTYPE:**:$fHasBinaryProductsTYPEUnit$fHasBinaryProducts->Cat$fHasBinaryProductsTYPE->$fHasLimits:++:k$fFunctorProductFunctor$fHasBinaryProductsTYPENat $fFunctor:*:$fHasBinaryCoproductskOp$fHasBinaryProductskOp$fHasBinaryCoproductsTYPE:>>:$fHasBinaryCoproductsTYPE:**:$fHasBinaryCoproductsTYPEUnit$fHasBinaryCoproducts->Cat$fHasColimits:++:k$fFunctorCoproductFunctor$fHasBinaryCoproductsTYPENat $fFunctor:+:$fHasLimits->->$fHasColimits->->ComonadMonadMonoidAsCategory MonoidValueComonoidObjectcounit comultiply MonoidObjectunitmultiplySymmetricTensorProductswap TensorProduct unitObject leftUnitor leftUnitorInv rightUnitorrightUnitorInv associator associatorInv trivialMonoidcoproductMonoidtrivialComonoidproductComonoidmkMonad monadFunctoridMonad mkComonad idComonadadjunctionMonadadjunctionMonadTadjunctionComonadadjunctionComonadT$fTensorProductFunctorCompose$fTensorProductCoproductFunctor$fTensorProductProductFunctor($fSymmetricTensorProductCoproductFunctor&$fSymmetricTensorProductProductFunctor$fCategoryTYPEMonoidAsCategory ReplicateAddForgetFinFzFsSimplexZYXSsucuniversalMonoid$fHasTerminalObjectTYPESimplex$fHasInitialObjectTYPESimplex$fCategoryTYPESimplex$fFunctorForget$fTensorProductAdd $fFunctorAdd$fFunctorReplicate KleisliForget KleisliFreeKleisli kleisliId kleisliAdj$fCategoryTYPEKleisli$fFunctorKleisliFree$fFunctorKleisliForgetLanHaskFLanHaskRanHaskFRanHask LanFunctorLan HasLeftKanLanFamlan lanFactorizer RanFunctorRan HasRightKanRanFamran ranFactorizerranFranF'ranAdjlanFlanF'lanAdj$fHasRightKan:.:k$fHasRightKanIdk$fHasRightKanConstk$fFunctorRanFunctor$fHasLeftKan:.:k$fHasLeftKanIdk$fHasLeftKanConstk$fFunctorLanFunctor$fHasRightKanAny->$fFunctorRanHaskF$fHasLeftKanAny->$fFunctorLanHaskF ForgetAlgFreeAlgNatNumAnaCataTerminalFAlgebraInitialFAlgebra CoalgebraCoalgAlgebraAlgDialgDialgA DialgebradialgId dialgebraprimRecfreeAlgeilenbergMooreAdj$fCategoryTYPEDialg$fHasInitialObjectTYPEDialg$fFunctorFreeAlg$fFunctorForgetAlgACubeNilConsSign0SMS0SPCubeSignMP$fHasTerminalObjectTYPECube$fCategoryTYPECubeArrows ObjectsOver ObjectsUnder ObjectsFOver ObjectsFUnder:/\:CommaACommaOcommaIdinitialUniversalCommaterminalUniversalComma$fCategoryTYPE:/\:M1YonedaYonedaEmbedding fromYonedatoYonedahaskUnit haskIsTotal$fFunctorYoneda $fFunctorM1ContextStatePShExponential ExpFunctorCartesianClosed Exponentialapplytuple^^^PshExponentialflipcurryAdjcurryuncurrystateMonadReturnstateMonadJoincontextComonadExtractcontextComonadDuplicate$fCartesianClosed->Cat$fCartesianClosedTYPEUnit$fCartesianClosedTYPE->$fFunctorExpFunctor$fCartesianClosedTYPENatOmega WrapTensorUnwrapFixz2s$fCartesianClosedTYPEFix$fHasBinaryCoproductsTYPEFix$fHasBinaryProductsTYPEFix$fHasTerminalObjectTYPEFix$fHasInitialObjectTYPEFix$fFunctorUnwrap$fTensorProduct:.: $fCategoryFixHasNaturalNumberObjectNaturalNumberObjectzerosucc$fHasNaturalNumberObject-> Initializer Terminator TgtFunctor SrcFunctorArrowBooleanFlsF2TTrutrueProductMonoidfalseCoproductComonoidtrueProductComonoidfalseCoproductMonoidtrueCoproductMonoidfalseProductComonoidterminatorLimitAdjinitializerColimitAdj$fHasColimitsBooleank$fHasLimitsBooleank$fCartesianClosedTYPEBoolean $fHasBinaryCoproductsTYPEBoolean$fHasBinaryProductsTYPEBoolean$fHasTerminalObjectTYPEBoolean$fHasInitialObjectTYPEBoolean$fCategoryTYPEBoolean$fFunctorArrow$fFunctorTerminator$fFunctorInitializerPoset3 PosetTestOneTwoThree colimitObj colimitInvColimWeigtedColimitlimitObjlimitInvLim WeigtedLimit EndFunctor:->>:FunCatFArrHaskEnd getHaskEndHasEndsEndend endCounit endFactorizer VProfunctorEHom_XEHomX_ENatEHom UnderlyingF:<*>: EFunctorOfEFunctorEDomECod:%%%%mapInHaskSelfgetSelf:<>:EOp UnderlyingArr ECategoryV$homidcompcompArrtoSelffromSelf->>yoneda yonedaInv$fCategoryTYPEUnderlying$fECategoryEOp$fECategory:<>:$fECategorySelf$fECategoryInHask $fEFunctorId $fEFunctor:.:$fEFunctorConst$fEFunctorOpposite$fEFunctor:<*>:$fEFunctorDiagProd$fFunctorUnderlyingF$fEFunctorEHom$fEFunctorEHomX_$fEFunctorEHom_X $fHasEnds->$fECategoryFunCat$fEFunctorEndFunctor$fHasLimitsSelf $fEFunctorY$fECategoryPosetTest