module Data.Category where
import Type.Set
import Type.Dummies
import Type.Function
import Type.Logic
import Data.Type.Equality
import Control.Monad
import Control.Category
import Prelude hiding(id,(.))
data Cat ob hom =
Cat {
homIsFun :: ((ob :×: ob) :~>: Univ) hom
, getid :: forall a. a :∈: ob -> ExId hom a
, getc :: forall a b c.
a :∈: ob ->
b :∈: ob ->
c :∈: ob ->
ExC hom a b c
}
data ExId hom a where
ExId :: ((a,a),aa) :∈: hom -> aa -> ExId hom a
data ExC hom a b c where
ExC ::
((b,c), bc) :∈: hom ->
((a,b), ab) :∈: hom ->
((a,c), ac) :∈: hom ->
(bc -> ab -> ac) ->
ExC hom a b c
hask :: Cat Univ HaskFun
hask = Cat (extendCod haskFunIsFun auto)
(\_ -> ExId HaskFun id)
(\_ _ _ -> ExC HaskFun HaskFun HaskFun (.))
kleisli :: Monad m => Cat Univ (KleisliHom m)
kleisli = Cat (extendCod kleisliHomIsFun auto)
(\_ -> ExId KleisliHom return)
(\_ _ _ -> ExC KleisliHom KleisliHom KleisliHom (<=<))
fromControlCategory :: (Category hom) => Cat Univ (BiGraph hom)
fromControlCategory = Cat biGraphIsFun
(\_ -> ExId BiGraph id)
(\_ _ _ -> ExC BiGraph BiGraph BiGraph (.))
makeCat :: ((ob :×: ob) :~>: Univ) hom ->
(forall a aa. ((a,a),aa) :∈: hom -> aa) ->
(forall a b c bc ab ac.
((b,c), bc) :∈: hom ->
((a,b), ab) :∈: hom ->
((a,c), ac) :∈: hom ->
(bc -> ab -> ac)) ->
Cat ob hom
makeCat hom k1 k2 =
Cat hom
(\a -> case total hom (a :×: a) of
ExSnd aa -> ExId aa (k1 aa))
(\a b c -> case ( total hom (b :×: c)
, total hom (a :×: b)
, total hom (a :×: c) ) of
( ExSnd bc
,ExSnd ab
,ExSnd ac ) ->
ExC bc ab ac (k2 bc ab ac) )
idauto :: (Fact (a :∈: ob)) => Cat ob hom -> ExId hom a
idauto cat = getid cat auto
cauto :: (Fact (a :∈: ob), Fact (b :∈: ob), Fact (c :∈: ob)) =>
Cat ob hom -> ExC hom a b c
cauto cat = getc cat auto auto auto
data GFunctor ob1 hom1 ob2 hom2 f =
GFunctor {
omapIsFun :: (ob1 :~>: ob2) f
, getfmap :: forall a b.
a :∈: ob1 ->
b :∈: ob1 ->
ExFmap hom1 hom2 f a b
}
data ExFmap hom1 hom2 f a b where
ExFmap ::
(a,fa) :∈: f ->
(b,fb) :∈: f ->
((a,b),ab) :∈: hom1 ->
((fa,fb),fafb) :∈: hom2 ->
(ab -> fafb) ->
ExFmap hom1 hom2 f a b
fromFunctor :: (Functor f) => GFunctor Univ HaskFun Univ HaskFun (Graph f)
fromFunctor = GFunctor graphIsFun (\_ _ -> ExFmap Graph Graph HaskFun HaskFun fmap)