| 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