| base-3.0.1.0: Basic libraries | 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 | Source

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

Lift a function to an arrow: you must define either this or `pure`.

pure :: (b -> c) -> a b c | Source

A synonym for `arr`: you must define one or other of them.

(>>>) :: a b c -> a c d -> a b d | Source

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.

Instances

Arrow (->)
Monad m => Arrow (Kleisli m)

newtype Kleisli m a b | Source

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 | 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 -> a b c -> a b d | Source

Right-to-left composition, for a better fit with arrow notation.

(<<^) :: 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 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`.
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)

Produced by Haddock version 0.8