
Control.Arrow  Portability  portable  Stability  experimental  Maintainer  libraries@haskell.org 





Description 
Basic arrow definitions, based on
Generalising Monads to Arrows, by John Hughes,
Science of Computer Programming 37, pp67111, May 2000.
plus a couple of definitions (returnA and loop) from
A New Notation for Arrows, by Ross Paterson, in ICFP 2001,
Firenze, Italy, pp229240.
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 




Arrows


class Category a => Arrow a where 
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  Lift a function to an arrow.
  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  


newtype Kleisli m a b 
Kleisli arrows of a monad.
 Constructors   Instances  


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.


Righttoleft variants


(<<^) :: Arrow a => a c d > (b > c) > a b d 
Precomposition with a pure function (righttoleft variant).


(^<<) :: Arrow a => (c > d) > a b c > a b d 
Postcomposition with a pure function (righttoleft variant).


Monoid operations


class Arrow a => ArrowZero a where 
 Methods    Instances  


class ArrowZero a => ArrowPlus a where 
 Methods  (<+>) :: a b c > a b c > a b c 
  Instances  


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  


Arrow application


class Arrow a => ArrowApply a where 
Some arrows allow application of arrow inputs to other inputs.
  Methods    Instances  


newtype ArrowApply a => ArrowMonad a b 


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  


(>>>) :: Category cat => cat a b > cat b c > cat a c 
Lefttoright composition


(<<<) :: Category cat => cat b c > cat a b > cat a c 
Righttoleft composition


Produced by Haddock version 2.3.0 