| Portability | portable |
|---|---|
| Stability | experimental |
| Maintainer | libraries@haskell.org |
Control.Arrow
Contents
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/.
- class Category a => Arrow a where
- 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
- 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 whereSource
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 cSource
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.
Kleisli arrows of a monad.
Constructors
| Kleisli | |
Fields
| |
Derived combinators
returnA :: Arrow a => a b bSource
The identity arrow, which plays the role of return in arrow notation.
Right-to-left variants
(<<^) :: Arrow a => a c d -> (b -> c) -> a b dSource
Precomposition with a pure function (right-to-left variant).
(^<<) :: Arrow a => (c -> d) -> a b c -> a b dSource
Postcomposition with a pure function (right-to-left variant).
Monoid operations
Conditionals
class Arrow a => ArrowChoice a whereSource
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) dSource
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 whereSource
Some arrows allow application of arrow inputs to other inputs.
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
| ArrowMonad (a () b) |
Instances
| ArrowApply a => Monad (ArrowMonad a) |
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.