Precursor.Control.Category

Category

class Category k cat where

A class for categories. id and (.) must form a monoid.

Minimal complete definition

id, (.)

Methods

id :: cat a a

the identity morphism

(.) :: cat b c -> cat a b -> cat a c infixr 9

morphism composition

Instances

Category k (Coercion k)

Methods

id :: cat a a

(.) :: cat b c -> cat a b -> cat a c

Category k ((:~:) k)

Methods

id :: cat a a

(.) :: cat b c -> cat a b -> cat a c

Category * (->)

Methods

id :: cat a a

(.) :: cat b c -> cat a b -> cat a c

Monad m => Category * (Kleisli m)

Methods

id :: cat a a

(.) :: cat b c -> cat a b -> cat a c

(.) :: Category k cat => forall b c a. cat b c -> cat a b -> cat a c

morphism composition

id :: Category k cat => forall a. cat a a

the identity morphism

Composition

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

Right-to-left composition

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

Left-to-right composition

Arrow

class Category * a => Arrow a where

The basic arrow class.

Instances should satisfy the following laws:

• arr id = id

• arr (f >>> g) = arr f >>> arr g

• first (arr f) = arr (first f)

• first (f >>> g) = first f >>> first g

• first f >>> arr fst = arr fst >>> f

• first f >>> arr (id *** g) = arr (id *** g) >>> first f

• first (first f) >>> arr assoc = arr assoc >>> first f

where

assoc ((a,b),c) = (a,(b,c))

The other combinators have sensible default definitions, which may be overridden for efficiency.

Minimal complete definition

arr, (first | (***))

Methods

arr :: (b -> c) -> a b c

Lift a function to an arrow.

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

Split the input between the two argument arrows and combine their output. Note that this is in general not a functor.

The default definition may be overridden with a more efficient version if desired.

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

Fanout: send the input to both argument arrows and combine their output.

The default definition may be overridden with a more efficient version if desired.

Instances

Arrow (->)

Methods

arr :: (b -> c) -> b -> c

first :: (b -> c) -> (b, d) -> (c, d)

second :: (b -> c) -> (d, b) -> (d, c)

(***) :: (b -> c) -> (b' -> c') -> (b, b') -> (c, c')

(&&&) :: (b -> c) -> (b -> c') -> b -> (c, c')

Monad m => Arrow (Kleisli m)

Methods

arr :: (b -> c) -> Kleisli m b c

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

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

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

(&&&) :: Kleisli m b c -> Kleisli m b c' -> Kleisli m b (c, c')

arr :: Arrow a => forall b c. (b -> c) -> a b c

Lift a function to an arrow.

(***) :: Arrow a => forall b c b' c'. a b c -> a b' c' -> a (b, b') (c, c')

Split the input between the two argument arrows and combine their output. Note that this is in general not a functor.

The default definition may be overridden with a more efficient version if desired.

(&&&) :: Arrow a => forall b c c'. a b c -> a b c' -> a b (c, c')

Fanout: send the input to both argument arrows and combine their output.

The default definition may be overridden with a more efficient version if desired.

Arrows

newtype Kleisli m a b :: (* -> *) -> * -> * -> *

Kleisli arrows of a monad.

Constructors

Kleisli

Fields

• runKleisli :: a -> m b

Instances

Monad m => Arrow (Kleisli m)

Methods

arr :: (b -> c) -> Kleisli m b c

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

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

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

(&&&) :: Kleisli m b c -> Kleisli m b c' -> Kleisli m b (c, c')

MonadPlus m => ArrowZero (Kleisli m)

Methods

zeroArrow :: Kleisli m b c

MonadPlus m => ArrowPlus (Kleisli m)

Methods

(<+>) :: Kleisli m b c -> Kleisli m b c -> Kleisli m b c

Monad m => ArrowChoice (Kleisli m)

Methods

left :: Kleisli m b c -> Kleisli m (Either b d) (Either c d)

right :: Kleisli m b c -> Kleisli m (Either d b) (Either d c)

(+++) :: Kleisli m b c -> Kleisli m b' c' -> Kleisli m (Either b b') (Either c c')

(|||) :: Kleisli m b d -> Kleisli m c d -> Kleisli m (Either b c) d

Monad m => ArrowApply (Kleisli m)

Methods

app :: Kleisli m (Kleisli m b c, b) c

MonadFix m => ArrowLoop (Kleisli m)

Beware that for many monads (those for which the >>= operation is strict) this instance will not satisfy the right-tightening law required by the ArrowLoop class.

Methods

loop :: Kleisli m (b, d) (c, d) -> Kleisli m b c

Monad m => Category * (Kleisli m)

Methods

id :: cat a a

(.) :: cat b c -> cat a b -> cat a c

Derived combinators

returnA :: Arrow a => a b b

The identity arrow, which plays the role of return in arrow notation.

(^>>) :: Arrow a => (b -> c) -> a c d -> a b d infixr 1

Precomposition with a pure function.

(>>^) :: Arrow a => a b c -> (c -> d) -> a b d infixr 1

Postcomposition with a pure function.

Right-to-left variants

(<<^) :: Arrow a => a c d -> (b -> c) -> a b d infixr 1

Precomposition with a pure function (right-to-left variant).

(^<<) :: Arrow a => (c -> d) -> a b c -> a b d infixr 1

Postcomposition with a pure function (right-to-left variant).

Monoid operations

class Arrow a => ArrowZero a where

Minimal complete definition

zeroArrow

Methods

zeroArrow :: a b c

Instances

MonadPlus m => ArrowZero (Kleisli m)

Methods

zeroArrow :: Kleisli m b c

zeroArrow :: ArrowZero a => forall b c. a b c

class ArrowZero a => ArrowPlus a where

A monoid on arrows.

Minimal complete definition

(<+>)

Methods

(<+>) :: a b c -> a b c -> a b c infixr 5

An associative operation with identity zeroArrow.

Instances

MonadPlus m => ArrowPlus (Kleisli m)

Methods

(<+>) :: Kleisli m b c -> Kleisli m b c -> Kleisli m b c

(<+>) :: ArrowPlus a => forall b c. a b c -> a b c -> a b c

An associative operation with identity zeroArrow.

Conditionals

class Arrow a => ArrowChoice a where

Choice, for arrows that support it. This class underlies the if and case constructs in arrow notation.

Instances should satisfy the following laws:

• left (arr f) = arr (left f)

• left (f >>> g) = left f >>> left g

• f >>> arr Left = arr Left >>> left f

• left f >>> arr (id +++ g) = arr (id +++ g) >>> left f

• left (left f) >>> arr assocsum = arr assocsum >>> left f

where

assocsum (Left (Left x)) = Left x
assocsum (Left (Right y)) = Right (Left y)
assocsum (Right z) = Right (Right z)

The other combinators have sensible default definitions, which may be overridden for efficiency.

Minimal complete definition

left | (+++)

Methods

left :: a b c -> a (Either b d) (Either c d)

Feed marked inputs through the argument arrow, passing the rest through unchanged to the output.

right :: a b c -> a (Either d b) (Either d c)

A mirror image of left.

The default definition may be overridden with a more efficient version if desired.

(+++) :: a b c -> a b' c' -> a (Either b b') (Either c c') infixr 2

Split the input between the two argument arrows, retagging and merging their outputs. Note that this is in general not a functor.

The default definition may be overridden with a more efficient version if desired.

(|||) :: a b d -> a c d -> a (Either b c) d infixr 2

Fanin: Split the input between the two argument arrows and merge their outputs.

The default definition may be overridden with a more efficient version if desired.

Instances

ArrowChoice (->)

Methods

left :: (b -> c) -> Either b d -> Either c d

right :: (b -> c) -> Either d b -> Either d c

(+++) :: (b -> c) -> (b' -> c') -> Either b b' -> Either c c'

(|||) :: (b -> d) -> (c -> d) -> Either b c -> d

Monad m => ArrowChoice (Kleisli m)

Methods

left :: Kleisli m b c -> Kleisli m (Either b d) (Either c d)

right :: Kleisli m b c -> Kleisli m (Either d b) (Either d c)

(+++) :: Kleisli m b c -> Kleisli m b' c' -> Kleisli m (Either b b') (Either c c')

(|||) :: Kleisli m b d -> Kleisli m c d -> Kleisli m (Either b c) d

left :: ArrowChoice a => forall b c d. a b c -> a (Either b d) (Either c d)

Feed marked inputs through the argument arrow, passing the rest through unchanged to the output.

right :: ArrowChoice a => forall b c d. a b c -> a (Either d b) (Either d c)

A mirror image of left.

The default definition may be overridden with a more efficient version if desired.

(+++) :: ArrowChoice a => forall b c b' c'. a b c -> a b' c' -> a (Either b b') (Either c c')

Split the input between the two argument arrows, retagging and merging their outputs. Note that this is in general not a functor.

The default definition may be overridden with a more efficient version if desired.

(|||) :: ArrowChoice a => forall b d c. a b d -> a c d -> a (Either b c) d

Fanin: Split the input between the two argument arrows and merge their outputs.

The default definition may be overridden with a more efficient version if desired.

Arrow application

class Arrow a => ArrowApply a where

Some arrows allow application of arrow inputs to other inputs. Instances should satisfy the following laws:

• first (arr (\x -> arr (\y -> (x,y)))) >>> app = id

• first (arr (g >>>)) >>> app = second g >>> app

• first (arr (>>> h)) >>> app = app >>> h

Such arrows are equivalent to monads (see ArrowMonad).

Minimal complete definition

app

Methods

app :: a (a b c, b) c

Instances

ArrowApply (->)

Methods

app :: (b -> c, b) -> c

Monad m => ArrowApply (Kleisli m)

Methods

app :: Kleisli m (Kleisli m b c, b) c

app :: ArrowApply a => forall b c. a (a b c, b) c

newtype ArrowMonad a b :: (* -> * -> *) -> * -> *

The ArrowApply class is equivalent to Monad: any monad gives rise to a Kleisli arrow, and any instance of ArrowApply defines a monad.

Constructors

ArrowMonad (a () b)

Instances

ArrowApply a => Monad (ArrowMonad a)

Methods

(>>=) :: ArrowMonad a a -> (a -> ArrowMonad a b) -> ArrowMonad a b

(>>) :: ArrowMonad a a -> ArrowMonad a b -> ArrowMonad a b

return :: a -> ArrowMonad a a

fail :: String -> ArrowMonad a a

Arrow a => Functor (ArrowMonad a)

Methods

fmap :: (a -> b) -> ArrowMonad a a -> ArrowMonad a b

(<$) :: a -> ArrowMonad a b -> ArrowMonad a a

Arrow a => Applicative (ArrowMonad a)

Methods

pure :: a -> ArrowMonad a a

(<*>) :: ArrowMonad a (a -> b) -> ArrowMonad a a -> ArrowMonad a b

(*>) :: ArrowMonad a a -> ArrowMonad a b -> ArrowMonad a b

(<*) :: ArrowMonad a a -> ArrowMonad a b -> ArrowMonad a a

ArrowPlus a => Alternative (ArrowMonad a)

Methods

empty :: ArrowMonad a a

(<|>) :: ArrowMonad a a -> ArrowMonad a a -> ArrowMonad a a

some :: ArrowMonad a a -> ArrowMonad a [a]

many :: ArrowMonad a a -> ArrowMonad a [a]

(ArrowApply a, ArrowPlus a) => MonadPlus (ArrowMonad a)

Methods

mzero :: ArrowMonad a a

mplus :: ArrowMonad a a -> ArrowMonad a a -> ArrowMonad a a

leftApp :: ArrowApply a => a b c -> a (Either b d) (Either c d)

Any instance of ArrowApply can be made into an instance of ArrowChoice by defining left = leftApp.

Feedback

class Arrow a => ArrowLoop a where

The loop operator expresses computations in which an output value is fed back as input, although the computation occurs only once. It underlies the rec value recursion construct in arrow notation. loop should satisfy the following laws:

extension

loop (arr f) = arr (\ b -> fst (fix (\ (c,d) -> f (b,d))))

left tightening

loop (first h >>> f) = h >>> loop f

right tightening

loop (f >>> first h) = loop f >>> h

sliding

loop (f >>> arr (id *** k)) = loop (arr (id *** k) >>> f)

vanishing

loop (loop f) = loop (arr unassoc >>> f >>> arr assoc)

superposing

second (loop f) = loop (arr assoc >>> second f >>> arr unassoc)

where

assoc ((a,b),c) = (a,(b,c))
unassoc (a,(b,c)) = ((a,b),c)

Minimal complete definition

loop

Methods

loop :: a (b, d) (c, d) -> a b c

Instances

ArrowLoop (->)

Methods

loop :: ((b, d) -> (c, d)) -> b -> c

MonadFix m => ArrowLoop (Kleisli m)

Beware that for many monads (those for which the >>= operation is strict) this instance will not satisfy the right-tightening law required by the ArrowLoop class.

Methods

loop :: Kleisli m (b, d) (c, d) -> Kleisli m b c

loop :: ArrowLoop a => forall b d c. a (b, d) (c, d) -> a b c