| Haskell Hierarchical Libraries (base package) | Source code | Contents | Index

Control.Arrow

Portability | portable
Stability | experimental
Maintainer | ross@soi.city.ac.uk

Contents

Arrows
  Derived combinators
  Right-to-left variants
Monoid operations
Conditionals
Arrow application
Feedback

Description

Basic arrow definitions, based on Generalising Monads to Arrows, by John Hughes, Science of Computer Programming 37, pp67-111, May 2000. plus a couple of definitions (`returnA` and `loop`) from A New Notation for Arrows, by Ross Paterson, in ICFP 2001, Firenze, Italy, pp229-240. See these papers for the equations these combinators are expected to satisfy. These papers and more information on arrows can be found at http://www.haskell.org/arrows/.

Synopsis

class Arrow a where

arr :: (b -> c) -> a b c
pure :: (b -> c) -> a b c
(>>>) :: a b c -> a c d -> a b d
first :: a b c -> a (b, d) (c, d)
second :: a b c -> a (d, b) (d, c)
(***) :: a b c -> a b' c' -> a (b, b') (c, c')
(&&&) :: a b c -> a b c' -> a b (c, c')

newtype Kleisli m a b = Kleisli {

runKleisli :: (a -> m b)

}

returnA :: Arrow a => a b b
(^>>) :: Arrow a => (b -> c) -> a c d -> a b d
(>>^) :: Arrow a => a b c -> (c -> d) -> a b d
(<<<) :: Arrow a => a c d -> a b c -> a b d
(<<^) :: Arrow a => a c d -> (b -> c) -> a b d
(^<<) :: Arrow a => (c -> d) -> a b c -> a b d
class Arrow a => ArrowZero a where

zeroArrow :: a b c

class ArrowZero a => ArrowPlus a where

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

class Arrow a => ArrowChoice a where

left :: a b c -> a (Either b d) (Either c d)
right :: a b c -> a (Either d b) (Either d c)
(+++) :: a b c -> a b' c' -> a (Either b b') (Either c c')
(|||) :: a b d -> a c d -> a (Either b c) d

class Arrow a => ArrowApply a where

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

newtype ArrowMonad a b = ArrowMonad (a () b)
leftApp :: ArrowApply a => a b c -> a (Either b d) (Either c d)
class Arrow a => ArrowLoop a where

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

Arrows
class Arrow a where

The basic arrow class. Any instance must define either `arr` or `pure` (which are synonyms), as well as `>>>` and `first`. The other combinators have sensible default definitions, which may be overridden for efficiency.
Methods

arr :: (b -> c) -> a b c
Lift a function to an arrow: you must define either this or `pure`.
pure :: (b -> c) -> a b c
A synonym for `arr`: you must define one or other of them.
(>>>) :: a b c -> a c d -> a b d
Left-to-right composition of arrows.
first :: a b c -> a (b, d) (c, d)
Send the first component of the input through the argument arrow, and copy the rest unchanged to the output.
second :: a b c -> a (d, b) (d, c)
A mirror image of `first`. The default definition may be overridden with a more efficient version if desired.
(***) :: 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.
(&&&) :: 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.

Instances

Arrow (->)
Monad m => Arrow (Kleisli m)

newtype Kleisli m a b

Kleisli arrows of a monad.
Constructors

Kleisli |

runKleisli :: (a -> m b) |

Instances

Monad m => Arrow (Kleisli m)
Monad m => ArrowApply (Kleisli m)
Monad m => ArrowChoice (Kleisli m)
MonadFix m => ArrowLoop (Kleisli m)
MonadPlus m => ArrowPlus (Kleisli m)
MonadPlus m => ArrowZero (Kleisli m)

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
Precomposition with a pure function.
(>>^) :: Arrow a => a b c -> (c -> d) -> a b d
Postcomposition with a pure function.
Right-to-left variants
(<<<) :: Arrow a => a c d -> a b c -> a b d
Right-to-left composition, for a better fit with arrow notation.
(<<^) :: Arrow a => a c d -> (b -> c) -> a b d
Precomposition with a pure function (right-to-left variant).
(^<<) :: Arrow a => (c -> d) -> a b c -> a b d
Postcomposition with a pure function (right-to-left variant).
Monoid operations
class Arrow a => ArrowZero a where

Methods

zeroArrow :: a b c

Instances

MonadPlus m => ArrowZero (Kleisli m)

class ArrowZero a => ArrowPlus a where

Methods

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

Instances

MonadPlus m => ArrowPlus (Kleisli m)

Conditionals
class Arrow a => ArrowChoice a where

Choice, for arrows that support it. This class underlies the `if` and `case` constructs in arrow notation. Any instance must define `left`. The other combinators have sensible default definitions, which may be overridden for efficiency.
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')
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
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 (->)
Monad m => ArrowChoice (Kleisli m)

Arrow application
class Arrow a => ArrowApply a where

Some arrows allow application of arrow inputs to other inputs.
Methods

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

Instances

ArrowApply (->)
Monad m => ArrowApply (Kleisli m)

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)

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, even though the computation occurs only once. It underlies the `rec` value recursion construct in arrow notation.
Methods

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

Instances

ArrowLoop (->)
MonadFix m => ArrowLoop (Kleisli m)

Produced by Haddock version 0.8