Control.Arrow.Constrained

Haskell's Arrows, going back to [Hughes 2000], combine multiple ideas from category theory:

• They expand upon cartesian categories, by offering ways to combine arrows between simple objects to composite ones working on tuples (i.e. products) thereof.
• They constitute a "profunctor" interface, allowing to "fmap" both covariantly over the second parameter, as well as contravariantly over the first. As in case of Control.Functor.Constrained, we wish the underlying category to fmap from not to be limited to Hask, so Arrow also has an extra parameter.

To facilitate these somewhat divergent needs, Arrow is split up in three classes. These do not even form an ordinary hierarchy, to allow categories to implement only one or the other aspect.

That's not the only significant difference of this module, compared to Control.Arrow:

• Kleisli arrows are not defined here, but in Control.Monad.Constrained. Monads are really a much more specific concept than category arrows.
• Some extra utilities are included that don't apparently have much to do with Arrow at all, but require the expanded cartesian-category tools and are therefore not in Control.Category.Constrained.

The Arrow type classes

type Arrow a k = (WellPointed a, EnhancedCat a k)

class Cartesian a => Morphism a where

Minimal complete definition

(***)

Methods

first :: (ObjectPair a b d, ObjectPair a c d) => a b c -> a (b, d) (c, d)

second :: (ObjectPair a d b, ObjectPair a d c) => a b c -> a (d, b) (d, c)

(***) :: (ObjectPair a b b', ObjectPair a c c') => a b c -> a b' c' -> a (b, b') (c, c') infixr 3

Instances

WellPointed k => Morphism (ReWellPointed k)

Methods

first :: (ObjectPair (ReWellPointed k) b d, ObjectPair (ReWellPointed k) c d) => ReWellPointed k b c -> ReWellPointed k (b, d) (c, d)

second :: (ObjectPair (ReWellPointed k) d b, ObjectPair (ReWellPointed k) d c) => ReWellPointed k b c -> ReWellPointed k (d, b) (d, c)

(***) :: (ObjectPair (ReWellPointed k) b b', ObjectPair (ReWellPointed k) c c') => ReWellPointed k b c -> ReWellPointed k b' c' -> ReWellPointed k (b, b') (c, c')

PreArrow k => Morphism (RePreArrow k)

Methods

first :: (ObjectPair (RePreArrow k) b d, ObjectPair (RePreArrow k) c d) => RePreArrow k b c -> RePreArrow k (b, d) (c, d)

second :: (ObjectPair (RePreArrow k) d b, ObjectPair (RePreArrow k) d c) => RePreArrow k b c -> RePreArrow k (d, b) (d, c)

(***) :: (ObjectPair (RePreArrow k) b b', ObjectPair (RePreArrow k) c c') => RePreArrow k b c -> RePreArrow k b' c' -> RePreArrow k (b, b') (c, c')

Morphism k => Morphism (ReMorphism k)

Methods

first :: (ObjectPair (ReMorphism k) b d, ObjectPair (ReMorphism k) c d) => ReMorphism k b c -> ReMorphism k (b, d) (c, d)

second :: (ObjectPair (ReMorphism k) d b, ObjectPair (ReMorphism k) d c) => ReMorphism k b c -> ReMorphism k (d, b) (d, c)

(***) :: (ObjectPair (ReMorphism k) b b', ObjectPair (ReMorphism k) c c') => ReMorphism k b c -> ReMorphism k b' c' -> ReMorphism k (b, b') (c, c')

Morphism ((->) LiftedRep LiftedRep)

Methods

first :: (ObjectPair (LiftedRep -> LiftedRep) b d, ObjectPair (LiftedRep -> LiftedRep) c d) => (LiftedRep -> LiftedRep) b c -> (LiftedRep -> LiftedRep) (b, d) (c, d)

second :: (ObjectPair (LiftedRep -> LiftedRep) d b, ObjectPair (LiftedRep -> LiftedRep) d c) => (LiftedRep -> LiftedRep) b c -> (LiftedRep -> LiftedRep) (d, b) (d, c)

(***) :: (ObjectPair (LiftedRep -> LiftedRep) b b', ObjectPair (LiftedRep -> LiftedRep) c c') => (LiftedRep -> LiftedRep) b c -> (LiftedRep -> LiftedRep) b' c' -> (LiftedRep -> LiftedRep) (b, b') (c, c')

(Morphism a, o (UnitObject a)) => Morphism (ConstrainedCategory a o)

Methods

first :: (ObjectPair (ConstrainedCategory a o) b d, ObjectPair (ConstrainedCategory a o) c d) => ConstrainedCategory a o b c -> ConstrainedCategory a o (b, d) (c, d)

second :: (ObjectPair (ConstrainedCategory a o) d b, ObjectPair (ConstrainedCategory a o) d c) => ConstrainedCategory a o b c -> ConstrainedCategory a o (d, b) (d, c)

(***) :: (ObjectPair (ConstrainedCategory a o) b b', ObjectPair (ConstrainedCategory a o) c c') => ConstrainedCategory a o b c -> ConstrainedCategory a o b' c' -> ConstrainedCategory a o (b, b') (c, c')

(Monad m a, Morphism a, Curry a) => Morphism (Kleisli m a)

Methods

first :: (ObjectPair (Kleisli m a) b d, ObjectPair (Kleisli m a) c d) => Kleisli m a b c -> Kleisli m a (b, d) (c, d)

second :: (ObjectPair (Kleisli m a) d b, ObjectPair (Kleisli m a) d c) => Kleisli m a b c -> Kleisli m a (d, b) (d, c)

(***) :: (ObjectPair (Kleisli m a) b b', ObjectPair (Kleisli m a) c c') => Kleisli m a b c -> Kleisli m a b' c' -> Kleisli m a (b, b') (c, c')

class Morphism a => PreArrow a where

Unlike first, second, *** and arr, the fanout operation &&& has an intrinsic notion of "direction": it is basically equivalent to precomposing the result of *** with a b -> (b,b), but that is only available for arrows that generalise ordinary functions, in their native direction. ((b,b) ->b is specific to semigroups.) It is for this reason the only constituent class of Arrow that actually has "arrow" in its name.

In terms of category theory, this "direction" reflects the distinction between initial- and terminal objects. The latter are more interesting, basically what UnitObject is useful for. It gives rise to the tuple selector morphisms as well.

Minimal complete definition

(&&&), terminal, fst, snd

Methods

(&&&) :: (Object a b, ObjectPair a c c') => a b c -> a b c' -> a b (c, c') infixr 3

terminal :: Object a b => a b (UnitObject a)

fst :: ObjectPair a x y => a (x, y) x

snd :: ObjectPair a x y => a (x, y) y

Instances

WellPointed k => PreArrow (ReWellPointed k)

Methods

(&&&) :: (Object (ReWellPointed k) b, ObjectPair (ReWellPointed k) c c') => ReWellPointed k b c -> ReWellPointed k b c' -> ReWellPointed k b (c, c')

terminal :: Object (ReWellPointed k) b => ReWellPointed k b (UnitObject (ReWellPointed k))

fst :: ObjectPair (ReWellPointed k) x y => ReWellPointed k (x, y) x

snd :: ObjectPair (ReWellPointed k) x y => ReWellPointed k (x, y) y

PreArrow k => PreArrow (RePreArrow k)

Methods

(&&&) :: (Object (RePreArrow k) b, ObjectPair (RePreArrow k) c c') => RePreArrow k b c -> RePreArrow k b c' -> RePreArrow k b (c, c')

terminal :: Object (RePreArrow k) b => RePreArrow k b (UnitObject (RePreArrow k))

fst :: ObjectPair (RePreArrow k) x y => RePreArrow k (x, y) x

snd :: ObjectPair (RePreArrow k) x y => RePreArrow k (x, y) y

PreArrow ((->) LiftedRep LiftedRep)

Methods

(&&&) :: (Object (LiftedRep -> LiftedRep) b, ObjectPair (LiftedRep -> LiftedRep) c c') => (LiftedRep -> LiftedRep) b c -> (LiftedRep -> LiftedRep) b c' -> (LiftedRep -> LiftedRep) b (c, c')

terminal :: Object (LiftedRep -> LiftedRep) b => (LiftedRep -> LiftedRep) b (UnitObject (LiftedRep -> LiftedRep))

fst :: ObjectPair (LiftedRep -> LiftedRep) x y => (LiftedRep -> LiftedRep) (x, y) x

snd :: ObjectPair (LiftedRep -> LiftedRep) x y => (LiftedRep -> LiftedRep) (x, y) y

(PreArrow a, o (UnitObject a)) => PreArrow (ConstrainedCategory a o)

Methods

(&&&) :: (Object (ConstrainedCategory a o) b, ObjectPair (ConstrainedCategory a o) c c') => ConstrainedCategory a o b c -> ConstrainedCategory a o b c' -> ConstrainedCategory a o b (c, c')

terminal :: Object (ConstrainedCategory a o) b => ConstrainedCategory a o b (UnitObject (ConstrainedCategory a o))

fst :: ObjectPair (ConstrainedCategory a o) x y => ConstrainedCategory a o (x, y) x

snd :: ObjectPair (ConstrainedCategory a o) x y => ConstrainedCategory a o (x, y) y

(Monad m a, PreArrow a, Curry a) => PreArrow (Kleisli m a)

Methods

(&&&) :: (Object (Kleisli m a) b, ObjectPair (Kleisli m a) c c') => Kleisli m a b c -> Kleisli m a b c' -> Kleisli m a b (c, c')

terminal :: Object (Kleisli m a) b => Kleisli m a b (UnitObject (Kleisli m a))

fst :: ObjectPair (Kleisli m a) x y => Kleisli m a (x, y) x

snd :: ObjectPair (Kleisli m a) x y => Kleisli m a (x, y) y

class (PreArrow a, ObjectPoint a (UnitObject a)) => WellPointed a where

WellPointed expresses the relation between your category's objects and the values of the Haskell data types (which is, after all, what objects are in this library). Specifically, this class allows you to "point" on specific objects, thus making out a value of that type as a point of the object.

Perhaps easier than thinking about what that's supposed to mean is noting this class contains const. Thus WellPointed is almost the traditional Arrow: it lets you express all the natural transformations and inject constant values, only you can't just promote arbitrary functions to arrows of the category.

Unlike with Morphism and PreArrow, a literal dual of WellPointed does not seem useful.

Minimal complete definition

unit, (globalElement | const)

Associated Types

type PointObject a x :: Constraint

Methods

globalElement :: ObjectPoint a x => x -> a (UnitObject a) x

unit :: CatTagged a (UnitObject a)

const :: (Object a b, ObjectPoint a x) => x -> a b x

Instances

WellPointed k => WellPointed (ReWellPointed k)

Associated Types

type PointObject (ReWellPointed k :: * -> * -> *) x :: Constraint

Methods

globalElement :: ObjectPoint (ReWellPointed k) x => x -> ReWellPointed k (UnitObject (ReWellPointed k)) x

unit :: CatTagged (ReWellPointed k) (UnitObject (ReWellPointed k))

const :: (Object (ReWellPointed k) b, ObjectPoint (ReWellPointed k) x) => x -> ReWellPointed k b x

WellPointed ((->) LiftedRep LiftedRep)

Associated Types

type PointObject (LiftedRep -> LiftedRep :: * -> * -> *) x :: Constraint

Methods

globalElement :: ObjectPoint (LiftedRep -> LiftedRep) x => x -> (LiftedRep -> LiftedRep) (UnitObject (LiftedRep -> LiftedRep)) x

unit :: CatTagged (LiftedRep -> LiftedRep) (UnitObject (LiftedRep -> LiftedRep))

const :: (Object (LiftedRep -> LiftedRep) b, ObjectPoint (LiftedRep -> LiftedRep) x) => x -> (LiftedRep -> LiftedRep) b x

(WellPointed a, o (UnitObject a)) => WellPointed (ConstrainedCategory a o)

Associated Types

type PointObject (ConstrainedCategory a o :: * -> * -> *) x :: Constraint

Methods

globalElement :: ObjectPoint (ConstrainedCategory a o) x => x -> ConstrainedCategory a o (UnitObject (ConstrainedCategory a o)) x

unit :: CatTagged (ConstrainedCategory a o) (UnitObject (ConstrainedCategory a o))

const :: (Object (ConstrainedCategory a o) b, ObjectPoint (ConstrainedCategory a o) x) => x -> ConstrainedCategory a o b x

(Monad m a, WellPointed a, ObjectPoint a (m (UnitObject a))) => WellPointed (Kleisli m a)

Associated Types

type PointObject (Kleisli m a :: * -> * -> *) x :: Constraint

Methods

globalElement :: ObjectPoint (Kleisli m a) x => x -> Kleisli m a (UnitObject (Kleisli m a)) x

unit :: CatTagged (Kleisli m a) (UnitObject (Kleisli m a))

const :: (Object (Kleisli m a) b, ObjectPoint (Kleisli m a) x) => x -> Kleisli m a b x

type ObjectPoint k a = (Object k a, PointObject k a)

class (Category a, Category k) => EnhancedCat a k where

EnhancedCat a k means that the subcategory of k whose objects are also objects of a is a subcategory of a. This works like EnhancedCat', but does not require Object k ⊆ Object a.

Minimal complete definition

arr

Methods

arr :: (Object k b, Object k c, Object a b, Object a c) => k b c -> a b c

Instances

Category k => EnhancedCat k k

Methods

arr :: (Object k b, Object k c, Object k b, Object k c) => k b c -> k b c

WellPointed k => EnhancedCat (ReWellPointed k) k

Methods

arr :: (Object k b, Object k c, Object (ReWellPointed k) b, Object (ReWellPointed k) c) => k b c -> ReWellPointed k b c

PreArrow k => EnhancedCat (RePreArrow k) k

Methods

arr :: (Object k b, Object k c, Object (RePreArrow k) b, Object (RePreArrow k) c) => k b c -> RePreArrow k b c

Morphism k => EnhancedCat (ReMorphism k) k

Methods

arr :: (Object k b, Object k c, Object (ReMorphism k) b, Object (ReMorphism k) c) => k b c -> ReMorphism k b c

Cartesian k => EnhancedCat (ReCartesian k) k

Methods

arr :: (Object k b, Object k c, Object (ReCartesian k) b, Object (ReCartesian k) c) => k b c -> ReCartesian k b c

Category k => EnhancedCat (ReCategory k) k

Methods

arr :: (Object k b, Object k c, Object (ReCategory k) b, Object (ReCategory k) c) => k b c -> ReCategory k b c

EnhancedCat (Coercion *) (Discrete *)

Methods

arr :: (Object (Discrete *) b, Object (Discrete *) c, Object (Coercion *) b, Object (Coercion *) c) => Discrete * b c -> Coercion * b c

EnhancedCat (Discrete *) f => EnhancedCat (Discrete *) (ConstrainedCategory f o)

Methods

arr :: (Object (ConstrainedCategory f o) b, Object (ConstrainedCategory f o) c, Object (Discrete *) b, Object (Discrete *) c) => ConstrainedCategory f o b c -> Discrete * b c

(EnhancedCat a k, o (UnitObject a)) => EnhancedCat (ConstrainedCategory a o) k

Methods

arr :: (Object k b, Object k c, Object (ConstrainedCategory a o) b, Object (ConstrainedCategory a o) c) => k b c -> ConstrainedCategory a o b c

(Monad m a, Arrow a q, Cartesian a) => EnhancedCat (Kleisli m a) q

Methods

arr :: (Object q b, Object q c, Object (Kleisli m a) b, Object (Kleisli m a) c) => q b c -> Kleisli m a b c

EnhancedCat ((->) LiftedRep LiftedRep) (Coercion *)

Methods

arr :: (Object (Coercion *) b, Object (Coercion *) c, Object (LiftedRep -> LiftedRep) b, Object (LiftedRep -> LiftedRep) c) => Coercion * b c -> (LiftedRep -> LiftedRep) b c

EnhancedCat ((->) LiftedRep LiftedRep) (Discrete *)

Methods

arr :: (Object (Discrete *) b, Object (Discrete *) c, Object (LiftedRep -> LiftedRep) b, Object (LiftedRep -> LiftedRep) c) => Discrete * b c -> (LiftedRep -> LiftedRep) b c

Category f => EnhancedCat (ConstrainedCategory f o) (Discrete *)

Methods

arr :: (Object (Discrete *) b, Object (Discrete *) c, Object (ConstrainedCategory f o) b, Object (ConstrainedCategory f o) c) => Discrete * b c -> ConstrainedCategory f o b c

Function f => EnhancedCat ((->) LiftedRep LiftedRep) (ConstrainedCategory f o)

Methods

arr :: (Object (ConstrainedCategory f o) b, Object (ConstrainedCategory f o) c, Object (LiftedRep -> LiftedRep) b, Object (LiftedRep -> LiftedRep) c) => ConstrainedCategory f o b c -> (LiftedRep -> LiftedRep) b c

Dual / "choice" arrows

type ArrowChoice a k = (WellPointed a, PreArrChoice a, EnhancedCat a k)

class CoCartesian a => MorphChoice a where

Dual to Morphism, dealing with sums instead of products.

Minimal complete definition

(+++)

Methods

left :: (ObjectSum a b d, ObjectSum a c d) => a b c -> a (b + d) (c + d)

right :: (ObjectSum a d b, ObjectSum a d c) => a b c -> a (d + b) (d + c)

(+++) :: (ObjectSum a b b', ObjectSum a c c') => a b c -> a b' c' -> a (b + b') (c + c')

Instances

MorphChoice ((->) LiftedRep LiftedRep)

Methods

left :: (ObjectSum (LiftedRep -> LiftedRep) b d, ObjectSum (LiftedRep -> LiftedRep) c d) => (LiftedRep -> LiftedRep) b c -> (LiftedRep -> LiftedRep) (b + d) (c + d)

right :: (ObjectSum (LiftedRep -> LiftedRep) d b, ObjectSum (LiftedRep -> LiftedRep) d c) => (LiftedRep -> LiftedRep) b c -> (LiftedRep -> LiftedRep) (d + b) (d + c)

(+++) :: (ObjectSum (LiftedRep -> LiftedRep) b b', ObjectSum (LiftedRep -> LiftedRep) c c') => (LiftedRep -> LiftedRep) b c -> (LiftedRep -> LiftedRep) b' c' -> (LiftedRep -> LiftedRep) (b + b') (c + c')

(MorphChoice k, o (ZeroObject k)) => MorphChoice (ConstrainedCategory k o)

Methods

left :: (ObjectSum (ConstrainedCategory k o) b d, ObjectSum (ConstrainedCategory k o) c d) => ConstrainedCategory k o b c -> ConstrainedCategory k o (b + d) (c + d)

right :: (ObjectSum (ConstrainedCategory k o) d b, ObjectSum (ConstrainedCategory k o) d c) => ConstrainedCategory k o b c -> ConstrainedCategory k o (d + b) (d + c)

(+++) :: (ObjectSum (ConstrainedCategory k o) b b', ObjectSum (ConstrainedCategory k o) c c') => ConstrainedCategory k o b c -> ConstrainedCategory k o b' c' -> ConstrainedCategory k o (b + b') (c + c')

(Monad m k, Arrow k ((->) LiftedRep LiftedRep), Function k, PreArrChoice k, Object k (m (ZeroObject k)), Object k (m (m (ZeroObject k)))) => MorphChoice (Kleisli m k)

Hask-Kleislis inherit more or less trivially ArrowChoice; however this does not generalise greatly well to non-function categories.

Methods

left :: (ObjectSum (Kleisli m k) b d, ObjectSum (Kleisli m k) c d) => Kleisli m k b c -> Kleisli m k (b + d) (c + d)

right :: (ObjectSum (Kleisli m k) d b, ObjectSum (Kleisli m k) d c) => Kleisli m k b c -> Kleisli m k (d + b) (d + c)

(+++) :: (ObjectSum (Kleisli m k) b b', ObjectSum (Kleisli m k) c c') => Kleisli m k b c -> Kleisli m k b' c' -> Kleisli m k (b + b') (c + c')

class MorphChoice k => PreArrChoice k where

Dual to PreArrow, this class deals with the vacuous initial (zero) objects, but also more usefully with choices / sums. This represents the most part of ArrowChoice.

Minimal complete definition

(|||), initial, coFst, coSnd

Methods

(|||) :: (ObjectSum k b b', Object k c) => k b c -> k b' c -> k (b + b') c infixr 2

initial :: Object k b => k (ZeroObject k) b

This is basically absurd.

coFst :: ObjectSum k a b => k a (a + b)

Perhaps lft and rgt would be more consequent names, but likely more confusing as well.

coSnd :: ObjectSum k a b => k b (a + b)

Instances

PreArrChoice ((->) LiftedRep LiftedRep)

Methods

(|||) :: (ObjectSum (LiftedRep -> LiftedRep) b b', Object (LiftedRep -> LiftedRep) c) => (LiftedRep -> LiftedRep) b c -> (LiftedRep -> LiftedRep) b' c -> (LiftedRep -> LiftedRep) (b + b') c

initial :: Object (LiftedRep -> LiftedRep) b => (LiftedRep -> LiftedRep) (ZeroObject (LiftedRep -> LiftedRep)) b

coFst :: ObjectSum (LiftedRep -> LiftedRep) a b => (LiftedRep -> LiftedRep) a (a + b)

coSnd :: ObjectSum (LiftedRep -> LiftedRep) a b => (LiftedRep -> LiftedRep) b (a + b)

(PreArrChoice k, o (ZeroObject k)) => PreArrChoice (ConstrainedCategory k o)

Methods

(|||) :: (ObjectSum (ConstrainedCategory k o) b b', Object (ConstrainedCategory k o) c) => ConstrainedCategory k o b c -> ConstrainedCategory k o b' c -> ConstrainedCategory k o (b + b') c

initial :: Object (ConstrainedCategory k o) b => ConstrainedCategory k o (ZeroObject (ConstrainedCategory k o)) b

coFst :: ObjectSum (ConstrainedCategory k o) a b => ConstrainedCategory k o a (a + b)

coSnd :: ObjectSum (ConstrainedCategory k o) a b => ConstrainedCategory k o b (a + b)

(Monad m k, Arrow k ((->) LiftedRep LiftedRep), Function k, PreArrChoice k, Object k (m (ZeroObject k)), Object k (m (m (ZeroObject k)))) => PreArrChoice (Kleisli m k)

Methods

(|||) :: (ObjectSum (Kleisli m k) b b', Object (Kleisli m k) c) => Kleisli m k b c -> Kleisli m k b' c -> Kleisli m k (b + b') c

initial :: Object (Kleisli m k) b => Kleisli m k (ZeroObject (Kleisli m k)) b

coFst :: ObjectSum (Kleisli m k) a b => Kleisli m k a (a + b)

coSnd :: ObjectSum (Kleisli m k) a b => Kleisli m k b (a + b)

Distributive law between sum- and product objects

class (PreArrow k, PreArrChoice k) => SPDistribute k where

Like in arithmetics, the distributive law a ⋅ (b + c) ≈ (a ⋅ b) + (a ⋅ c) holds for Haskell types – in the usual isomorphism sense. But like many such isomorphisms that are trivial to inline in Hask, this is not necessarily the case for general categories.

Minimal complete definition

distribute, unDistribute, boolAsSwitch, boolFromSwitch

Methods

distribute :: (ObjectSum k (a, b) (a, c), ObjectPair k a (b + c), ObjectSum k b c, PairObjects k a b, PairObjects k a c) => k (a, b + c) ((a, b) + (a, c))

unDistribute :: (ObjectSum k (a, b) (a, c), ObjectPair k a (b + c), ObjectSum k b c, PairObjects k a b, PairObjects k a c) => k ((a, b) + (a, c)) (a, b + c)

boolAsSwitch :: (ObjectSum k a a, ObjectPair k Bool a) => k (Bool, a) (a + a)

boolFromSwitch :: (ObjectSum k a a, ObjectPair k Bool a) => k (a + a) (Bool, a)

Instances

SPDistribute ((->) LiftedRep LiftedRep)

Methods

distribute :: (ObjectSum (LiftedRep -> LiftedRep) (a, b) (a, c), ObjectPair (LiftedRep -> LiftedRep) a (b + c), ObjectSum (LiftedRep -> LiftedRep) b c, PairObjects (LiftedRep -> LiftedRep) a b, PairObjects (LiftedRep -> LiftedRep) a c) => (LiftedRep -> LiftedRep) (a, b + c) ((a, b) + (a, c))

unDistribute :: (ObjectSum (LiftedRep -> LiftedRep) (a, b) (a, c), ObjectPair (LiftedRep -> LiftedRep) a (b + c), ObjectSum (LiftedRep -> LiftedRep) b c, PairObjects (LiftedRep -> LiftedRep) a b, PairObjects (LiftedRep -> LiftedRep) a c) => (LiftedRep -> LiftedRep) ((a, b) + (a, c)) (a, b + c)

boolAsSwitch :: (ObjectSum (LiftedRep -> LiftedRep) a a, ObjectPair (LiftedRep -> LiftedRep) Bool a) => (LiftedRep -> LiftedRep) (Bool, a) (a + a)

boolFromSwitch :: (ObjectSum (LiftedRep -> LiftedRep) a a, ObjectPair (LiftedRep -> LiftedRep) Bool a) => (LiftedRep -> LiftedRep) (a + a) (Bool, a)

(SPDistribute k, o (ZeroObject k), o (UnitObject k)) => SPDistribute (ConstrainedCategory k o)

Methods

distribute :: (ObjectSum (ConstrainedCategory k o) (a, b) (a, c), ObjectPair (ConstrainedCategory k o) a (b + c), ObjectSum (ConstrainedCategory k o) b c, PairObjects (ConstrainedCategory k o) a b, PairObjects (ConstrainedCategory k o) a c) => ConstrainedCategory k o (a, b + c) ((a, b) + (a, c))

unDistribute :: (ObjectSum (ConstrainedCategory k o) (a, b) (a, c), ObjectPair (ConstrainedCategory k o) a (b + c), ObjectSum (ConstrainedCategory k o) b c, PairObjects (ConstrainedCategory k o) a b, PairObjects (ConstrainedCategory k o) a c) => ConstrainedCategory k o ((a, b) + (a, c)) (a, b + c)

boolAsSwitch :: (ObjectSum (ConstrainedCategory k o) a a, ObjectPair (ConstrainedCategory k o) Bool a) => ConstrainedCategory k o (Bool, a) (a + a)

boolFromSwitch :: (ObjectSum (ConstrainedCategory k o) a a, ObjectPair (ConstrainedCategory k o) Bool a) => ConstrainedCategory k o (a + a) (Bool, a)

(SPDistribute k, Monad m k, PreArrow (Kleisli m k), PreArrChoice (Kleisli m k)) => SPDistribute (Kleisli m k)

Methods

distribute :: (ObjectSum (Kleisli m k) (a, b) (a, c), ObjectPair (Kleisli m k) a (b + c), ObjectSum (Kleisli m k) b c, PairObjects (Kleisli m k) a b, PairObjects (Kleisli m k) a c) => Kleisli m k (a, b + c) ((a, b) + (a, c))

unDistribute :: (ObjectSum (Kleisli m k) (a, b) (a, c), ObjectPair (Kleisli m k) a (b + c), ObjectSum (Kleisli m k) b c, PairObjects (Kleisli m k) a b, PairObjects (Kleisli m k) a c) => Kleisli m k ((a, b) + (a, c)) (a, b + c)

boolAsSwitch :: (ObjectSum (Kleisli m k) a a, ObjectPair (Kleisli m k) Bool a) => Kleisli m k (Bool, a) (a + a)

boolFromSwitch :: (ObjectSum (Kleisli m k) a a, ObjectPair (Kleisli m k) Bool a) => Kleisli m k (a + a) (Bool, a)

Function-like categories

type Function f = EnhancedCat (->) f

Many categories have as morphisms essentially functions with extra properties: group homomorphisms, linear maps, continuous functions...

It makes sense to generalise the notion of function application to these morphisms; we can't do that for the simple juxtaposition writing f x, but it is possible for the function-application operator $.

This is particularly useful for ConstrainedCategory versions of Hask, where after all the morphisms are nothing but functions.

($) :: (Function f, Object f a, Object f b) => f a b -> a -> b infixr 0

Alternative composition notation

(>>>) :: (Category k, Object k a, Object k b, Object k c) => k a b -> k b c -> k a c infixr 1

(<<<) :: (Category k, Object k a, Object k b, Object k c) => k b c -> k a b -> k a c infixr 1

Proxies for cartesian categories

class (Morphism k, HasAgent k) => CartesianAgent k where

Minimal complete definition

alg1to2, alg2to1, alg2to2

Methods

alg1to2 :: (Object k a, ObjectPair k b c) => (forall q. Object k q => AgentVal k q a -> (AgentVal k q b, AgentVal k q c)) -> k a (b, c)

alg2to1 :: (ObjectPair k a b, Object k c) => (forall q. Object k q => AgentVal k q a -> AgentVal k q b -> AgentVal k q c) -> k (a, b) c

alg2to2 :: (ObjectPair k a b, ObjectPair k c d) => (forall q. Object k q => AgentVal k q a -> AgentVal k q b -> (AgentVal k q c, AgentVal k q d)) -> k (a, b) (c, d)

genericAgentCombine :: (HasAgent k, PreArrow k, Object k a, ObjectPair k b c, Object k d) => k (b, c) d -> GenericAgent k a b -> GenericAgent k a c -> GenericAgent k a d

genericUnit :: (PreArrow k, HasAgent k, Object k a) => GenericAgent k a (UnitObject k)

genericAlg1to2 :: (PreArrow k, u ~ UnitObject k, Object k a, ObjectPair k b c) => (forall q. Object k q => GenericAgent k q a -> (GenericAgent k q b, GenericAgent k q c)) -> k a (b, c)

genericAlg2to1 :: (PreArrow k, u ~ UnitObject k, ObjectPair k a u, ObjectPair k a b, ObjectPair k b u, ObjectPair k b a) => (forall q. Object k q => GenericAgent k q a -> GenericAgent k q b -> GenericAgent k q c) -> k (a, b) c

genericAlg2to2 :: (PreArrow k, u ~ UnitObject k, ObjectPair k a u, ObjectPair k a b, ObjectPair k c d, ObjectPair k b u, ObjectPair k b a) => (forall q. Object k q => GenericAgent k q a -> GenericAgent k q b -> (GenericAgent k q c, GenericAgent k q d)) -> k (a, b) (c, d)

class (HasAgent k, AgentVal k a x ~ p a x) => PointAgent p k a x | p -> k where

Minimal complete definition

point

Methods

point :: (Object k a, Object k x) => x -> p a x

genericPoint :: (WellPointed k, Object k a, ObjectPoint k x) => x -> GenericAgent k a x

Misc utility

Conditionals

choose

Arguments

:: (Arrow f (->), Function f, Object f Bool, Object f a)

=> f (UnitObject f) a

"False" value

-> f (UnitObject f) a

"True" value

-> f Bool a

Basically ifThenElse with inverted argument order, and "morphismised" arguments.

ifThenElse :: (EnhancedCat f (->), Function f, Object f Bool, Object f a, Object f (f a a), Object f (f a (f a a))) => Bool `f` (a `f` (a `f` a))

Coercions

follow :: (EnhancedCat k Coercion, Coercible a b, Object k a, Object k b) => p a b -> k a b

Imitate a type change in a different category. This is usually possible for type changes that are no-ops at runtime, in particular for newtype wrappers.

flout :: (EnhancedCat k Coercion, Coercible b a, Object k a, Object k b) => p a b -> k b a

The opposite of follow.

pretend :: (EnhancedCat k Coercion, Object k a, Object k b) => Coercion a b -> k a a -> k b b

Wrap an endomorphism in inverse coercions, to have it work on any type that's representationally equivalent to the one in the morphism's signature. This is a specialised version of pretendLike.

swallow :: (EnhancedCat k Coercion, Object k a, Object k b) => Coercion b a -> k a a -> k b b

Equivalent to pretend . sym.

pretendLike :: (EnhancedCat k Coercion, Coercible b a, Coercible c d, Object k a, Object k b, Object k c, Object k d) => p c d -> k a c -> k b d

This works much like over: wrap a morphism in any coercions required so the result types match. This will often be too polymorphic for the type checker; consider using the more explicit follow and flout.

swallowLike :: (EnhancedCat k Coercion, Coercible b a, Coercible c d, Object k a, Object k b, Object k c, Object k d) => p b a -> k a c -> k b d

Generalised coercion analogue of under.

Orphan instances

(SPDistribute k, ObjectSum k a a, ObjectPair k Bool a) => Isomorphic k ((+) a a) (Bool, a)

Methods

iso :: k (a + a) (Bool, a)

(SPDistribute k, ObjectSum k a a, ObjectPair k Bool a) => Isomorphic k (Bool, a) ((+) a a)

Methods

iso :: k (Bool, a) (a + a)

(SPDistribute k, ObjectSum k (a, b) (a, c), ObjectPair k a ((+) b c), ObjectSum k b c, PairObjects k a b, PairObjects k a c) => Isomorphic k ((+) (a, b) (a, c)) (a, (+) b c)

Methods

iso :: k ((a, b) + (a, c)) (a, b + c)

(SPDistribute k, ObjectSum k (a, b) (a, c), ObjectPair k a ((+) b c), ObjectSum k b c, PairObjects k a b, PairObjects k a c) => Isomorphic k (a, (+) b c) ((+) (a, b) (a, c))

Methods

iso :: k (a, b + c) ((a, b) + (a, c))