class Category a => Arrow (a :: Type -> Type -> Type) where Source

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.

  b ╭───╮ c
>───┤ f ├───>
    ╰───╯

  b ╭─────╮ c
>───┼─ f ─┼───>
>───┼─────┼───>
  d ╰─────╯ d

  d ╭─────╮ d
>───┼─────┼───>
>───┼─ f ─┼───>
  b ╰─────╯ c

  b ╭─────╮ b'
>───┼─ f ─┼───>
>───┼─ g ─┼───>
  c ╰─────╯ c'

    ╭───────╮ c
  b │ ┌─ f ─┼───>
>───┼─┤     │
    │ └─ g ─┼───>
    ╰───────╯ c'

newtype Kleisli (m :: Type -> Type) a b Source

Kleisli arrows of a monad.

returnA :: Arrow a => a b b Source

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

  b
>───>

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

Precomposition with a pure function.

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

Postcomposition with a pure function.

(>>>) :: forall {k} cat (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c infixr 1 Source

Left-to-right composition. This is useful if you want to write a morphism as a pipeline going from left to right.

(<<<) :: forall {k} cat (b :: k) (c :: k) (a :: k). Category cat => cat b c -> cat a b -> cat a c infixr 1 Source

Right-to-left composition. This is a synonym for (.), but it can be useful to make the order of composition more apparent.

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

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

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

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

class Arrow a => ArrowZero (a :: Type -> Type -> Type) where Source

class ArrowZero a => ArrowPlus (a :: Type -> Type -> Type) where Source

A monoid on arrows.

class Arrow a => ArrowChoice (a :: Type -> Type -> Type) where Source

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.

class Arrow a => ArrowApply (a :: Type -> Type -> Type) where Source

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

newtype ArrowMonad (a :: Type -> Type -> Type) b Source

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

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

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

class Arrow a => ArrowLoop (a :: Type -> Type -> Type) where Source

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)

    ╭──────────────╮
  b │     ╭───╮    │ c
>───┼─────┤   ├────┼───>
    │   ┌─┤   ├─┐  │
    │ d │ ╰───╯ │  │
    │   └───<───┘  │
    ╰──────────────╯