Control.Computation

Arrows

module Control.Arrow

Computations

class ArrowChoice p => Computation p where

Associated Types

type Unit p :: *

type Pair p :: * -> * -> *

type Function p :: * -> * -> *

type DropResult p a :: Constraint

Methods

(###) :: (a `p` c) -> (b `p` d) -> Pair p a b `p` Pair p c d infixr 3

assocLeft :: Pair p a (Pair p b c) `p` Pair p (Pair p a b) c

assocRight :: Pair p (Pair p a b) c `p` Pair p a (Pair p b c)

padFst :: a `p` Pair p (Unit p) a

padSnd :: a `p` Pair p a (Unit p)

dropFst :: DropResult p a => Pair p (Unit p) a `p` a

dropSnd :: DropResult p a => Pair p a (Unit p) `p` a

swap :: Pair p a b `p` Pair p b a

curry :: (Pair p a b `p` c) -> a `p` Function p b c

apply :: Pair p (Function p a b) a `p` b

Instances

Computation Pure

Computation Resourceful

Typeable ((* -> * -> *) -> Constraint) Computation

mapFst :: Computation p => (a `p` b) -> Pair p a c `p` Pair p b c

mapSnd :: Computation p => (b `p` c) -> Pair p a b `p` Pair p a c

precomp :: Computation p => (a `p` b) -> Function p b c `p` Function p a c

postcomp :: Computation p => (b `p` c) -> Function p a b `p` Function p a c

uncurry :: Computation p => (a `p` Function p b c) -> Pair p a b `p` c

inFst :: Computation p => (a `p` Function p b c) -> Pair p a b `p` c

inSnd :: Computation p => (b `p` Function p a c) -> Pair p a b `p` c

outFst :: Computation p => (Pair p a b `p` c) -> a `p` Function p b c

outSnd :: Computation p => (Pair p a b `p` c) -> b `p` Function p a c

Nested pairs

map1 :: Computation p => (a `p` b) -> Pair p a t `p` Pair p b t

map2 :: Computation p => (b `p` c) -> Pair p a (Pair p b t) `p` Pair p a (Pair p c t)

map3 :: Computation p => (c `p` d) -> Pair p a (Pair p b (Pair p c t)) `p` Pair p a (Pair p b (Pair p d t))

map4 :: Computation p => (d `p` e) -> Pair p a (Pair p b (Pair p c (Pair p d t))) `p` Pair p a (Pair p b (Pair p c (Pair p e t)))

in1 :: Computation p => (a `p` Function p t r) -> Pair p a t `p` r

in2 :: Computation p => (b `p` Function p t (Function p a r)) -> Pair p a (Pair p b t) `p` r

in3 :: Computation p => (c `p` Function p t (Function p b (Function p a r))) -> Pair p a (Pair p b (Pair p c t)) `p` r

in4 :: Computation p => (d `p` Function p t (Function p c (Function p b (Function p a r)))) -> Pair p a (Pair p b (Pair p c (Pair p d t))) `p` r

out1 :: Computation p => (Pair p a t `p` r) -> a `p` Function p t r

out2 :: Computation p => (Pair p a (Pair p b t) `p` r) -> b `p` Function p t (Function p a r)

out3 :: Computation p => (Pair p a (Pair p b (Pair p c t)) `p` r) -> c `p` Function p t (Function p b (Function p a r))

out4 :: Computation p => (Pair p a (Pair p b (Pair p c (Pair p d t))) `p` r) -> d `p` Function p t (Function p c (Function p b (Function p a r)))

construct :: Computation p => (Unit p `p` a) -> b `p` Pair p a b

destruct :: (Computation p, DropResult p b) => (a `p` Unit p) -> Pair p a b `p` b

(+:+) :: Computation p => (Unit p `p` a) -> (b `p` t) -> b `p` Pair p a t infixr 5

(-:-) :: (Computation p, DropResult p t) => (a `p` Unit p) -> (t `p` b) -> Pair p a t `p` b infixr 5

Pure computations

type Pure = (->)

Links between computation types

class (Computation (Source l), Computation (Target l)) => Link l where

Associated Types

type Source l :: * -> * -> *

type Target l :: * -> * -> *

Methods

linkMap :: Source l a b -> Target l (l a) (l b)

unitInside :: Target l (Unit (Target l)) (l (Unit (Source l)))

pairInside :: Target l (Pair (Target l) (l a) (l b)) (l (Pair (Source l) a b))

Instances

Computation p => Link ((==>) p p)

Link ((==>) Pure Resourceful)

Computation p => Link ((<==) p p)

Link ((<==) Pure Resourceful)

Typeable ((* -> *) -> Constraint) Link

Connected computation types

class (Link (p ==> q), Source (p ==> q) ~ p, Target (p ==> q) ~ q, Link (p <== q), Source (p <== q) ~ q, Target (p <== q) ~ p) => Connected p q where

Associated Types

data p ==> q :: * -> *

data p <== q :: * -> *

Methods

inject :: a `p` (p <== q) ((p ==> q) a)

extract :: (p ==> q) ((p <== q) b) `q` b

Instances

Computation p => Connected p p

Connected Pure Resourceful

Typeable ((* -> * -> *) -> (* -> * -> *) -> Constraint) Connected

up :: Connected p q => (a `p` (p <== q) b) -> (p ==> q) a `q` b

down :: Connected p q => ((p ==> q) a `q` b) -> a `p` (p <== q) b