base-3.0.2.0: Basic librariesSource codeContentsIndex
Control.Arrow
Portabilityportable
Stabilityexperimental
Maintainerlibraries@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 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 whereSource
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 cSource
Lift a function to an arrow: you must define either this or pure.
pure :: (b -> c) -> a b cSource
A synonym for arr: you must define one or other of them.
(>>>) :: a b c -> a c d -> a b dSource
Left-to-right composition of arrows.
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.

show/hide Instances
Arrow (->)
Monad m => Arrow (Kleisli m)
newtype Kleisli m a bSource
Kleisli arrows of a monad.
Constructors
Kleisli
runKleisli :: (a -> m b)
show/hide Instances
Derived combinators
returnA :: Arrow a => a b bSource
The identity arrow, which plays the role of return in arrow notation.
(^>>) :: Arrow a => (b -> c) -> a c d -> a b dSource
Precomposition with a pure function.
(>>^) :: Arrow a => a b c -> (c -> d) -> a b dSource
Postcomposition with a pure function.
Right-to-left variants
(<<<) :: Arrow a => a c d -> a b c -> a b dSource
Right-to-left composition, for a better fit with arrow notation.
(<<^) :: 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
class Arrow a => ArrowZero a whereSource
Methods
zeroArrow :: a b cSource
show/hide Instances
class ArrowZero a => ArrowPlus a whereSource
Methods
(<+>) :: a b c -> a b c -> a b cSource
show/hide Instances
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.

show/hide Instances
Arrow application
class Arrow a => ArrowApply a whereSource
Some arrows allow application of arrow inputs to other inputs.
Methods
app :: a (a b c, b) cSource
show/hide Instances
newtype ArrowMonad a bSource
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)
show/hide 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 whereSource
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 cSource
show/hide Instances
Produced by Haddock version 0.9