------------------------------------------------------------------------------------------- -- | -- Module : Control.Bifunctor.Monoidal -- Copyright : 2008 Edward Kmett -- License : BSD -- -- Maintainer : Edward Kmett <ekmett@gmail.com> -- Stability : experimental -- Portability : non-portable (class-associated types) -- -- A 'Monoidal' category is a category with an associated biendofunctor that has an identity, -- which satisfies Mac Lane''s pentagonal and triangular coherence conditions -- Technically we usually say that category is 'monoidal', but since -- most interesting categories in our world have multiple candidate bifunctors that you can -- use to enrich their structure, we choose here to think of the bifunctor as being -- monoidal. This lets us reuse the same Bifunctor over different categories without -- painful type annotations. ------------------------------------------------------------------------------------------- module Control.Bifunctor.Monoidal where import Control.Bifunctor import Control.Bifunctor.Associative import Control.Bifunctor.Braided -- | Denotes that we have some reasonable notion of 'Identity' for a particular 'Bifunctor' in this 'Category'. This -- notion is currently used by both 'Monoidal' and 'Comonoidal' class Bifunctor p => HasIdentity p i | p -> i {- | A monoidal category. 'idl' and 'idr' are traditionally denoted lambda and rho the triangle identity holds: > bimap idr id = bimap id idl . associate > bimap id idl = bimap idr id . associate -} class (Associative p, HasIdentity p i) => Monoidal p i | p -> i where idl :: p i a -> a idr :: p a i -> a {- | A comonoidal category satisfies the dual form of the triangle identities > bimap idr id = coassociate . bimap id idl > bimap id idl = coassociate . bimap idr id This type class is also (ab)used for the inverse operations needed for a strict (co)monoidal category. A strict (co)monoidal category is one that is both 'Monoidal' and 'Comonoidal' and satisfies the following laws: > idr . coidr = id > idl . coidl = id > coidl . idl = id > coidr . idr = id -} class (Coassociative p, HasIdentity p i) => Comonoidal p i | p -> i where coidl :: a -> p i a coidr :: a -> p a i {-# RULES -- "bimap id idl/associate" bimap id idl . associate = bimap idr id -- "bimap idr id/associate" bimap idr id . associate = bimap id idl -- "coassociate/bimap id idl" coassociate . bimap id idl = bimap idr id -- "coassociate/bimap idr id" coassociate . bimap idr id = bimap id idl "idr/coidr" idr . coidr = id "idl/coidl" idl . coidl = id "coidl/idl" coidl . idl = id "coidr/idr" coidr . idr = id "idr/braid" idr . braid = idl "idl/braid" idl . braid = idr "braid/coidr" braid . coidr = coidl "braid/coidl" braid . coidl = coidr #-}