Control.Arrow
 Portability portable Stability experimental Maintainer libraries@haskell.org
 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 Category a => Arrow a where
 arr :: (b -> c) -> a b c 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 -> (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 ArrowApply a => 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
(>>>) :: Category cat => cat a b -> cat b c -> cat a c
(<<<) :: Category cat => cat b c -> cat a b -> cat a c
Arrows
 class Category a => Arrow a where Source

The basic arrow class.

Minimal complete definition: arr and first.

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

Methods
 arr :: (b -> c) -> a b c Source
Lift a function to an arrow.
 first :: a b c -> a (b, d) (c, d) Source
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) Source

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

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

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 Source
Constructors
Kleisli
 runKleisli :: a -> m b Instances
 Monad m => Category (Kleisli m) MonadFix m => ArrowLoop (Kleisli m) Monad m => ArrowApply (Kleisli m) Monad m => ArrowChoice (Kleisli m) MonadPlus m => ArrowPlus (Kleisli m) MonadPlus m => ArrowZero (Kleisli m) Monad m => Arrow (Kleisli m)
Derived combinators
 returnA :: Arrow a => a b b Source
The identity arrow, which plays the role of return in arrow notation.
 (^>>) :: Arrow a => (b -> c) -> a c d -> a b d Source
Precomposition with a pure function.
 (>>^) :: Arrow a => a b c -> (c -> d) -> a b d Source
Postcomposition with a pure function.
Right-to-left variants
 (<<^) :: Arrow a => a c d -> (b -> c) -> a b d Source
Precomposition with a pure function (right-to-left variant).
 (^<<) :: Arrow a => (c -> d) -> a b c -> a b d Source
Postcomposition with a pure function (right-to-left variant).
Monoid operations
 class Arrow a => ArrowZero a where Source
Methods
 zeroArrow :: a b c Source Instances
 MonadPlus m => ArrowZero (Kleisli m)
 class ArrowZero a => ArrowPlus a where Source
Methods
 (<+>) :: a b c -> a b c -> a b c Source Instances
 MonadPlus m => ArrowPlus (Kleisli m)
Conditionals
 class Arrow a => ArrowChoice a where Source
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) Source
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) Source

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

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 Source

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 Source
Some arrows allow application of arrow inputs to other inputs.
Methods
 app :: a (a b c, b) c Source Instances
 ArrowApply (->) Monad m => ArrowApply (Kleisli m)
 newtype ArrowApply a => ArrowMonad a 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.
Constructors Instances
 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.
Feedback
 class Arrow a => ArrowLoop a where Source
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 Source Instances
 ArrowLoop (->) MonadFix m => ArrowLoop (Kleisli m)
 (>>>) :: Category cat => cat a b -> cat b c -> cat a c Source
Left-to-right composition
 (<<<) :: Category cat => cat b c -> cat a b -> cat a c Source
Right-to-left composition