License	BSD-style (see the file LICENSE)
Maintainer	sjoerd@w3future.com
Stability	experimental
Portability	non-portable
Safe Haskell	Safe-Inferred
Language	Haskell2010

Data.Category.Limit

Contents

Preliminairies
- Diagonal Functor
- Cones
Limits
Colimits
Limits of type Void
Limits of type Pair

Description

Synopsis

data Diag :: (Type -> Type -> Type) -> (Type -> Type -> Type) -> Type where
- Diag :: Diag j k
type DiagF f = Diag (Dom f) (Cod f)
type Cone j k f n = Nat j k (Const j k n) f
type Cocone j k f n = Nat j k f (Const j k n)
coneVertex :: Cone j k f n -> Obj k n
coconeVertex :: Cocone j k f n -> Obj k n
class (Category j, Category k) => HasLimits j k where
- type LimitFam (j :: Type -> Type -> Type) (k :: Type -> Type -> Type) (f :: Type) :: Type
- limit :: Obj (Nat j k) f -> Cone j k f (LimitFam j k f)
- limitFactorizer :: Cone j k f n -> k n (LimitFam j k f)
type Limit f = LimitFam (Dom f) (Cod f) f
data LimitFunctor (j :: Type -> Type -> Type) (k :: Type -> Type -> Type) = LimitFunctor
limitAdj :: forall j k. HasLimits j k => Adjunction (Nat j k) k (Diag j k) (LimitFunctor j k)
adjLimit :: Category k => Adjunction (Nat j k) k (Diag j k) r -> Obj (Nat j k) f -> Cone j k f (r :% f)
adjLimitFactorizer :: Category k => Adjunction (Nat j k) k (Diag j k) r -> Cone j k f n -> k n (r :% f)
rightAdjointPreservesLimits :: (HasLimits j c, HasLimits j d) => Adjunction c d f g -> Obj (Nat j c) t -> d (Limit (g :.: t)) (g :% Limit t)
rightAdjointPreservesLimitsInv :: (HasLimits j c, HasLimits j d) => Obj (Nat c d) g -> Obj (Nat j c) t -> d (g :% LimitFam j c t) (LimitFam j d (g :.: t))
class (Category j, Category k) => HasColimits j k where
- type ColimitFam (j :: Type -> Type -> Type) (k :: Type -> Type -> Type) (f :: Type) :: Type
- colimit :: Obj (Nat j k) f -> Cocone j k f (ColimitFam j k f)
- colimitFactorizer :: Cocone j k f n -> k (ColimitFam j k f) n
type Colimit f = ColimitFam (Dom f) (Cod f) f
data ColimitFunctor (j :: Type -> Type -> Type) (k :: Type -> Type -> Type) = ColimitFunctor
colimitAdj :: forall j k. HasColimits j k => Adjunction k (Nat j k) (ColimitFunctor j k) (Diag j k)
adjColimit :: Category k => Adjunction k (Nat j k) l (Diag j k) -> Obj (Nat j k) f -> Cocone j k f (l :% f)
adjColimitFactorizer :: Category k => Adjunction k (Nat j k) l (Diag j k) -> Cocone j k f n -> k (l :% f) n
leftAdjointPreservesColimits :: (HasColimits j c, HasColimits j d) => Adjunction c d f g -> Obj (Nat j d) t -> c (f :% Colimit t) (Colimit (f :.: t))
leftAdjointPreservesColimitsInv :: (HasColimits j c, HasColimits j d) => Obj (Nat d c) f -> Obj (Nat j d) t -> c (ColimitFam j c (f :.: t)) (f :% ColimitFam j d t)
class Category k => HasTerminalObject k where
- type TerminalObject k :: Kind k
- terminalObject :: Obj k (TerminalObject k)
- terminate :: Obj k a -> k a (TerminalObject k)
class Category k => HasInitialObject k where
- type InitialObject k :: Kind k
- initialObject :: Obj k (InitialObject k)
- initialize :: Obj k a -> k (InitialObject k) a
data Zero
class Category k => HasBinaryProducts k where
- type BinaryProduct k (x :: Kind k) (y :: Kind k) :: Kind k
- proj1 :: Obj k x -> Obj k y -> k (BinaryProduct k x y) x
- proj2 :: Obj k x -> Obj k y -> k (BinaryProduct k x y) y
- (&&&) :: k a x -> k a y -> k a (BinaryProduct k x y)
- (***) :: k a1 b1 -> k a2 b2 -> k (BinaryProduct k a1 a2) (BinaryProduct k b1 b2)
data ProductFunctor (k :: Type -> Type -> Type) = ProductFunctor
data p :*: q where
- (:*:) :: (Functor p, Functor q, Dom p ~ Dom q, Cod p ~ k, Cod q ~ k, HasBinaryProducts k) => p -> q -> p :*: q
prodAdj :: HasBinaryProducts k => Adjunction (k :**: k) k (DiagProd k) (ProductFunctor k)
newtype x & y = AddConj (forall r. Either (x %1 -> r) (y %1 -> r) %1 -> r)
class Category k => HasBinaryCoproducts k where
- type BinaryCoproduct k (x :: Kind k) (y :: Kind k) :: Kind k
- inj1 :: Obj k x -> Obj k y -> k x (BinaryCoproduct k x y)
- inj2 :: Obj k x -> Obj k y -> k y (BinaryCoproduct k x y)
- (|||) :: k x a -> k y a -> k (BinaryCoproduct k x y) a
- (+++) :: k a1 b1 -> k a2 b2 -> k (BinaryCoproduct k a1 a2) (BinaryCoproduct k b1 b2)
data CoproductFunctor (k :: Type -> Type -> Type) = CoproductFunctor
data p :+: q where
- (:+:) :: (Functor p, Functor q, Dom p ~ Dom q, Cod p ~ k, Cod q ~ k, HasBinaryCoproducts k) => p -> q -> p :+: q
coprodAdj :: HasBinaryCoproducts k => Adjunction k (k :**: k) (CoproductFunctor k) (DiagProd k)
data Either a b
- = Left a
- | Right b

Preliminairies

Diagonal Functor

data Diag :: (Type -> Type -> Type) -> (Type -> Type -> Type) -> Type where Source #

Constructors

Diag :: Diag j k

Instances

Instances details

(Category j, Category k) => Functor (Diag j k) Source #	The diagonal functor from (index-) category J to k.
Instance details Defined in Data.Category.Limit Associated Types type Dom (Diag j k) :: Type -> Type -> Type Source # type Cod (Diag j k) :: Type -> Type -> Type Source # type (Diag j k) :% a Source # Methods (%) :: Diag j k -> Dom (Diag j k) a b -> Cod (Diag j k) (Diag j k :% a) (Diag j k :% b) Source #
type Cod (Diag j k) Source #
Instance details Defined in Data.Category.Limit type Cod (Diag j k) = Nat j k
type Dom (Diag j k) Source #
Instance details Defined in Data.Category.Limit type Dom (Diag j k) = k
type (Diag j k) :% a Source #
Instance details Defined in Data.Category.Limit type (Diag j k) :% a = Const j k a

type DiagF f = Diag (Dom f) (Cod f) Source #

The diagonal functor with the same domain and codomain as f.

Cones

type Cone j k f n = Nat j k (Const j k n) f Source #

A cone from N to F is a natural transformation from the constant functor to N to F.

type Cocone j k f n = Nat j k f (Const j k n) Source #

A co-cone from F to N is a natural transformation from F to the constant functor to N.

coneVertex :: Cone j k f n -> Obj k n Source #

The vertex (or apex) of a cone.

coconeVertex :: Cocone j k f n -> Obj k n Source #

The vertex (or apex) of a co-cone.

Limits

class (Category j, Category k) => HasLimits j k where Source #

An instance of HasLimits j k says that k has all limits of type j.

Associated Types

type LimitFam (j :: Type -> Type -> Type) (k :: Type -> Type -> Type) (f :: Type) :: Type Source #

Limits in a category k by means of a diagram of type j, which is a functor from j to k.

Methods

limit :: Obj (Nat j k) f -> Cone j k f (LimitFam j k f) Source #

limit returns the limiting cone for a functor f.

limitFactorizer :: Cone j k f n -> k n (LimitFam j k f) Source #

limitFactorizer 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.

Instances

Instances details

Category k => HasLimits Boolean k Source #	The limit of a functor from the Boolean category is the source of the arrow it points to.
Instance details Defined in Data.Category.Boolean Associated Types type LimitFam Boolean k f Source # Methods limit :: Obj (Nat Boolean k) f -> Cone Boolean k f (LimitFam Boolean k f) Source # limitFactorizer :: Cone Boolean k f n -> k n (LimitFam Boolean k f) Source #
Category k => HasLimits Unit k Source #	The limit of a single object is that object.
Instance details Defined in Data.Category.Limit Associated Types type LimitFam Unit k f Source # Methods limit :: Obj (Nat Unit k) f -> Cone Unit k f (LimitFam Unit k f) Source # limitFactorizer :: Cone Unit k f n -> k n (LimitFam Unit k f) Source #
(Category k, HasTerminalObject k) => HasLimits Void k Source #	A terminal object is the limit of the functor from 0 to k.
Instance details Defined in Data.Category.Limit Associated Types type LimitFam Void k f Source # Methods limit :: Obj (Nat Void k) f -> Cone Void k f (LimitFam Void k f) Source # limitFactorizer :: Cone Void k f n -> k n (LimitFam Void k f) Source #
(HasLimits i k, HasLimits j k, HasBinaryProducts k) => HasLimits (i :++: j) k Source #	If `k` has binary products, we can take the limit of 2 joined diagrams.
Instance details Defined in Data.Category.Limit Associated Types type LimitFam (i :++: j) k f Source # Methods limit :: Obj (Nat (i :++: j) k) f -> Cone (i :++: j) k f (LimitFam (i :++: j) k f) Source # limitFactorizer :: Cone (i :++: j) k f n -> k n (LimitFam (i :++: j) k f) Source #
(HasInitialObject (i :>>: j), Category i, Category j, Category k) => HasLimits (i :>>: j) k Source #	The limit of any diagram with an initial object, has the limit at the initial object.
Instance details Defined in Data.Category.Limit Associated Types type LimitFam (i :>>: j) k f Source # Methods limit :: Obj (Nat (i :>>: j) k) f -> Cone (i :>>: j) k f (LimitFam (i :>>: j) k f) Source # limitFactorizer :: Cone (i :>>: j) k f n -> k n (LimitFam (i :>>: j) k f) Source #
HasLimits (->) (->) Source #
Instance details Defined in Data.Category.Limit Associated Types type LimitFam (->) (->) f Source # Methods limit :: Obj (Nat (->) (->)) f -> Cone (->) (->) f (LimitFam (->) (->) f) Source # limitFactorizer :: Cone (->) (->) f n -> n -> LimitFam (->) (->) f Source #

type Limit f = LimitFam (Dom f) (Cod f) f Source #

data LimitFunctor (j :: Type -> Type -> Type) (k :: Type -> Type -> Type) Source #

Constructors

LimitFunctor

Instances

Instances details

HasLimits j k => Functor (LimitFunctor j k) Source #	If every diagram of type `j` has a limit in `k` there exists a limit functor. It can be seen as a generalisation of `(***)`.
Instance details Defined in Data.Category.Limit Associated Types type Dom (LimitFunctor j k) :: Type -> Type -> Type Source # type Cod (LimitFunctor j k) :: Type -> Type -> Type Source # type (LimitFunctor j k) :% a Source # Methods (%) :: LimitFunctor j k -> Dom (LimitFunctor j k) a b -> Cod (LimitFunctor j k) (LimitFunctor j k :% a) (LimitFunctor j k :% b) Source #
type Cod (LimitFunctor j k) Source #
Instance details Defined in Data.Category.Limit type Cod (LimitFunctor j k) = k
type Dom (LimitFunctor j k) Source #
Instance details Defined in Data.Category.Limit type Dom (LimitFunctor j k) = Nat j k
type (LimitFunctor j k) :% f Source #
Instance details Defined in Data.Category.Limit type (LimitFunctor j k) :% f = LimitFam j k f

limitAdj :: forall j k. HasLimits j k => Adjunction (Nat j k) k (Diag j k) (LimitFunctor j k) Source #

The limit functor is right adjoint to the diagonal functor.

adjLimit :: Category k => Adjunction (Nat j k) k (Diag j k) r -> Obj (Nat j k) f -> Cone j k f (r :% f) Source #

adjLimitFactorizer :: Category k => Adjunction (Nat j k) k (Diag j k) r -> Cone j k f n -> k n (r :% f) Source #

rightAdjointPreservesLimits :: (HasLimits j c, HasLimits j d) => Adjunction c d f g -> Obj (Nat j c) t -> d (Limit (g :.: t)) (g :% Limit t) Source #

rightAdjointPreservesLimitsInv :: (HasLimits j c, HasLimits j d) => Obj (Nat c d) g -> Obj (Nat j c) t -> d (g :% LimitFam j c t) (LimitFam j d (g :.: t)) Source #

Colimits

class (Category j, Category k) => HasColimits j k where Source #

An instance of HasColimits j k says that k has all colimits of type j.

Associated Types

type ColimitFam (j :: Type -> Type -> Type) (k :: Type -> Type -> Type) (f :: Type) :: Type Source #

Colimits in a category k by means of a diagram of type j, which is a functor from j to k.

Methods

colimit :: Obj (Nat j k) f -> Cocone j k f (ColimitFam j k f) Source #

colimit returns the limiting co-cone for a functor f.

colimitFactorizer :: Cocone j k f n -> k (ColimitFam j k f) n Source #

colimitFactorizer 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.

Instances

Instances details

Category k => HasColimits Boolean k Source #	The colimit of a functor from the Boolean category is the target of the arrow it points to.
Instance details Defined in Data.Category.Boolean Associated Types type ColimitFam Boolean k f Source # Methods colimit :: Obj (Nat Boolean k) f -> Cocone Boolean k f (ColimitFam Boolean k f) Source # colimitFactorizer :: Cocone Boolean k f n -> k (ColimitFam Boolean k f) n Source #
Category k => HasColimits Unit k Source #	The colimit of a single object is that object.
Instance details Defined in Data.Category.Limit Associated Types type ColimitFam Unit k f Source # Methods colimit :: Obj (Nat Unit k) f -> Cocone Unit k f (ColimitFam Unit k f) Source # colimitFactorizer :: Cocone Unit k f n -> k (ColimitFam Unit k f) n Source #
(Category k, HasInitialObject k) => HasColimits Void k Source #	An initial object is the colimit of the functor from 0 to k.
Instance details Defined in Data.Category.Limit Associated Types type ColimitFam Void k f Source # Methods colimit :: Obj (Nat Void k) f -> Cocone Void k f (ColimitFam Void k f) Source # colimitFactorizer :: Cocone Void k f n -> k (ColimitFam Void k f) n Source #
(HasColimits i k, HasColimits j k, HasBinaryCoproducts k) => HasColimits (i :++: j) k Source #	If `k` has binary coproducts, we can take the colimit of 2 joined diagrams.
Instance details Defined in Data.Category.Limit Associated Types type ColimitFam (i :++: j) k f Source # Methods colimit :: Obj (Nat (i :++: j) k) f -> Cocone (i :++: j) k f (ColimitFam (i :++: j) k f) Source # colimitFactorizer :: Cocone (i :++: j) k f n -> k (ColimitFam (i :++: j) k f) n Source #
(HasTerminalObject (i :>>: j), Category i, Category j, Category k) => HasColimits (i :>>: j) k Source #	The colimit of any diagram with a terminal object, has the limit at the terminal object.
Instance details Defined in Data.Category.Limit Associated Types type ColimitFam (i :>>: j) k f Source # Methods colimit :: Obj (Nat (i :>>: j) k) f -> Cocone (i :>>: j) k f (ColimitFam (i :>>: j) k f) Source # colimitFactorizer :: Cocone (i :>>: j) k f n -> k (ColimitFam (i :>>: j) k f) n Source #
HasColimits (->) (->) Source #
Instance details Defined in Data.Category.Limit Associated Types type ColimitFam (->) (->) f Source # Methods colimit :: Obj (Nat (->) (->)) f -> Cocone (->) (->) f (ColimitFam (->) (->) f) Source # colimitFactorizer :: Cocone (->) (->) f n -> ColimitFam (->) (->) f -> n Source #

type Colimit f = ColimitFam (Dom f) (Cod f) f Source #

data ColimitFunctor (j :: Type -> Type -> Type) (k :: Type -> Type -> Type) Source #

Constructors

ColimitFunctor

Instances

Instances details

HasColimits j k => Functor (ColimitFunctor j k) Source #	If every diagram of type `j` has a colimit in `k` there exists a colimit functor. It can be seen as a generalisation of `(+++)`.
Instance details Defined in Data.Category.Limit Associated Types type Dom (ColimitFunctor j k) :: Type -> Type -> Type Source # type Cod (ColimitFunctor j k) :: Type -> Type -> Type Source # type (ColimitFunctor j k) :% a Source # Methods (%) :: ColimitFunctor j k -> Dom (ColimitFunctor j k) a b -> Cod (ColimitFunctor j k) (ColimitFunctor j k :% a) (ColimitFunctor j k :% b) Source #
type Cod (ColimitFunctor j k) Source #
Instance details Defined in Data.Category.Limit type Cod (ColimitFunctor j k) = k
type Dom (ColimitFunctor j k) Source #
Instance details Defined in Data.Category.Limit type Dom (ColimitFunctor j k) = Nat j k
type (ColimitFunctor j k) :% f Source #
Instance details Defined in Data.Category.Limit type (ColimitFunctor j k) :% f = ColimitFam j k f

colimitAdj :: forall j k. HasColimits j k => Adjunction k (Nat j k) (ColimitFunctor j k) (Diag j k) Source #

The colimit functor is left adjoint to the diagonal functor.

adjColimit :: Category k => Adjunction k (Nat j k) l (Diag j k) -> Obj (Nat j k) f -> Cocone j k f (l :% f) Source #

adjColimitFactorizer :: Category k => Adjunction k (Nat j k) l (Diag j k) -> Cocone j k f n -> k (l :% f) n Source #

leftAdjointPreservesColimits :: (HasColimits j c, HasColimits j d) => Adjunction c d f g -> Obj (Nat j d) t -> c (f :% Colimit t) (Colimit (f :.: t)) Source #

leftAdjointPreservesColimitsInv :: (HasColimits j c, HasColimits j d) => Obj (Nat d c) f -> Obj (Nat j d) t -> c (ColimitFam j c (f :.: t)) (f :% ColimitFam j d t) Source #

Limits of type Void

class Category k => HasTerminalObject k where Source #

Associated Types

type TerminalObject k :: Kind k Source #

Methods

terminalObject :: Obj k (TerminalObject k) Source #

terminate :: Obj k a -> k a (TerminalObject k) Source #

Instances

Instances details

HasTerminalObject Boolean Source #	True is the terminal object in the Boolean category.
Instance details Defined in Data.Category.Boolean Associated Types type TerminalObject Boolean :: Kind k Source # Methods terminalObject :: Obj Boolean (TerminalObject Boolean) Source # terminate :: forall (a :: k). Obj Boolean a -> Boolean a (TerminalObject Boolean) Source #
HasTerminalObject Cube Source #
Instance details Defined in Data.Category.Cube Associated Types type TerminalObject Cube :: Kind k Source # Methods terminalObject :: Obj Cube (TerminalObject Cube) Source # terminate :: forall (a :: k). Obj Cube a -> Cube a (TerminalObject Cube) Source #
HasTerminalObject Simplex Source #	The ordinal `1` is the terminal object of the simplex category.
Instance details Defined in Data.Category.Simplex Associated Types type TerminalObject Simplex :: Kind k Source # Methods terminalObject :: Obj Simplex (TerminalObject Simplex) Source # terminate :: forall (a :: k). Obj Simplex a -> Simplex a (TerminalObject Simplex) Source #
HasTerminalObject Unit Source #	The category of one object has that object as terminal object.
Instance details Defined in Data.Category.Limit Associated Types type TerminalObject Unit :: Kind k Source # Methods terminalObject :: Obj Unit (TerminalObject Unit) Source # terminate :: forall (a :: k). Obj Unit a -> Unit a (TerminalObject Unit) Source #
HasTerminalObject (f (Fix f)) => HasTerminalObject (Fix f :: Type -> Type -> Type) Source #	`Fix f` inherits its (co)limits from `f (Fix f)`.
Instance details Defined in Data.Category.Fix Associated Types type TerminalObject (Fix f) :: Kind k Source # Methods terminalObject :: Obj (Fix f) (TerminalObject (Fix f)) Source # terminate :: forall (a :: k). Obj (Fix f) a -> Fix f a (TerminalObject (Fix f)) Source #
(Eq a, Bounded a) => HasTerminalObject (Preorder a :: Type -> Type -> Type) Source #
Instance details Defined in Data.Category.Preorder Associated Types type TerminalObject (Preorder a) :: Kind k Source # Methods terminalObject :: Obj (Preorder a) (TerminalObject (Preorder a)) Source # terminate :: forall (a0 :: k). Obj (Preorder a) a0 -> Preorder a a0 (TerminalObject (Preorder a)) Source #
(Category c1, HasTerminalObject c2) => HasTerminalObject (c1 :>>: c2 :: Type -> Type -> TYPE LiftedRep) Source #	The terminal object of the direct coproduct of categories is the terminal object of the terminal category.
Instance details Defined in Data.Category.Limit Associated Types type TerminalObject (c1 :>>: c2) :: Kind k Source # Methods terminalObject :: Obj (c1 :>>: c2) (TerminalObject (c1 :>>: c2)) Source # terminate :: forall (a :: k). Obj (c1 :>>: c2) a -> (c1 :>>: c2) a (TerminalObject (c1 :>>: c2)) Source #
(Category c, HasTerminalObject d) => HasTerminalObject (Nat c d :: Type -> Type -> Type) Source #	The constant functor to the terminal object is itself the terminal object in its functor category.
Instance details Defined in Data.Category.Limit Associated Types type TerminalObject (Nat c d) :: Kind k Source # Methods terminalObject :: Obj (Nat c d) (TerminalObject (Nat c d)) Source # terminate :: forall (a :: k). Obj (Nat c d) a -> Nat c d a (TerminalObject (Nat c d)) Source #
(HasTerminalObject c1, HasTerminalObject c2) => HasTerminalObject (c1 :**: c2 :: Type -> Type -> Type) Source #	The terminal object of the product of 2 categories is the product of their terminal objects.
Instance details Defined in Data.Category.Limit Associated Types type TerminalObject (c1 :: c2) :: Kind k Source # Methods terminalObject :: Obj (c1 :: c2) (TerminalObject (c1 :: c2)) Source # terminate :: forall (a :: k). Obj (c1 :: c2) a -> (c1 :: c2) a (TerminalObject (c1 :: c2)) Source #
HasTerminalObject (->) Source #	`()` is the terminal object in `Hask`.
Instance details Defined in Data.Category.Limit Associated Types type TerminalObject (->) :: Kind k Source # Methods terminalObject :: Obj (->) (TerminalObject (->)) Source # terminate :: forall (a :: k). Obj (->) a -> a -> TerminalObject (->) Source #
HasTerminalObject (FUN 'One :: Type -> Type -> Type) Source #	The terminal object in the category of linear types is `Top`.
Instance details Defined in Data.Category.Limit Associated Types type TerminalObject (FUN 'One) :: Kind k Source # Methods terminalObject :: Obj (FUN 'One) (TerminalObject (FUN 'One)) Source # terminate :: forall (a :: k). Obj (FUN 'One) a -> FUN 'One a (TerminalObject (FUN 'One)) Source #
HasInitialObject k2 => HasTerminalObject (Op k2 :: k1 -> k1 -> Type) Source #	Terminal objects are the dual of initial objects.
Instance details Defined in Data.Category.Limit Associated Types type TerminalObject (Op k2) :: Kind k Source # Methods terminalObject :: Obj (Op k2) (TerminalObject (Op k2)) Source # terminate :: forall (a :: k). Obj (Op k2) a -> Op k2 a (TerminalObject (Op k2)) Source #
HasTerminalObject (LTE ('S n)) => HasTerminalObject (LTE ('S ('S n)) :: Fin ('S ('S n)) -> Fin ('S ('S n)) -> Type) Source #
Instance details Defined in Data.Category.Fin Associated Types type TerminalObject (LTE ('S ('S n))) :: Kind k Source # Methods terminalObject :: Obj (LTE ('S ('S n))) (TerminalObject (LTE ('S ('S n)))) Source # terminate :: forall (a :: k). Obj (LTE ('S ('S n))) a -> LTE ('S ('S n)) a (TerminalObject (LTE ('S ('S n)))) Source #
HasTerminalObject (LTE ('S 'Z)) Source #
Instance details Defined in Data.Category.Fin Associated Types type TerminalObject (LTE ('S 'Z)) :: Kind k Source # Methods terminalObject :: Obj (LTE ('S 'Z)) (TerminalObject (LTE ('S 'Z))) Source # terminate :: forall (a :: k). Obj (LTE ('S 'Z)) a -> LTE ('S 'Z) a (TerminalObject (LTE ('S 'Z))) Source #
HasTerminalObject Cat Source #	`Unit` is the terminal category.
Instance details Defined in Data.Category.Limit Associated Types type TerminalObject Cat :: Kind k Source # Methods terminalObject :: Obj Cat (TerminalObject Cat) Source # terminate :: forall (a :: k). Obj Cat a -> Cat a (TerminalObject Cat) Source #

class Category k => HasInitialObject k where Source #

Associated Types

type InitialObject k :: Kind k Source #

Methods

initialObject :: Obj k (InitialObject k) Source #

initialize :: Obj k a -> k (InitialObject k) a Source #

Instances

Instances details

HasInitialObject Boolean Source #	False is the initial object in the Boolean category.
Instance details Defined in Data.Category.Boolean Associated Types type InitialObject Boolean :: Kind k Source # Methods initialObject :: Obj Boolean (InitialObject Boolean) Source # initialize :: forall (a :: k). Obj Boolean a -> Boolean (InitialObject Boolean) a Source #
HasInitialObject Simplex Source #	The ordinal `0` is the initial object of the simplex category.
Instance details Defined in Data.Category.Simplex Associated Types type InitialObject Simplex :: Kind k Source # Methods initialObject :: Obj Simplex (InitialObject Simplex) Source # initialize :: forall (a :: k). Obj Simplex a -> Simplex (InitialObject Simplex) a Source #
HasInitialObject Unit Source #	The category of one object has that object as initial object.
Instance details Defined in Data.Category.Limit Associated Types type InitialObject Unit :: Kind k Source # Methods initialObject :: Obj Unit (InitialObject Unit) Source # initialize :: forall (a :: k). Obj Unit a -> Unit (InitialObject Unit) a Source #
HasInitialObject (f (Fix f)) => HasInitialObject (Fix f :: Type -> Type -> Type) Source #	`Fix f` inherits its (co)limits from `f (Fix f)`.
Instance details Defined in Data.Category.Fix Associated Types type InitialObject (Fix f) :: Kind k Source # Methods initialObject :: Obj (Fix f) (InitialObject (Fix f)) Source # initialize :: forall (a :: k). Obj (Fix f) a -> Fix f (InitialObject (Fix f)) a Source #
(Eq a, Bounded a) => HasInitialObject (Preorder a :: Type -> Type -> Type) Source #
Instance details Defined in Data.Category.Preorder Associated Types type InitialObject (Preorder a) :: Kind k Source # Methods initialObject :: Obj (Preorder a) (InitialObject (Preorder a)) Source # initialize :: forall (a0 :: k). Obj (Preorder a) a0 -> Preorder a (InitialObject (Preorder a)) a0 Source #
(HasInitialObject c1, Category c2) => HasInitialObject (c1 :>>: c2 :: Type -> Type -> TYPE LiftedRep) Source #	The initial object of the direct coproduct of categories is the initial object of the initial category.
Instance details Defined in Data.Category.Limit Associated Types type InitialObject (c1 :>>: c2) :: Kind k Source # Methods initialObject :: Obj (c1 :>>: c2) (InitialObject (c1 :>>: c2)) Source # initialize :: forall (a :: k). Obj (c1 :>>: c2) a -> (c1 :>>: c2) (InitialObject (c1 :>>: c2)) a Source #
HasInitialObject (Dialg (Tuple1 (->) (->) ()) (DiagProd (->))) Source #	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>`.
Instance details Defined in Data.Category.Dialg Associated Types type InitialObject (Dialg (Tuple1 (->) (->) ()) (DiagProd (->))) :: Kind k Source # Methods initialObject :: Obj (Dialg (Tuple1 (->) (->) ()) (DiagProd (->))) (InitialObject (Dialg (Tuple1 (->) (->) ()) (DiagProd (->)))) Source # initialize :: forall (a :: k). Obj (Dialg (Tuple1 (->) (->) ()) (DiagProd (->))) a -> Dialg (Tuple1 (->) (->) ()) (DiagProd (->)) (InitialObject (Dialg (Tuple1 (->) (->) ()) (DiagProd (->)))) a Source #
(Category c, HasInitialObject d) => HasInitialObject (Nat c d :: Type -> Type -> Type) Source #	The constant functor to the initial object is itself the initial object in its functor category.
Instance details Defined in Data.Category.Limit Associated Types type InitialObject (Nat c d) :: Kind k Source # Methods initialObject :: Obj (Nat c d) (InitialObject (Nat c d)) Source # initialize :: forall (a :: k). Obj (Nat c d) a -> Nat c d (InitialObject (Nat c d)) a Source #
(HasInitialObject c1, HasInitialObject c2) => HasInitialObject (c1 :**: c2 :: Type -> Type -> Type) Source #	The initial object of the product of 2 categories is the product of their initial objects.
Instance details Defined in Data.Category.Limit Associated Types type InitialObject (c1 :: c2) :: Kind k Source # Methods initialObject :: Obj (c1 :: c2) (InitialObject (c1 :: c2)) Source # initialize :: forall (a :: k). Obj (c1 :: c2) a -> (c1 :: c2) (InitialObject (c1 :: c2)) a Source #
HasInitialObject (FUN m :: Type -> Type -> Type) Source #	Any empty data type is an initial object in `Hask`.
Instance details Defined in Data.Category.Limit Associated Types type InitialObject (FUN m) :: Kind k Source # Methods initialObject :: Obj (FUN m) (InitialObject (FUN m)) Source # initialize :: forall (a :: k). Obj (FUN m) a -> FUN m (InitialObject (FUN m)) a Source #
HasTerminalObject k2 => HasInitialObject (Op k2 :: k1 -> k1 -> Type) Source #	Terminal objects are the dual of initial objects.
Instance details Defined in Data.Category.Limit Associated Types type InitialObject (Op k2) :: Kind k Source # Methods initialObject :: Obj (Op k2) (InitialObject (Op k2)) Source # initialize :: forall (a :: k). Obj (Op k2) a -> Op k2 (InitialObject (Op k2)) a Source #
HasInitialObject (LTE ('S n) :: Fin ('S n) -> Fin ('S n) -> Type) Source #
Instance details Defined in Data.Category.Fin Associated Types type InitialObject (LTE ('S n)) :: Kind k Source # Methods initialObject :: Obj (LTE ('S n)) (InitialObject (LTE ('S n))) Source # initialize :: forall (a :: k). Obj (LTE ('S n)) a -> LTE ('S n) (InitialObject (LTE ('S n))) a Source #
HasInitialObject Cat Source #	The empty category is the initial object in `Cat`.
Instance details Defined in Data.Category.Limit Associated Types type InitialObject Cat :: Kind k Source # Methods initialObject :: Obj Cat (InitialObject Cat) Source # initialize :: forall (a :: k). Obj Cat a -> Cat (InitialObject Cat) a Source #

data Zero Source #

Limits of type Pair

class Category k => HasBinaryProducts k where Source #

Minimal complete definition

proj1, proj2, (&&&)

Associated Types

type BinaryProduct k (x :: Kind k) (y :: Kind k) :: Kind k Source #

Methods

proj1 :: Obj k x -> Obj k y -> k (BinaryProduct k x y) x Source #

proj2 :: Obj k x -> Obj k y -> k (BinaryProduct k x y) y Source #

(&&&) :: k a x -> k a y -> k a (BinaryProduct k x y) infixl 3 Source #

(***) :: k a1 b1 -> k a2 b2 -> k (BinaryProduct k a1 a2) (BinaryProduct k b1 b2) infixl 3 Source #

Instances

Instances details

HasBinaryProducts Boolean Source #	Conjunction is the binary product in the Boolean category.
Instance details Defined in Data.Category.Boolean Associated Types type BinaryProduct Boolean x y :: Kind k Source # Methods proj1 :: forall (x :: k) (y :: k). Obj Boolean x -> Obj Boolean y -> Boolean (BinaryProduct Boolean x y) x Source # proj2 :: forall (x :: k) (y :: k). Obj Boolean x -> Obj Boolean y -> Boolean (BinaryProduct Boolean x y) y Source # (&&&) :: forall (a :: k) (x :: k) (y :: k). Boolean a x -> Boolean a y -> Boolean a (BinaryProduct Boolean x y) Source # (***) :: forall (a1 :: k) (b1 :: k) (a2 :: k) (b2 :: k). Boolean a1 b1 -> Boolean a2 b2 -> Boolean (BinaryProduct Boolean a1 a2) (BinaryProduct Boolean b1 b2) Source #
HasBinaryProducts Unit Source #	In the category of one object that object is its own product.
Instance details Defined in Data.Category.Limit Associated Types type BinaryProduct Unit x y :: Kind k Source # Methods proj1 :: forall (x :: k) (y :: k). Obj Unit x -> Obj Unit y -> Unit (BinaryProduct Unit x y) x Source # proj2 :: forall (x :: k) (y :: k). Obj Unit x -> Obj Unit y -> Unit (BinaryProduct Unit x y) y Source # (&&&) :: forall (a :: k) (x :: k) (y :: k). Unit a x -> Unit a y -> Unit a (BinaryProduct Unit x y) Source # (***) :: forall (a1 :: k) (b1 :: k) (a2 :: k) (b2 :: k). Unit a1 b1 -> Unit a2 b2 -> Unit (BinaryProduct Unit a1 a2) (BinaryProduct Unit b1 b2) Source #
HasBinaryProducts (f (Fix f)) => HasBinaryProducts (Fix f :: Type -> Type -> Type) Source #	`Fix f` inherits its (co)limits from `f (Fix f)`.
Instance details Defined in Data.Category.Fix Associated Types type BinaryProduct (Fix f) x y :: Kind k Source # Methods proj1 :: forall (x :: k) (y :: k). Obj (Fix f) x -> Obj (Fix f) y -> Fix f (BinaryProduct (Fix f) x y) x Source # proj2 :: forall (x :: k) (y :: k). Obj (Fix f) x -> Obj (Fix f) y -> Fix f (BinaryProduct (Fix f) x y) y Source # (&&&) :: forall (a :: k) (x :: k) (y :: k). Fix f a x -> Fix f a y -> Fix f a (BinaryProduct (Fix f) x y) Source # (***) :: forall (a1 :: k) (b1 :: k) (a2 :: k) (b2 :: k). Fix f a1 b1 -> Fix f a2 b2 -> Fix f (BinaryProduct (Fix f) a1 a2) (BinaryProduct (Fix f) b1 b2) Source #
Ord a => HasBinaryProducts (Preorder a :: Type -> Type -> Type) Source #
Instance details Defined in Data.Category.Preorder Associated Types type BinaryProduct (Preorder a) x y :: Kind k Source # Methods proj1 :: forall (x :: k) (y :: k). Obj (Preorder a) x -> Obj (Preorder a) y -> Preorder a (BinaryProduct (Preorder a) x y) x Source # proj2 :: forall (x :: k) (y :: k). Obj (Preorder a) x -> Obj (Preorder a) y -> Preorder a (BinaryProduct (Preorder a) x y) y Source # (&&&) :: forall (a0 :: k) (x :: k) (y :: k). Preorder a a0 x -> Preorder a a0 y -> Preorder a a0 (BinaryProduct (Preorder a) x y) Source # (***) :: forall (a1 :: k) (b1 :: k) (a2 :: k) (b2 :: k). Preorder a a1 b1 -> Preorder a a2 b2 -> Preorder a (BinaryProduct (Preorder a) a1 a2) (BinaryProduct (Preorder a) b1 b2) Source #
(HasBinaryProducts c1, HasBinaryProducts c2) => HasBinaryProducts (c1 :>>: c2 :: Type -> Type -> TYPE LiftedRep) Source #
Instance details Defined in Data.Category.Limit Associated Types type BinaryProduct (c1 :>>: c2) x y :: Kind k Source # Methods proj1 :: forall (x :: k) (y :: k). Obj (c1 :>>: c2) x -> Obj (c1 :>>: c2) y -> (c1 :>>: c2) (BinaryProduct (c1 :>>: c2) x y) x Source # proj2 :: forall (x :: k) (y :: k). Obj (c1 :>>: c2) x -> Obj (c1 :>>: c2) y -> (c1 :>>: c2) (BinaryProduct (c1 :>>: c2) x y) y Source # (&&&) :: forall (a :: k) (x :: k) (y :: k). (c1 :>>: c2) a x -> (c1 :>>: c2) a y -> (c1 :>>: c2) a (BinaryProduct (c1 :>>: c2) x y) Source # (***) :: forall (a1 :: k) (b1 :: k) (a2 :: k) (b2 :: k). (c1 :>>: c2) a1 b1 -> (c1 :>>: c2) a2 b2 -> (c1 :>>: c2) (BinaryProduct (c1 :>>: c2) a1 a2) (BinaryProduct (c1 :>>: c2) b1 b2) Source #
(Category c, HasBinaryProducts d) => HasBinaryProducts (Nat c d :: Type -> Type -> Type) Source #	The functor product `:*:` is the binary product in functor categories.
Instance details Defined in Data.Category.Limit Associated Types type BinaryProduct (Nat c d) x y :: Kind k Source # Methods proj1 :: forall (x :: k) (y :: k). Obj (Nat c d) x -> Obj (Nat c d) y -> Nat c d (BinaryProduct (Nat c d) x y) x Source # proj2 :: forall (x :: k) (y :: k). Obj (Nat c d) x -> Obj (Nat c d) y -> Nat c d (BinaryProduct (Nat c d) x y) y Source # (&&&) :: forall (a :: k) (x :: k) (y :: k). Nat c d a x -> Nat c d a y -> Nat c d a (BinaryProduct (Nat c d) x y) Source # (***) :: forall (a1 :: k) (b1 :: k) (a2 :: k) (b2 :: k). Nat c d a1 b1 -> Nat c d a2 b2 -> Nat c d (BinaryProduct (Nat c d) a1 a2) (BinaryProduct (Nat c d) b1 b2) Source #
(HasBinaryProducts c1, HasBinaryProducts c2) => HasBinaryProducts (c1 :**: c2 :: Type -> Type -> Type) Source #	The binary product of the product of 2 categories is the product of their binary products.
Instance details Defined in Data.Category.Limit Associated Types type BinaryProduct (c1 :: c2) x y :: Kind k Source # Methods proj1 :: forall (x :: k) (y :: k). Obj (c1 :: c2) x -> Obj (c1 :: c2) y -> (c1 :: c2) (BinaryProduct (c1 :: c2) x y) x Source # proj2 :: forall (x :: k) (y :: k). Obj (c1 :: c2) x -> Obj (c1 :: c2) y -> (c1 :: c2) (BinaryProduct (c1 :: c2) x y) y Source # (&&&) :: forall (a :: k) (x :: k) (y :: k). (c1 :: c2) a x -> (c1 :: c2) a y -> (c1 :: c2) a (BinaryProduct (c1 :: c2) x y) Source # () :: forall (a1 :: k) (b1 :: k) (a2 :: k) (b2 :: k). (c1 :: c2) a1 b1 -> (c1 :: c2) a2 b2 -> (c1 :: c2) (BinaryProduct (c1 :: c2) a1 a2) (BinaryProduct (c1 :*: c2) b1 b2) Source #
HasBinaryProducts (->) Source #	The tuple is the binary product in `Hask`.
Instance details Defined in Data.Category.Limit Associated Types type BinaryProduct (->) x y :: Kind k Source # Methods proj1 :: forall (x :: k) (y :: k). Obj (->) x -> Obj (->) y -> BinaryProduct (->) x y -> x Source # proj2 :: forall (x :: k) (y :: k). Obj (->) x -> Obj (->) y -> BinaryProduct (->) x y -> y Source # (&&&) :: forall (a :: k) (x :: k) (y :: k). (a -> x) -> (a -> y) -> a -> BinaryProduct (->) x y Source # (***) :: forall (a1 :: k) (b1 :: k) (a2 :: k) (b2 :: k). (a1 -> b1) -> (a2 -> b2) -> BinaryProduct (->) a1 a2 -> BinaryProduct (->) b1 b2 Source #
HasBinaryProducts (FUN 'One :: Type -> Type -> Type) Source #	The product in the category of linear types is a & b, where you have access to a and b, but not both at the same time.
Instance details Defined in Data.Category.Limit Associated Types type BinaryProduct (FUN 'One) x y :: Kind k Source # Methods proj1 :: forall (x :: k) (y :: k). Obj (FUN 'One) x -> Obj (FUN 'One) y -> FUN 'One (BinaryProduct (FUN 'One) x y) x Source # proj2 :: forall (x :: k) (y :: k). Obj (FUN 'One) x -> Obj (FUN 'One) y -> FUN 'One (BinaryProduct (FUN 'One) x y) y Source # (&&&) :: forall (a :: k) (x :: k) (y :: k). FUN 'One a x -> FUN 'One a y -> FUN 'One a (BinaryProduct (FUN 'One) x y) Source # (***) :: forall (a1 :: k) (b1 :: k) (a2 :: k) (b2 :: k). FUN 'One a1 b1 -> FUN 'One a2 b2 -> FUN 'One (BinaryProduct (FUN 'One) a1 a2) (BinaryProduct (FUN 'One) b1 b2) Source #
HasBinaryCoproducts k2 => HasBinaryProducts (Op k2 :: k1 -> k1 -> Type) Source #	Binary products are the dual of binary coproducts.
Instance details Defined in Data.Category.Limit Associated Types type BinaryProduct (Op k2) x y :: Kind k Source # Methods proj1 :: forall (x :: k) (y :: k). Obj (Op k2) x -> Obj (Op k2) y -> Op k2 (BinaryProduct (Op k2) x y) x Source # proj2 :: forall (x :: k) (y :: k). Obj (Op k2) x -> Obj (Op k2) y -> Op k2 (BinaryProduct (Op k2) x y) y Source # (&&&) :: forall (a :: k) (x :: k) (y :: k). Op k2 a x -> Op k2 a y -> Op k2 a (BinaryProduct (Op k2) x y) Source # (***) :: forall (a1 :: k) (b1 :: k) (a2 :: k) (b2 :: k). Op k2 a1 b1 -> Op k2 a2 b2 -> Op k2 (BinaryProduct (Op k2) a1 a2) (BinaryProduct (Op k2) b1 b2) Source #
HasBinaryProducts (LTE ('S n)) => HasBinaryProducts (LTE ('S ('S n)) :: Fin ('S ('S n)) -> Fin ('S ('S n)) -> Type) Source #
Instance details Defined in Data.Category.Fin Associated Types type BinaryProduct (LTE ('S ('S n))) x y :: Kind k Source # Methods proj1 :: forall (x :: k) (y :: k). Obj (LTE ('S ('S n))) x -> Obj (LTE ('S ('S n))) y -> LTE ('S ('S n)) (BinaryProduct (LTE ('S ('S n))) x y) x Source # proj2 :: forall (x :: k) (y :: k). Obj (LTE ('S ('S n))) x -> Obj (LTE ('S ('S n))) y -> LTE ('S ('S n)) (BinaryProduct (LTE ('S ('S n))) x y) y Source # (&&&) :: forall (a :: k) (x :: k) (y :: k). LTE ('S ('S n)) a x -> LTE ('S ('S n)) a y -> LTE ('S ('S n)) a (BinaryProduct (LTE ('S ('S n))) x y) Source # (***) :: forall (a1 :: k) (b1 :: k) (a2 :: k) (b2 :: k). LTE ('S ('S n)) a1 b1 -> LTE ('S ('S n)) a2 b2 -> LTE ('S ('S n)) (BinaryProduct (LTE ('S ('S n))) a1 a2) (BinaryProduct (LTE ('S ('S n))) b1 b2) Source #
HasBinaryProducts (LTE ('S 'Z)) Source #
Instance details Defined in Data.Category.Fin Associated Types type BinaryProduct (LTE ('S 'Z)) x y :: Kind k Source # Methods proj1 :: forall (x :: k) (y :: k). Obj (LTE ('S 'Z)) x -> Obj (LTE ('S 'Z)) y -> LTE ('S 'Z) (BinaryProduct (LTE ('S 'Z)) x y) x Source # proj2 :: forall (x :: k) (y :: k). Obj (LTE ('S 'Z)) x -> Obj (LTE ('S 'Z)) y -> LTE ('S 'Z) (BinaryProduct (LTE ('S 'Z)) x y) y Source # (&&&) :: forall (a :: k) (x :: k) (y :: k). LTE ('S 'Z) a x -> LTE ('S 'Z) a y -> LTE ('S 'Z) a (BinaryProduct (LTE ('S 'Z)) x y) Source # (***) :: forall (a1 :: k) (b1 :: k) (a2 :: k) (b2 :: k). LTE ('S 'Z) a1 b1 -> LTE ('S 'Z) a2 b2 -> LTE ('S 'Z) (BinaryProduct (LTE ('S 'Z)) a1 a2) (BinaryProduct (LTE ('S 'Z)) b1 b2) Source #
HasBinaryProducts Cat Source #	The product of categories `:**:` is the binary product in `Cat`.
Instance details Defined in Data.Category.Limit Associated Types type BinaryProduct Cat x y :: Kind k Source # Methods proj1 :: forall (x :: k) (y :: k). Obj Cat x -> Obj Cat y -> Cat (BinaryProduct Cat x y) x Source # proj2 :: forall (x :: k) (y :: k). Obj Cat x -> Obj Cat y -> Cat (BinaryProduct Cat x y) y Source # (&&&) :: forall (a :: k) (x :: k) (y :: k). Cat a x -> Cat a y -> Cat a (BinaryProduct Cat x y) Source # (***) :: forall (a1 :: k) (b1 :: k) (a2 :: k) (b2 :: k). Cat a1 b1 -> Cat a2 b2 -> Cat (BinaryProduct Cat a1 a2) (BinaryProduct Cat b1 b2) Source #

data ProductFunctor (k :: Type -> Type -> Type) Source #

Constructors

ProductFunctor

Instances

Instances details

HasBinaryProducts k => Functor (ProductFunctor k) Source #	Binary product as a bifunctor.
Instance details Defined in Data.Category.Limit Associated Types type Dom (ProductFunctor k) :: Type -> Type -> Type Source # type Cod (ProductFunctor k) :: Type -> Type -> Type Source # type (ProductFunctor k) :% a Source # Methods (%) :: ProductFunctor k -> Dom (ProductFunctor k) a b -> Cod (ProductFunctor k) (ProductFunctor k :% a) (ProductFunctor k :% b) Source #
(HasTerminalObject k, HasBinaryProducts k) => SymmetricTensorProduct (ProductFunctor k) Source #
Instance details Defined in Data.Category.Monoidal Methods swap :: Cod (ProductFunctor k) ~ k0 => ProductFunctor k -> Obj k0 a -> Obj k0 b -> k0 (ProductFunctor k :% (a, b)) (ProductFunctor k :% (b, a)) Source #
(HasTerminalObject k, HasBinaryProducts k) => TensorProduct (ProductFunctor k) Source #	If a category has all products, then the product functor makes it a monoidal category, with the terminal object as unit.
Instance details Defined in Data.Category.Monoidal Associated Types type Unit (ProductFunctor k) :: Kind (Cod f) Source # Methods unitObject :: ProductFunctor k -> Obj (Cod (ProductFunctor k)) (Unit (ProductFunctor k)) Source # leftUnitor :: Cod (ProductFunctor k) ~ k0 => ProductFunctor k -> Obj k0 a -> k0 (ProductFunctor k :% (Unit (ProductFunctor k), a)) a Source # leftUnitorInv :: Cod (ProductFunctor k) ~ k0 => ProductFunctor k -> Obj k0 a -> k0 a (ProductFunctor k :% (Unit (ProductFunctor k), a)) Source # rightUnitor :: Cod (ProductFunctor k) ~ k0 => ProductFunctor k -> Obj k0 a -> k0 (ProductFunctor k :% (a, Unit (ProductFunctor k))) a Source # rightUnitorInv :: Cod (ProductFunctor k) ~ k0 => ProductFunctor k -> Obj k0 a -> k0 a (ProductFunctor k :% (a, Unit (ProductFunctor k))) Source # associator :: Cod (ProductFunctor k) ~ k0 => ProductFunctor k -> Obj k0 a -> Obj k0 b -> Obj k0 c -> k0 (ProductFunctor k :% (ProductFunctor k :% (a, b), c)) (ProductFunctor k :% (a, ProductFunctor k :% (b, c))) Source # associatorInv :: Cod (ProductFunctor k) ~ k0 => ProductFunctor k -> Obj k0 a -> Obj k0 b -> Obj k0 c -> k0 (ProductFunctor k :% (a, ProductFunctor k :% (b, c))) (ProductFunctor k :% (ProductFunctor k :% (a, b), c)) Source #
type Cod (ProductFunctor k) Source #
Instance details Defined in Data.Category.Limit type Cod (ProductFunctor k) = k
type Dom (ProductFunctor k) Source #
Instance details Defined in Data.Category.Limit type Dom (ProductFunctor k) = k :**: k
type Unit (ProductFunctor k) Source #
Instance details Defined in Data.Category.Monoidal type Unit (ProductFunctor k) = TerminalObject k
type (ProductFunctor k) :% (a, b) Source #
Instance details Defined in Data.Category.Limit type (ProductFunctor k) :% (a, b) = BinaryProduct k a b

data p :*: q where Source #

Constructors

(:*:) :: (Functor p, Functor q, Dom p ~ Dom q, Cod p ~ k, Cod q ~ k, HasBinaryProducts k) => p -> q -> p :*: q

Instances

Instances details

(Category (Dom p), Category (Cod p)) => Functor (p :*: q) Source #	The product of two functors, passing the same object to both functors and taking the product of the results.
Instance details Defined in Data.Category.Limit Associated Types type Dom (p :: q) :: Type -> Type -> Type Source # type Cod (p :: q) :: Type -> Type -> Type Source # type (p :: q) :% a Source # Methods (%) :: (p :: q) -> Dom (p :: q) a b -> Cod (p :: q) ((p :: q) :% a) ((p :: q) :% b) Source #
type Cod (p :*: q) Source #
Instance details Defined in Data.Category.Limit type Cod (p :*: q) = Cod p
type Dom (p :*: q) Source #
Instance details Defined in Data.Category.Limit type Dom (p :*: q) = Dom p
type (p :*: q) :% a Source #
Instance details Defined in Data.Category.Limit type (p :*: q) :% a = BinaryProduct (Cod p) (p :% a) (q :% a)

prodAdj :: HasBinaryProducts k => Adjunction (k :**: k) k (DiagProd k) (ProductFunctor k) Source #

A specialisation of the limit adjunction to products.

newtype x & y Source #

Constructors

AddConj (forall r. Either (x %1 -> r) (y %1 -> r) %1 -> r)

class Category k => HasBinaryCoproducts k where Source #

Minimal complete definition

inj1, inj2, (|||)

Associated Types

type BinaryCoproduct k (x :: Kind k) (y :: Kind k) :: Kind k Source #

Methods

inj1 :: Obj k x -> Obj k y -> k x (BinaryCoproduct k x y) Source #

inj2 :: Obj k x -> Obj k y -> k y (BinaryCoproduct k x y) Source #

(|||) :: k x a -> k y a -> k (BinaryCoproduct k x y) a infixl 2 Source #

(+++) :: k a1 b1 -> k a2 b2 -> k (BinaryCoproduct k a1 a2) (BinaryCoproduct k b1 b2) infixl 2 Source #

Instances

Instances details

HasBinaryCoproducts Boolean Source #	Disjunction is the binary coproduct in the Boolean category.
Instance details Defined in Data.Category.Boolean Associated Types type BinaryCoproduct Boolean x y :: Kind k Source # Methods inj1 :: forall (x :: k) (y :: k). Obj Boolean x -> Obj Boolean y -> Boolean x (BinaryCoproduct Boolean x y) Source # inj2 :: forall (x :: k) (y :: k). Obj Boolean x -> Obj Boolean y -> Boolean y (BinaryCoproduct Boolean x y) Source # (\|\|\|) :: forall (x :: k) (a :: k) (y :: k). Boolean x a -> Boolean y a -> Boolean (BinaryCoproduct Boolean x y) a Source # (+++) :: forall (a1 :: k) (b1 :: k) (a2 :: k) (b2 :: k). Boolean a1 b1 -> Boolean a2 b2 -> Boolean (BinaryCoproduct Boolean a1 a2) (BinaryCoproduct Boolean b1 b2) Source #
HasBinaryCoproducts Unit Source #	In the category of one object that object is its own coproduct.
Instance details Defined in Data.Category.Limit Associated Types type BinaryCoproduct Unit x y :: Kind k Source # Methods inj1 :: forall (x :: k) (y :: k). Obj Unit x -> Obj Unit y -> Unit x (BinaryCoproduct Unit x y) Source # inj2 :: forall (x :: k) (y :: k). Obj Unit x -> Obj Unit y -> Unit y (BinaryCoproduct Unit x y) Source # (\|\|\|) :: forall (x :: k) (a :: k) (y :: k). Unit x a -> Unit y a -> Unit (BinaryCoproduct Unit x y) a Source # (+++) :: forall (a1 :: k) (b1 :: k) (a2 :: k) (b2 :: k). Unit a1 b1 -> Unit a2 b2 -> Unit (BinaryCoproduct Unit a1 a2) (BinaryCoproduct Unit b1 b2) Source #
HasBinaryCoproducts (f (Fix f)) => HasBinaryCoproducts (Fix f :: Type -> Type -> Type) Source #	`Fix f` inherits its (co)limits from `f (Fix f)`.
Instance details Defined in Data.Category.Fix Associated Types type BinaryCoproduct (Fix f) x y :: Kind k Source # Methods inj1 :: forall (x :: k) (y :: k). Obj (Fix f) x -> Obj (Fix f) y -> Fix f x (BinaryCoproduct (Fix f) x y) Source # inj2 :: forall (x :: k) (y :: k). Obj (Fix f) x -> Obj (Fix f) y -> Fix f y (BinaryCoproduct (Fix f) x y) Source # (\|\|\|) :: forall (x :: k) (a :: k) (y :: k). Fix f x a -> Fix f y a -> Fix f (BinaryCoproduct (Fix f) x y) a Source # (+++) :: forall (a1 :: k) (b1 :: k) (a2 :: k) (b2 :: k). Fix f a1 b1 -> Fix f a2 b2 -> Fix f (BinaryCoproduct (Fix f) a1 a2) (BinaryCoproduct (Fix f) b1 b2) Source #
Ord a => HasBinaryCoproducts (Preorder a :: Type -> Type -> Type) Source #
Instance details Defined in Data.Category.Preorder Associated Types type BinaryCoproduct (Preorder a) x y :: Kind k Source # Methods inj1 :: forall (x :: k) (y :: k). Obj (Preorder a) x -> Obj (Preorder a) y -> Preorder a x (BinaryCoproduct (Preorder a) x y) Source # inj2 :: forall (x :: k) (y :: k). Obj (Preorder a) x -> Obj (Preorder a) y -> Preorder a y (BinaryCoproduct (Preorder a) x y) Source # (\|\|\|) :: forall (x :: k) (a0 :: k) (y :: k). Preorder a x a0 -> Preorder a y a0 -> Preorder a (BinaryCoproduct (Preorder a) x y) a0 Source # (+++) :: forall (a1 :: k) (b1 :: k) (a2 :: k) (b2 :: k). Preorder a a1 b1 -> Preorder a a2 b2 -> Preorder a (BinaryCoproduct (Preorder a) a1 a2) (BinaryCoproduct (Preorder a) b1 b2) Source #
(HasBinaryCoproducts c1, HasBinaryCoproducts c2) => HasBinaryCoproducts (c1 :>>: c2 :: Type -> Type -> TYPE LiftedRep) Source #
Instance details Defined in Data.Category.Limit Associated Types type BinaryCoproduct (c1 :>>: c2) x y :: Kind k Source # Methods inj1 :: forall (x :: k) (y :: k). Obj (c1 :>>: c2) x -> Obj (c1 :>>: c2) y -> (c1 :>>: c2) x (BinaryCoproduct (c1 :>>: c2) x y) Source # inj2 :: forall (x :: k) (y :: k). Obj (c1 :>>: c2) x -> Obj (c1 :>>: c2) y -> (c1 :>>: c2) y (BinaryCoproduct (c1 :>>: c2) x y) Source # (\|\|\|) :: forall (x :: k) (a :: k) (y :: k). (c1 :>>: c2) x a -> (c1 :>>: c2) y a -> (c1 :>>: c2) (BinaryCoproduct (c1 :>>: c2) x y) a Source # (+++) :: forall (a1 :: k) (b1 :: k) (a2 :: k) (b2 :: k). (c1 :>>: c2) a1 b1 -> (c1 :>>: c2) a2 b2 -> (c1 :>>: c2) (BinaryCoproduct (c1 :>>: c2) a1 a2) (BinaryCoproduct (c1 :>>: c2) b1 b2) Source #
(Category c, HasBinaryCoproducts d) => HasBinaryCoproducts (Nat c d :: Type -> Type -> Type) Source #	The functor coproduct `:+:` is the binary coproduct in functor categories.
Instance details Defined in Data.Category.Limit Associated Types type BinaryCoproduct (Nat c d) x y :: Kind k Source # Methods inj1 :: forall (x :: k) (y :: k). Obj (Nat c d) x -> Obj (Nat c d) y -> Nat c d x (BinaryCoproduct (Nat c d) x y) Source # inj2 :: forall (x :: k) (y :: k). Obj (Nat c d) x -> Obj (Nat c d) y -> Nat c d y (BinaryCoproduct (Nat c d) x y) Source # (\|\|\|) :: forall (x :: k) (a :: k) (y :: k). Nat c d x a -> Nat c d y a -> Nat c d (BinaryCoproduct (Nat c d) x y) a Source # (+++) :: forall (a1 :: k) (b1 :: k) (a2 :: k) (b2 :: k). Nat c d a1 b1 -> Nat c d a2 b2 -> Nat c d (BinaryCoproduct (Nat c d) a1 a2) (BinaryCoproduct (Nat c d) b1 b2) Source #
(HasBinaryCoproducts c1, HasBinaryCoproducts c2) => HasBinaryCoproducts (c1 :**: c2 :: Type -> Type -> Type) Source #	The binary coproduct of the product of 2 categories is the product of their binary coproducts.
Instance details Defined in Data.Category.Limit Associated Types type BinaryCoproduct (c1 :: c2) x y :: Kind k Source # Methods inj1 :: forall (x :: k) (y :: k). Obj (c1 :: c2) x -> Obj (c1 :: c2) y -> (c1 :: c2) x (BinaryCoproduct (c1 :: c2) x y) Source # inj2 :: forall (x :: k) (y :: k). Obj (c1 :: c2) x -> Obj (c1 :: c2) y -> (c1 :: c2) y (BinaryCoproduct (c1 :: c2) x y) Source # (\|\|\|) :: forall (x :: k) (a :: k) (y :: k). (c1 :: c2) x a -> (c1 :: c2) y a -> (c1 :: c2) (BinaryCoproduct (c1 :: c2) x y) a Source # (+++) :: forall (a1 :: k) (b1 :: k) (a2 :: k) (b2 :: k). (c1 :: c2) a1 b1 -> (c1 :: c2) a2 b2 -> (c1 :: c2) (BinaryCoproduct (c1 :: c2) a1 a2) (BinaryCoproduct (c1 :: c2) b1 b2) Source #
HasBinaryCoproducts (FUN m :: Type -> Type -> Type) Source #
Instance details Defined in Data.Category.Limit Associated Types type BinaryCoproduct (FUN m) x y :: Kind k Source # Methods inj1 :: forall (x :: k) (y :: k). Obj (FUN m) x -> Obj (FUN m) y -> FUN m x (BinaryCoproduct (FUN m) x y) Source # inj2 :: forall (x :: k) (y :: k). Obj (FUN m) x -> Obj (FUN m) y -> FUN m y (BinaryCoproduct (FUN m) x y) Source # (\|\|\|) :: forall (x :: k) (a :: k) (y :: k). FUN m x a -> FUN m y a -> FUN m (BinaryCoproduct (FUN m) x y) a Source # (+++) :: forall (a1 :: k) (b1 :: k) (a2 :: k) (b2 :: k). FUN m a1 b1 -> FUN m a2 b2 -> FUN m (BinaryCoproduct (FUN m) a1 a2) (BinaryCoproduct (FUN m) b1 b2) Source #
HasBinaryProducts k2 => HasBinaryCoproducts (Op k2 :: k1 -> k1 -> Type) Source #	Binary products are the dual of binary coproducts.
Instance details Defined in Data.Category.Limit Associated Types type BinaryCoproduct (Op k2) x y :: Kind k Source # Methods inj1 :: forall (x :: k) (y :: k). Obj (Op k2) x -> Obj (Op k2) y -> Op k2 x (BinaryCoproduct (Op k2) x y) Source # inj2 :: forall (x :: k) (y :: k). Obj (Op k2) x -> Obj (Op k2) y -> Op k2 y (BinaryCoproduct (Op k2) x y) Source # (\|\|\|) :: forall (x :: k) (a :: k) (y :: k). Op k2 x a -> Op k2 y a -> Op k2 (BinaryCoproduct (Op k2) x y) a Source # (+++) :: forall (a1 :: k) (b1 :: k) (a2 :: k) (b2 :: k). Op k2 a1 b1 -> Op k2 a2 b2 -> Op k2 (BinaryCoproduct (Op k2) a1 a2) (BinaryCoproduct (Op k2) b1 b2) Source #
HasBinaryCoproducts (LTE ('S n)) => HasBinaryCoproducts (LTE ('S ('S n)) :: Fin ('S ('S n)) -> Fin ('S ('S n)) -> Type) Source #
Instance details Defined in Data.Category.Fin Associated Types type BinaryCoproduct (LTE ('S ('S n))) x y :: Kind k Source # Methods inj1 :: forall (x :: k) (y :: k). Obj (LTE ('S ('S n))) x -> Obj (LTE ('S ('S n))) y -> LTE ('S ('S n)) x (BinaryCoproduct (LTE ('S ('S n))) x y) Source # inj2 :: forall (x :: k) (y :: k). Obj (LTE ('S ('S n))) x -> Obj (LTE ('S ('S n))) y -> LTE ('S ('S n)) y (BinaryCoproduct (LTE ('S ('S n))) x y) Source # (\|\|\|) :: forall (x :: k) (a :: k) (y :: k). LTE ('S ('S n)) x a -> LTE ('S ('S n)) y a -> LTE ('S ('S n)) (BinaryCoproduct (LTE ('S ('S n))) x y) a Source # (+++) :: forall (a1 :: k) (b1 :: k) (a2 :: k) (b2 :: k). LTE ('S ('S n)) a1 b1 -> LTE ('S ('S n)) a2 b2 -> LTE ('S ('S n)) (BinaryCoproduct (LTE ('S ('S n))) a1 a2) (BinaryCoproduct (LTE ('S ('S n))) b1 b2) Source #
HasBinaryCoproducts (LTE ('S 'Z)) Source #
Instance details Defined in Data.Category.Fin Associated Types type BinaryCoproduct (LTE ('S 'Z)) x y :: Kind k Source # Methods inj1 :: forall (x :: k) (y :: k). Obj (LTE ('S 'Z)) x -> Obj (LTE ('S 'Z)) y -> LTE ('S 'Z) x (BinaryCoproduct (LTE ('S 'Z)) x y) Source # inj2 :: forall (x :: k) (y :: k). Obj (LTE ('S 'Z)) x -> Obj (LTE ('S 'Z)) y -> LTE ('S 'Z) y (BinaryCoproduct (LTE ('S 'Z)) x y) Source # (\|\|\|) :: forall (x :: k) (a :: k) (y :: k). LTE ('S 'Z) x a -> LTE ('S 'Z) y a -> LTE ('S 'Z) (BinaryCoproduct (LTE ('S 'Z)) x y) a Source # (+++) :: forall (a1 :: k) (b1 :: k) (a2 :: k) (b2 :: k). LTE ('S 'Z) a1 b1 -> LTE ('S 'Z) a2 b2 -> LTE ('S 'Z) (BinaryCoproduct (LTE ('S 'Z)) a1 a2) (BinaryCoproduct (LTE ('S 'Z)) b1 b2) Source #
HasBinaryCoproducts Cat Source #	The coproduct of categories `:++:` is the binary coproduct in `Cat`.
Instance details Defined in Data.Category.Limit Associated Types type BinaryCoproduct Cat x y :: Kind k Source # Methods inj1 :: forall (x :: k) (y :: k). Obj Cat x -> Obj Cat y -> Cat x (BinaryCoproduct Cat x y) Source # inj2 :: forall (x :: k) (y :: k). Obj Cat x -> Obj Cat y -> Cat y (BinaryCoproduct Cat x y) Source # (\|\|\|) :: forall (x :: k) (a :: k) (y :: k). Cat x a -> Cat y a -> Cat (BinaryCoproduct Cat x y) a Source # (+++) :: forall (a1 :: k) (b1 :: k) (a2 :: k) (b2 :: k). Cat a1 b1 -> Cat a2 b2 -> Cat (BinaryCoproduct Cat a1 a2) (BinaryCoproduct Cat b1 b2) Source #

data CoproductFunctor (k :: Type -> Type -> Type) Source #

Constructors

CoproductFunctor

Instances

Instances details

HasBinaryCoproducts k => Functor (CoproductFunctor k) Source #	Binary coproduct as a bifunctor.
Instance details Defined in Data.Category.Limit Associated Types type Dom (CoproductFunctor k) :: Type -> Type -> Type Source # type Cod (CoproductFunctor k) :: Type -> Type -> Type Source # type (CoproductFunctor k) :% a Source # Methods (%) :: CoproductFunctor k -> Dom (CoproductFunctor k) a b -> Cod (CoproductFunctor k) (CoproductFunctor k :% a) (CoproductFunctor k :% b) Source #
(HasInitialObject k, HasBinaryCoproducts k) => SymmetricTensorProduct (CoproductFunctor k) Source #
Instance details Defined in Data.Category.Monoidal Methods swap :: Cod (CoproductFunctor k) ~ k0 => CoproductFunctor k -> Obj k0 a -> Obj k0 b -> k0 (CoproductFunctor k :% (a, b)) (CoproductFunctor k :% (b, a)) Source #
(HasInitialObject k, HasBinaryCoproducts k) => TensorProduct (CoproductFunctor k) Source #	If a category has all coproducts, then the coproduct functor makes it a monoidal category, with the initial object as unit.
Instance details Defined in Data.Category.Monoidal Associated Types type Unit (CoproductFunctor k) :: Kind (Cod f) Source # Methods unitObject :: CoproductFunctor k -> Obj (Cod (CoproductFunctor k)) (Unit (CoproductFunctor k)) Source # leftUnitor :: Cod (CoproductFunctor k) ~ k0 => CoproductFunctor k -> Obj k0 a -> k0 (CoproductFunctor k :% (Unit (CoproductFunctor k), a)) a Source # leftUnitorInv :: Cod (CoproductFunctor k) ~ k0 => CoproductFunctor k -> Obj k0 a -> k0 a (CoproductFunctor k :% (Unit (CoproductFunctor k), a)) Source # rightUnitor :: Cod (CoproductFunctor k) ~ k0 => CoproductFunctor k -> Obj k0 a -> k0 (CoproductFunctor k :% (a, Unit (CoproductFunctor k))) a Source # rightUnitorInv :: Cod (CoproductFunctor k) ~ k0 => CoproductFunctor k -> Obj k0 a -> k0 a (CoproductFunctor k :% (a, Unit (CoproductFunctor k))) Source # associator :: Cod (CoproductFunctor k) ~ k0 => CoproductFunctor k -> Obj k0 a -> Obj k0 b -> Obj k0 c -> k0 (CoproductFunctor k :% (CoproductFunctor k :% (a, b), c)) (CoproductFunctor k :% (a, CoproductFunctor k :% (b, c))) Source # associatorInv :: Cod (CoproductFunctor k) ~ k0 => CoproductFunctor k -> Obj k0 a -> Obj k0 b -> Obj k0 c -> k0 (CoproductFunctor k :% (a, CoproductFunctor k :% (b, c))) (CoproductFunctor k :% (CoproductFunctor k :% (a, b), c)) Source #
type Cod (CoproductFunctor k) Source #
Instance details Defined in Data.Category.Limit type Cod (CoproductFunctor k) = k
type Dom (CoproductFunctor k) Source #
Instance details Defined in Data.Category.Limit type Dom (CoproductFunctor k) = k :**: k
type Unit (CoproductFunctor k) Source #
Instance details Defined in Data.Category.Monoidal type Unit (CoproductFunctor k) = InitialObject k
type (CoproductFunctor k) :% (a, b) Source #
Instance details Defined in Data.Category.Limit type (CoproductFunctor k) :% (a, b) = BinaryCoproduct k a b

data p :+: q where Source #

Constructors

(:+:) :: (Functor p, Functor q, Dom p ~ Dom q, Cod p ~ k, Cod q ~ k, HasBinaryCoproducts k) => p -> q -> p :+: q

Instances

Instances details

(Category (Dom p), Category (Cod p)) => Functor (p :+: q) Source #	The coproduct of two functors, passing the same object to both functors and taking the coproduct of the results.
Instance details Defined in Data.Category.Limit Associated Types type Dom (p :+: q) :: Type -> Type -> Type Source # type Cod (p :+: q) :: Type -> Type -> Type Source # type (p :+: q) :% a Source # Methods (%) :: (p :+: q) -> Dom (p :+: q) a b -> Cod (p :+: q) ((p :+: q) :% a) ((p :+: q) :% b) Source #
type Cod (p :+: q) Source #
Instance details Defined in Data.Category.Limit type Cod (p :+: q) = Cod p
type Dom (p :+: q) Source #
Instance details Defined in Data.Category.Limit type Dom (p :+: q) = Dom p
type (p :+: q) :% a Source #
Instance details Defined in Data.Category.Limit type (p :+: q) :% a = BinaryCoproduct (Cod p) (p :% a) (q :% a)

coprodAdj :: HasBinaryCoproducts k => Adjunction k (k :**: k) (CoproductFunctor k) (DiagProd k) Source #

A specialisation of the colimit adjunction to coproducts.

data Either a b #

The Either type represents values with two possibilities: a value of type Either a b is either Left a or Right b.

The Either type is sometimes used to represent a value which is either correct or an error; by convention, the Left constructor is used to hold an error value and the Right constructor is used to hold a correct value (mnemonic: "right" also means "correct").

Examples

Expand

The type Either String Int is the type of values which can be either a String or an Int. The Left constructor can be used only on Strings, and the Right constructor can be used only on Ints:

>>> let s = Left "foo" :: Either String Int
>>> s
Left "foo"
>>> let n = Right 3 :: Either String Int
>>> n
Right 3
>>> :type s
s :: Either String Int
>>> :type n
n :: Either String Int

The fmap from our Functor instance will ignore Left values, but will apply the supplied function to values contained in a Right:

>>> let s = Left "foo" :: Either String Int
>>> let n = Right 3 :: Either String Int
>>> fmap (*2) s
Left "foo"
>>> fmap (*2) n
Right 6

The Monad instance for Either allows us to chain together multiple actions which may fail, and fail overall if any of the individual steps failed. First we'll write a function that can either parse an Int from a Char, or fail.

>>> import Data.Char ( digitToInt, isDigit )
>>> :{
    let parseEither :: Char -> Either String Int
        parseEither c
          | isDigit c = Right (digitToInt c)
          | otherwise = Left "parse error"
>>> :}

The following should work, since both '1' and '2' can be parsed as Ints.

>>> :{
    let parseMultiple :: Either String Int
        parseMultiple = do
          x <- parseEither '1'
          y <- parseEither '2'
          return (x + y)
>>> :}

>>> parseMultiple
Right 3

But the following should fail overall, since the first operation where we attempt to parse 'm' as an Int will fail:

>>> :{
    let parseMultiple :: Either String Int
        parseMultiple = do
          x <- parseEither 'm'
          y <- parseEither '2'
          return (x + y)
>>> :}

>>> parseMultiple
Left "parse error"

Constructors

Left a
Right b

Instances

Instances details

Foldable (Either a)	Since: base-4.7.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Either a m -> m # foldMap :: Monoid m => (a0 -> m) -> Either a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> Either a a0 -> m # foldr :: (a0 -> b -> b) -> b -> Either a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> Either a a0 -> b # foldl :: (b -> a0 -> b) -> b -> Either a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> Either a a0 -> b # foldr1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 # toList :: Either a a0 -> [a0] # null :: Either a a0 -> Bool # length :: Either a a0 -> Int # elem :: Eq a0 => a0 -> Either a a0 -> Bool # maximum :: Ord a0 => Either a a0 -> a0 # minimum :: Ord a0 => Either a a0 -> a0 # sum :: Num a0 => Either a a0 -> a0 # product :: Num a0 => Either a a0 -> a0 #
Traversable (Either a)	Since: base-4.7.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a0 -> f b) -> Either a a0 -> f (Either a b) # sequenceA :: Applicative f => Either a (f a0) -> f (Either a a0) # mapM :: Monad m => (a0 -> m b) -> Either a a0 -> m (Either a b) # sequence :: Monad m => Either a (m a0) -> m (Either a a0) #
Applicative (Either e)	Since: base-3.0
Instance details Defined in Data.Either Methods pure :: a -> Either e a # (<>) :: Either e (a -> b) -> Either e a -> Either e b # liftA2 :: (a -> b -> c) -> Either e a -> Either e b -> Either e c # (>) :: Either e a -> Either e b -> Either e b # (<*) :: Either e a -> Either e b -> Either e a #
Functor (Either a)	Since: base-3.0
Instance details Defined in Data.Either Methods fmap :: (a0 -> b) -> Either a a0 -> Either a b # (<$) :: a0 -> Either a b -> Either a a0 #
Monad (Either e)	Since: base-4.4.0.0
Instance details Defined in Data.Either Methods (>>=) :: Either e a -> (a -> Either e b) -> Either e b # (>>) :: Either e a -> Either e b -> Either e b # return :: a -> Either e a #
Semigroup (Either a b)	Since: base-4.9.0.0
Instance details Defined in Data.Either Methods (<>) :: Either a b -> Either a b -> Either a b # sconcat :: NonEmpty (Either a b) -> Either a b # stimes :: Integral b0 => b0 -> Either a b -> Either a b #
(Read a, Read b) => Read (Either a b)	Since: base-3.0
Instance details Defined in Data.Either Methods readsPrec :: Int -> ReadS (Either a b) # readList :: ReadS [Either a b] # readPrec :: ReadPrec (Either a b) # readListPrec :: ReadPrec [Either a b] #
(Show a, Show b) => Show (Either a b)	Since: base-3.0
Instance details Defined in Data.Either Methods showsPrec :: Int -> Either a b -> ShowS # show :: Either a b -> String # showList :: [Either a b] -> ShowS #
(Eq a, Eq b) => Eq (Either a b)	Since: base-2.1
Instance details Defined in Data.Either Methods (==) :: Either a b -> Either a b -> Bool # (/=) :: Either a b -> Either a b -> Bool #
(Ord a, Ord b) => Ord (Either a b)	Since: base-2.1
Instance details Defined in Data.Either Methods compare :: Either a b -> Either a b -> Ordering # (<) :: Either a b -> Either a b -> Bool # (<=) :: Either a b -> Either a b -> Bool # (>) :: Either a b -> Either a b -> Bool # (>=) :: Either a b -> Either a b -> Bool # max :: Either a b -> Either a b -> Either a b # min :: Either a b -> Either a b -> Either a b #