constrained-categories-0.3.1.1: Constrained clones of the category-theory type classes, using ConstraintKinds.

Copyright(c) 2013 Justus Sagemüller
LicenseGPL v3 (see COPYING)
Maintainer(@) sagemueller $ geo.uni-koeln.de
Safe HaskellTrustworthy
LanguageHaskell2010

Control.Monad.Constrained

Contents

Description

 
Synopsis

Documentation

Monads

class (Applicative m k k, Object k (m (UnitObject k)), Object k (m (m (UnitObject k)))) => Monad m k where Source #

Minimal complete definition

join

Methods

join :: (Object k a, Object k (m a), Object k (m (m a))) => m (m a) `k` m a Source #

Instances
(Applicative m, Monad m) => Monad m ((->) :: * -> * -> *) Source # 
Instance details

Defined in Control.Monad.Constrained

Methods

join :: (Object (->) a, Object (->) (m a), Object (->) (m (m a))) => m (m a) -> m a Source #

return :: Monad m (->) => a -> m a Source #

This is monomorphic in the category Hask, thus exactly the same as return from the standard prelude. This allows writing expressions like return $ case x of ..., which would always be ambiguous with the more general signature Monad m k => k a (m a).

Use pure when you want to "return" in categories other than (->); this always works since Applicative is a superclass of Monad.

(>>=) :: (Function f, Monad m f, Object f a, Object f b, Object f (m a), Object f (m b), Object f (m (m b))) => m a -> f a (m b) -> m b infixl 1 Source #

(=<<) :: (Monad m k, Object k a, Object k b, Object k (m a), Object k (m b), Object k (m (m b))) => k a (m b) -> k (m a) (m b) infixr 1 Source #

(>>) :: (WellPointed k, Monad m k, ObjectPair k b (UnitObject k), ObjectPair k (m b) (UnitObject k), ObjectPair k (UnitObject k) (m b), ObjectPair k b a, ObjectPair k a b, Object k (m (a, b)), ObjectPair k (m a) (m b), ObjectPoint k (m a)) => m a -> k (m b) (m b) infixl 1 Source #

(<<) :: (Monad m k, WellPointed k, Object k a, Object k b, Object k (m a), ObjectPoint k (m b), Object k (m (m b))) => m b -> k (m a) (m b) infixr 1 Source #

Kleisli arrows

(>=>) :: (Monad m k, Object k a, Object k b, Object k c, Object k (m b), Object k (m c), Object k (m (m c))) => (a `k` m b) -> (b `k` m c) -> a `k` m c infixr 1 Source #

(<=<) :: (Monad m k, Object k a, Object k b, Object k c, Object k (m b), Object k (m c), Object k (m (m c))) => (b `k` m c) -> (a `k` m b) -> a `k` m c infixr 1 Source #

newtype Kleisli m k a b Source #

Constructors

Kleisli 

Fields

Instances
(Monad m a, Arrow a ((->) :: * -> * -> *), Function a) => Curry (Kleisli m a) Source # 
Instance details

Defined in Control.Monad.Constrained

Associated Types

type MorphObjects (Kleisli m a) b c :: Constraint Source #

Methods

uncurry :: (ObjectPair (Kleisli m a) a0 b, ObjectMorphism (Kleisli m a) b c) => Kleisli m a a0 (Kleisli m a b c) -> Kleisli m a (a0, b) c Source #

curry :: (ObjectPair (Kleisli m a) a0 b, ObjectMorphism (Kleisli m a) b c) => Kleisli m a (a0, b) c -> Kleisli m a a0 (Kleisli m a b c) Source #

apply :: (ObjectMorphism (Kleisli m a) a0 b, ObjectPair (Kleisli m a) (Kleisli m a a0 b) a0) => Kleisli m a (Kleisli m a a0 b, a0) b Source #

(Monad m k, CoCartesian k, Object k (m (ZeroObject k)), Object k (m (m (ZeroObject k)))) => CoCartesian (Kleisli m k) Source # 
Instance details

Defined in Control.Monad.Constrained

Associated Types

type SumObjects (Kleisli m k) a b :: Constraint Source #

type ZeroObject (Kleisli m k) :: * Source #

Methods

coSwap :: (ObjectSum (Kleisli m k) a b, ObjectSum (Kleisli m k) b a) => Kleisli m k (a + b) (b + a) Source #

attachZero :: (Object (Kleisli m k) a, z ~ ZeroObject (Kleisli m k), ObjectSum (Kleisli m k) a z) => Kleisli m k a (a + z) Source #

detachZero :: (Object (Kleisli m k) a, z ~ ZeroObject (Kleisli m k), ObjectSum (Kleisli m k) a z) => Kleisli m k (a + z) a Source #

coRegroup :: (Object (Kleisli m k) a, Object (Kleisli m k) c, ObjectSum (Kleisli m k) a b, ObjectSum (Kleisli m k) b c, ObjectSum (Kleisli m k) a (b + c), ObjectSum (Kleisli m k) (a + b) c) => Kleisli m k (a + (b + c)) ((a + b) + c) Source #

coRegroup' :: (Object (Kleisli m k) a, Object (Kleisli m k) c, ObjectSum (Kleisli m k) a b, ObjectSum (Kleisli m k) b c, ObjectSum (Kleisli m k) a (b + c), ObjectSum (Kleisli m k) (a + b) c) => Kleisli m k ((a + b) + c) (a + (b + c)) Source #

maybeAsSum :: (ObjectSum (Kleisli m k) u a, u ~ UnitObject (Kleisli m k), Object (Kleisli m k) (Maybe a)) => Kleisli m k (Maybe a) (u + a) Source #

maybeFromSum :: (ObjectSum (Kleisli m k) u a, u ~ UnitObject (Kleisli m k), Object (Kleisli m k) (Maybe a)) => Kleisli m k (u + a) (Maybe a) Source #

boolAsSum :: (ObjectSum (Kleisli m k) u u, u ~ UnitObject (Kleisli m k), Object (Kleisli m k) Bool) => Kleisli m k Bool (u + u) Source #

boolFromSum :: (ObjectSum (Kleisli m k) u u, u ~ UnitObject (Kleisli m k), Object (Kleisli m k) Bool) => Kleisli m k (u + u) Bool Source #

(Monad m a, Cartesian a) => Cartesian (Kleisli m a) Source # 
Instance details

Defined in Control.Monad.Constrained

Associated Types

type PairObjects (Kleisli m a) a b :: Constraint Source #

type UnitObject (Kleisli m a) :: * Source #

Methods

swap :: (ObjectPair (Kleisli m a) a0 b, ObjectPair (Kleisli m a) b a0) => Kleisli m a (a0, b) (b, a0) Source #

attachUnit :: (u ~ UnitObject (Kleisli m a), ObjectPair (Kleisli m a) a0 u) => Kleisli m a a0 (a0, u) Source #

detachUnit :: (u ~ UnitObject (Kleisli m a), ObjectPair (Kleisli m a) a0 u) => Kleisli m a (a0, u) a0 Source #

regroup :: (ObjectPair (Kleisli m a) a0 b, ObjectPair (Kleisli m a) b c, ObjectPair (Kleisli m a) a0 (b, c), ObjectPair (Kleisli m a) (a0, b) c) => Kleisli m a (a0, (b, c)) ((a0, b), c) Source #

regroup' :: (ObjectPair (Kleisli m a) a0 b, ObjectPair (Kleisli m a) b c, ObjectPair (Kleisli m a) a0 (b, c), ObjectPair (Kleisli m a) (a0, b) c) => Kleisli m a ((a0, b), c) (a0, (b, c)) Source #

Monad m k => Category (Kleisli m k) Source # 
Instance details

Defined in Control.Monad.Constrained

Associated Types

type Object (Kleisli m k) o :: Constraint Source #

Methods

id :: Object (Kleisli m k) a => Kleisli m k a a Source #

(.) :: (Object (Kleisli m k) a, Object (Kleisli m k) b, Object (Kleisli m k) c) => Kleisli m k b c -> Kleisli m k a b -> Kleisli m k a c Source #

(Monad m a, WellPointed a, ObjectPoint a (m (UnitObject a))) => WellPointed (Kleisli m a) Source # 
Instance details

Defined in Control.Monad.Constrained

Associated Types

type PointObject (Kleisli m a) x :: Constraint Source #

Methods

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

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

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

(SPDistribute k, Monad m k, PreArrow (Kleisli m k), PreArrChoice (Kleisli m k)) => SPDistribute (Kleisli m k) Source # 
Instance details

Defined in Control.Monad.Constrained

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)) Source #

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) Source #

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

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

(Monad m k, Arrow k ((->) :: * -> * -> *), Function k, PreArrChoice k, Object k (m (ZeroObject k)), Object k (m (m (ZeroObject k)))) => PreArrChoice (Kleisli m k) Source # 
Instance details

Defined in Control.Monad.Constrained

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 Source #

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

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

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

(Monad m a, PreArrow a, Curry a) => PreArrow (Kleisli m a) Source # 
Instance details

Defined in Control.Monad.Constrained

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') Source #

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

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

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

(Monad m k, Arrow k ((->) :: * -> * -> *), Function k, PreArrChoice k, Object k (m (ZeroObject k)), Object k (m (m (ZeroObject k)))) => MorphChoice (Kleisli m k) Source #

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

Instance details

Defined in Control.Monad.Constrained

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) Source #

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) Source #

(+++) :: (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') Source #

(Monad m a, Morphism a, Curry a) => Morphism (Kleisli m a) Source # 
Instance details

Defined in Control.Monad.Constrained

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) Source #

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) Source #

(***) :: (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') Source #

(Monad m a, Arrow a q, Cartesian a) => EnhancedCat (Kleisli m a) q Source # 
Instance details

Defined in Control.Monad.Constrained

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 Source #

type ZeroObject (Kleisli m k) Source # 
Instance details

Defined in Control.Monad.Constrained

type UnitObject (Kleisli m a) Source # 
Instance details

Defined in Control.Monad.Constrained

type Object (Kleisli m k) o Source # 
Instance details

Defined in Control.Monad.Constrained

type Object (Kleisli m k) o = (Object k o, Object k (m o), Object k (m (m o)))
type PointObject (Kleisli m a) b Source # 
Instance details

Defined in Control.Monad.Constrained

type PointObject (Kleisli m a) b = (PointObject a b, PointObject a (m b))
type MorphObjects (Kleisli m a) c d Source # 
Instance details

Defined in Control.Monad.Constrained

type MorphObjects (Kleisli m a) c d = (Object a (Kleisli m a c d), Object a (m (Kleisli m a c d)), Object a (a c (m d)), ObjectMorphism a c d, ObjectMorphism a c (m d), ObjectMorphism a c (m (m d)))
type SumObjects (Kleisli m k) b c Source # 
Instance details

Defined in Control.Monad.Constrained

type SumObjects (Kleisli m k) b c = (ObjectSum k b c, ObjectSum k (m b) c, ObjectSum k b (m c), ObjectSum k (m b) (m c))
type PairObjects (Kleisli m a) b c Source # 
Instance details

Defined in Control.Monad.Constrained

type PairObjects (Kleisli m a) b c = (ObjectPair a b c, ObjectPair a (m b) c, ObjectPair a b (m c), ObjectPair a (m b) (m c))

Monoid-Monads

class Monad m k => MonadZero m k where Source #

MonadPlus cannot be adapted quite analogously to Monad, since mzero is just a value with no way to indicate its morphism category. The current implementation is probably not ideal, mainly written to give MonadFail (fail being needed for RebindableSyntax-do notation) a mathematically reasonable superclass.

Consider these classes provisorial, avoid relying on them explicitly.

Minimal complete definition

fmzero

Methods

fmzero :: (Object k a, Object k (m a)) => UnitObject k `k` m a Source #

Instances
(MonadPlus m, Applicative m) => MonadZero m ((->) :: * -> * -> *) Source # 
Instance details

Defined in Control.Monad.Constrained

Methods

fmzero :: (Object (->) a, Object (->) (m a)) => UnitObject (->) -> m a Source #

mzero :: MonadZero m (->) => m a Source #

class MonadZero m k => MonadPlus m k where Source #

Minimal complete definition

fmplus

Methods

fmplus :: ObjectPair k (m a) (m a) => k (m a, m a) (m a) Source #

Instances
(MonadPlus m, Applicative m) => MonadPlus m ((->) :: * -> * -> *) Source # 
Instance details

Defined in Control.Monad.Constrained

Methods

fmplus :: ObjectPair (->) (m a) (m a) => (m a, m a) -> m a Source #

mplus :: MonadPlus m (->) => m a -> m a -> m a Source #

class MonadPlus m k => MonadFail m k where Source #

Minimal complete definition

fail

Methods

fail :: Object k (m a) => k String (m a) Source #

Instances
(MonadPlus m, Applicative m) => MonadFail m ((->) :: * -> * -> *) Source # 
Instance details

Defined in Control.Monad.Constrained

Methods

fail :: Object (->) (m a) => String -> m a Source #

Utility

mapM :: (Traversable s t k l, k ~ l, s ~ t, Applicative m k k, Object k a, Object k (t a), ObjectPair k b (t b), ObjectPair k (m b) (m (t b)), TraversalObject k t b) => (a `k` m b) -> t a `k` m (t b) Source #

traverse, restricted to endofunctors. May be more efficient to implement.

mapM_ :: forall t k o f a b u. (Foldable t k k, WellPointed k, Monoidal f k k, u ~ UnitObject k, ObjectPair k (f u) (t a), ObjectPair k (f u) a, ObjectPair k u (t a), ObjectPair k (t a) u, ObjectPair k (f u) (f u), ObjectPair k u u, ObjectPair k b u, Object k (f b)) => (a `k` f b) -> t a `k` f u Source #

The distinction between mapM_ and traverse_ doesn't really make sense on grounds of Monoidal / Applicative vs Monad, but it has in fact some benefits to restrict this to endofunctors, to make the constraint list at least somewhat shorter.

forM :: forall s t k m a b l. (Traversable s t k l, Monoidal m k l, Function l, Object k b, Object k (t b), ObjectPair k b (t b), Object l a, Object l (s a), ObjectPair l (m b) (m (t b)), TraversalObject k t b) => s a -> (a `l` m b) -> m (t b) Source #

Flipped version of traverse / mapM.

forM_ :: forall t k l f a b uk ul. (Foldable t k l, Monoidal f l l, Monoidal f k k, Function l, Arrow k (->), Arrow l (->), ul ~ UnitObject l, uk ~ UnitObject k, uk ~ ul, ObjectPair l ul ul, ObjectPair l (f ul) (f ul), ObjectPair l (f ul) (t a), ObjectPair l ul (t a), ObjectPair l (t a) ul, ObjectPair l (f ul) a, ObjectPair k b (f b), ObjectPair k b ul, ObjectPair k uk uk, ObjectPair k (f uk) a, ObjectPair k (f uk) (f uk)) => t a -> (a `k` f b) -> f uk Source #

sequence :: (Traversable s t k l, k ~ l, s ~ t, Monoidal f k k, ObjectPair k a (t a), ObjectPair k (f a) (f (t a)), Object k (t (f a)), TraversalObject k t a) => t (f a) `k` f (t a) Source #

sequence_ :: forall t k l m a b uk ul. (Foldable t k l, Arrow k (->), Arrow l (->), uk ~ UnitObject k, ul ~ UnitObject l, uk ~ ul, Monoidal m k k, Monoidal m l l, ObjectPair k a uk, ObjectPair k (t (m a)) uk, ObjectPair k uk uk, ObjectPair k (m uk) (m uk), ObjectPair k (t (m a)) ul, ObjectPair l (m ul) (t (m a)), ObjectPair l ul (t (m a)), ObjectPair l (m uk) (t (m a)), ObjectPair l (t (m a)) ul, ObjectPair k (m uk) (m a)) => t (m a) `l` m uk Source #

guard :: (MonadPlus m k, Arrow k (->), Function k, UnitObject k ~ (), Object k Bool) => Bool `k` m () Source #

when :: (Monad m k, PreArrow k, u ~ UnitObject k, ObjectPair k (m u) u) => Bool -> m u `k` m u Source #

unless :: (Monad m k, PreArrow k, u ~ UnitObject k, ObjectPair k (m u) u) => Bool -> m u `k` m u Source #

forever :: (Monad m k, Function k, Arrow k (->), Object k a, Object k b, Object k (m a), Object k (m (m a)), ObjectPoint k (m b), Object k (m (m b))) => m a `k` m b Source #

void :: (Monad m k, PreArrow k, Object k a, Object k (m a), ObjectPair k a u, u ~ UnitObject k) => m a `k` m (UnitObject k) Source #

filterM :: (PreArrow k, Monad m k, SumToProduct c k k, EndoTraversable c k, ObjectPair k Bool a, Object k (c a), Object k (m (c a)), ObjectPair k (Bool, a) (c (Bool, a)), ObjectPair k (m Bool) (m a), ObjectPair k (m (Bool, a)) (m (c (Bool, a))), TraversalObject k c (Bool, a)) => (a `k` m Bool) -> c a `k` m (c a) Source #