h$tf3      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                                               BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portable Safe-Inferred '(.6 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-categoryThe 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-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'(-.>?& data-category data-category The composition of two functors.? data-categoryCat 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-category is a bifunctor that projects out the first component of a product.E data-category 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-categoryThe Hom functor, Hom(--,--), a bifunctor contravariant in its first argument and covariant in its second argument./ !"#$%&'()*+,-./0132456789:;?WO 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-categoryNatural 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 n. 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-categoryFunctor 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-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. qrstxwvuyz{|} stxwvuyz{r|q} BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portable Safe-Inferred '(? 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-category! is the category with one object. BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portableNone '(?$  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-portableNone'(./>?<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-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-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-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-categoryLimits in a category k by means of a diagram of type j, which is a functor from j to k. 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-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-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-portableNone &'(>Cv  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-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-portableNone '(Gp 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.  BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portableNone'(>?Hh data-categoryThe category of Kleisli arrows. BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portableNone&'(>?L  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-portableNone '(NN 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-portableNone'(>?OZ data-category!The comma category T \downarrow S   BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portable Safe-Inferred Q! 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'(./>T 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-portableNone 2>Y  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-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-categoryFix f inherits its (co)limits from  f (Fix f). data-categoryFix f inherits its (co)limits 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'(Y BSD-style (see the file LICENSE)sjoerd@w3future.com experimental non-portableNone'(>]  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)  data-categoryAn enriched category data-category;The tensor product of 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 embedding !!"#$%&'(()*+,,--..//0011223445566789:;<=>#$%?@)*+ABCDEFGHIJKLMMNNOOPQRSTUVVWXXYPQZ[\]^_`abcdefghijklmnoppqrstuvwxyzz{{|}~                                                                                                                                                                                              OOk,,22445566*data-category-0.8.1-1Lp8BgNuxeV94Jb2VhNDoT 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.EnrichedKindOpunOpCategorysrctgt.Obj$fCategoryTYPE-> $fCategorykOp:**:$fCategoryTYPE:**:CostarStarHomF:-*::*-:HomTuple2SwapTuple1DiagProd:***:Proj2Proj1OpOpInvOpOpOppositeConstFConst:.:IdCatCatA FunctorOfFunctorDomCod:%%Hom_XHomX_ $fFunctorId $fFunctor:.:$fCategory->Cat$fFunctorConst$fFunctorOpposite $fFunctorOpOp$fFunctorOpOpInv$fFunctorProj1$fFunctorProj2$fFunctor:***:$fFunctorDiagProd $fFunctorHomTupleApplyWrap Postcompose Precompose Profunctors PresheavesEndoFunctorComposeEndoFunctorCompose ComponentNat:~>!onatIdsrcFtgtF compAssoc compAssocInv idPrecomp idPrecompInv idPostcomp idPostcompInvconstPrecompInconstPrecompOutconstPostcompInconstPostcompOut$fCategoryTYPENat$fFunctorFunctorCompose $fFunctorWrap$fFunctorApply$fFunctorTupleTerminalUniversalInitialUniversal RepresentablerepresentedFunctorrepresentingObject representuniversalElement unrepresentcovariantHomReprcontravariantHomReprinitialUniversalterminalUniversalAdjArrow Adjunction leftAdjoint rightAdjoint leftAdjunctN rightAdjunctN mkAdjunctionmkAdjunctionUnitsmkAdjunctionUnitmkAdjunctionCounit leftAdjunct rightAdjunctadjunctionUnitadjunctionCounitadjunctionInitialPropadjunctionTerminalPropinitialPropAdjunctionterminalPropAdjunctionidAdj composeAdj precomposeAdjpostcomposeAdjcontAdj$fCategory->AdjArrowUnit$fCategoryTYPEUnit NatAsFunctor:>>:DCCographI1AI2AI12Cotuple2Cotuple1 CodiagCoprod:+++:Inj2Inj1:++:I1I2$fCategoryTYPE:++: $fFunctorInj1 $fFunctorInj2$fFunctor:+++:$fFunctorCodiagCoprod$fFunctorCotuple1$fFunctorCotuple2$fCategoryTYPECograph$fFunctorNatAsFunctor$fCategoryTYPE:>>:MagicVoidmagicvoidNat$fCategoryTYPEVoid$fFunctorMagic:+:CoproductFunctorHasBinaryCoproductsBinaryCoproductinj1inj2|||+++:*:ProductFunctorHasBinaryProducts BinaryProductproj1proj2&&&***ZeroHasInitialObject InitialObject initialObject initializeHasTerminalObjectTerminalObjectterminalObject terminateColimitFunctor HasColimitscolimitcolimitFactorizerColimit ColimitFam LimitFunctor HasLimitslimitlimitFactorizerLimitLimitFamCoconeConeDiagFDiag 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$fFunctorKleisliForget 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$fFunctorUnwrap$fTensorProduct:.:$fHasTerminalObjectTYPEFix$fHasInitialObjectTYPEFix$fCategoryTYPEFixHasNaturalNumberObjectNaturalNumberObjectzerosucc$fHasNaturalNumberObject->ArrowBooleanFlsF2TTrutrueProductMonoidfalseCoproductComonoidtrueProductComonoidfalseCoproductMonoidtrueCoproductMonoidfalseProductComonoid$fHasColimitsBooleank$fHasLimitsBooleank$fCartesianClosedTYPEBoolean $fHasBinaryCoproductsTYPEBoolean$fHasBinaryProductsTYPEBoolean$fHasTerminalObjectTYPEBoolean$fHasInitialObjectTYPEBoolean$fCategoryTYPEBoolean$fFunctorArrowPoset3 PosetTestOneTwoThree colimitObj colimitInvColimWeigtedColimitlimitObjlimitInvLim WeigtedLimit EndFunctor:->>:FunCatFArrHaskEnd getHaskEndHasEndsend endCounit endFactorizerEnd VProfunctorEHom_XEHomX_ENatEHom UnderlyingF:<*>: EFunctorOfEFunctorEDomECod:%%%%mapInHaskSelfgetSelf:<>:EOp UnderlyingArrElem ECategoryV$homidcompelemcompArrtoSelffromSelf->>yoneda yonedaInv$fCategoryTYPEUnderlying$fECategoryEOp$fECategory:<>:$fECategorySelf$fECategoryInHask $fEFunctorId $fEFunctor:.:$fEFunctorConst$fEFunctorOpposite$fEFunctor:<*>:$fEFunctorDiagProd$fFunctorUnderlyingF$fEFunctorEHom$fEFunctorEHomX_$fEFunctorEHom_X $fHasEnds->$fECategoryFunCat$fEFunctorEndFunctor$fHasLimitsSelf $fEFunctorY$fECategoryPosetTest