Safe Haskell	None
Language	GHC2024

Proarrow.Colimit.Coequalizer

Contents

Orphan instances

Synopsis

class CategoryOf k => HasCoequalizers k where
- coequalize :: forall (a :: k) (b :: k) r. (a ~> b) -> (a ~> b) -> (forall (c :: k). (b ~> c) -> r) -> r
- factorCoequalizer :: forall (a :: k) (b :: k) (c :: k). (a ~> b) -> (a ~> b) -> (b ~> c) -> (Hom k :.: Hom k) b c
thinCoequalize :: forall {k} (a :: k) (b :: k) r. Thin k => (a ~> b) -> (a ~> b) -> (forall (c :: k). (b ~> c) -> r) -> r
thinFactorCoequalizer :: forall {k} (a :: k) (b :: k) (c :: k). Thin k => (a ~> b) -> (a ~> b) -> (b ~> c) -> (Hom k :.: Hom k) b c
pushoutDefault :: forall {k} (o :: k) (a :: k) (b :: k) r. (HasCoequalizers k, HasCoproducts k) => (o ~> a) -> (o ~> b) -> (forall (p :: k). (a ~> p) -> (b ~> p) -> r) -> r
cokernel :: forall k (a :: k) (b :: k) r. (HasCoequalizers k, HasZeroObject k) => (a ~> b) -> (forall (c :: k). (b ~> c) -> r) -> r

Documentation

class CategoryOf k => HasCoequalizers k where Source Github #

Coequalizers are an inherently dependently typed concept: The type of the apex object depends on the values of the given arrows. But at runtime we can still calculate the arrow and the type, which we hide behind an existential.

Minimal complete definition

factorCoequalizer

Methods

coequalize :: forall (a :: k) (b :: k) r. (a ~> b) -> (a ~> b) -> (forall (c :: k). (b ~> c) -> r) -> r Source Github #

default coequalize :: forall (a :: k) (b :: k) r. HasTerminalObject k => (a ~> b) -> (a ~> b) -> (forall (c :: k). (b ~> c) -> r) -> r Source Github #

factorCoequalizer :: forall (a :: k) (b :: k) (c :: k). (a ~> b) -> (a ~> b) -> (b ~> c) -> (Hom k :.: Hom k) b c Source Github #

Instances

Instances details

HasCoequalizers BOOL Source Github #
Instance details Defined in Proarrow.Category.Instance.Bool Methods coequalize :: forall (a :: BOOL) (b :: BOOL) r. (a ~> b) -> (a ~> b) -> (forall (c :: BOOL). (b ~> c) -> r) -> r Source Github # factorCoequalizer :: forall (a :: BOOL) (b :: BOOL) (c :: BOOL). (a ~> b) -> (a ~> b) -> (b ~> c) -> (Hom BOOL :.: Hom BOOL) b c Source Github #
HasCoequalizers FINSET Source Github #
Instance details Defined in Proarrow.Category.Instance.FinSet Methods coequalize :: forall (a :: FINSET) (b :: FINSET) r. (a ~> b) -> (a ~> b) -> (forall (c :: FINSET). (b ~> c) -> r) -> r Source Github # factorCoequalizer :: forall (a :: FINSET) (b :: FINSET) (c :: FINSET). (a ~> b) -> (a ~> b) -> (b ~> c) -> (Hom FINSET :.: Hom FINSET) b c Source Github #
HasCoequalizers () Source Github #
Instance details Defined in Proarrow.Colimit.Coequalizer Methods coequalize :: forall (a :: ()) (b :: ()) r. (a ~> b) -> (a ~> b) -> (forall (c :: ()). (b ~> c) -> r) -> r Source Github # factorCoequalizer :: forall (a :: ()) (b :: ()) (c :: ()). (a ~> b) -> (a ~> b) -> (b ~> c) -> (Hom () :.: Hom ()) b c Source Github #
HasEqualizers k => HasCoequalizers (OPPOSITE k) Source Github #
Instance details Defined in Proarrow.Colimit.Coequalizer Methods coequalize :: forall (a :: OPPOSITE k) (b :: OPPOSITE k) r. (a ~> b) -> (a ~> b) -> (forall (c :: OPPOSITE k). (b ~> c) -> r) -> r Source Github # factorCoequalizer :: forall (a :: OPPOSITE k) (b :: OPPOSITE k) (c :: OPPOSITE k). (a ~> b) -> (a ~> b) -> (b ~> c) -> (Hom (OPPOSITE k) :.: Hom (OPPOSITE k)) b c Source Github #
(HasCoequalizers k1, HasCoequalizers k2) => HasCoequalizers (k1, k2) Source Github #
Instance details Defined in Proarrow.Colimit.Coequalizer Methods coequalize :: forall (a :: (k1, k2)) (b :: (k1, k2)) r. (a ~> b) -> (a ~> b) -> (forall (c :: (k1, k2)). (b ~> c) -> r) -> r Source Github # factorCoequalizer :: forall (a :: (k1, k2)) (b :: (k1, k2)) (c :: (k1, k2)). (a ~> b) -> (a ~> b) -> (b ~> c) -> (Hom (k1, k2) :.: Hom (k1, k2)) b c Source Github #

thinCoequalize :: forall {k} (a :: k) (b :: k) r. Thin k => (a ~> b) -> (a ~> b) -> (forall (c :: k). (b ~> c) -> r) -> r Source Github #

In a thin category, arrows don't carry information, so coequalizers are just coproducts.

thinFactorCoequalizer :: forall {k} (a :: k) (b :: k) (c :: k). Thin k => (a ~> b) -> (a ~> b) -> (b ~> c) -> (Hom k :.: Hom k) b c Source Github #

pushoutDefault :: forall {k} (o :: k) (a :: k) (b :: k) r. (HasCoequalizers k, HasCoproducts k) => (o ~> a) -> (o ~> b) -> (forall (p :: k). (a ~> p) -> (b ~> p) -> r) -> r Source Github #

cokernel :: forall k (a :: k) (b :: k) r. (HasCoequalizers k, HasZeroObject k) => (a ~> b) -> (forall (c :: k). (b ~> c) -> r) -> r Source Github #

Orphan instances

HasCoequalizers k => HasEqualizers (OPPOSITE k) Source Github #
Instance details Methods equalize :: forall (a :: OPPOSITE k) (b :: OPPOSITE k) r. (a ~> b) -> (a ~> b) -> (forall (e :: OPPOSITE k). (e ~> a) -> r) -> r Source Github # factorEqualizer :: forall (a :: OPPOSITE k) (b :: OPPOSITE k) (c :: OPPOSITE k). (a ~> b) -> (a ~> b) -> (c ~> a) -> (Hom (OPPOSITE k) :.: Hom (OPPOSITE k)) c a Source Github #