Control.Arrow

base-4.3.1.0: Basic libraries

Portability | portable
Stability | experimental
Maintainer | libraries@haskell.org

Control.Arrow

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 Category a => Arrow a where
  - arr :: (b -> c) -> a b c
  - 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 -> (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 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 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

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

newtype Kleisli m a b

Kleisli arrows of a monad.

Constructors

Kleisli |
Fields runKleisli :: a -> m b

Instances

Monad m => Category (Kleisli m) |
MonadFix m => ArrowLoop (Kleisli m) |
Monad m => ArrowApply (Kleisli m) |
Monad m => ArrowChoice (Kleisli m) |
MonadPlus m => ArrowPlus (Kleisli m) |
MonadPlus m => ArrowZero (Kleisli m) |
Monad m => Arrow (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 -> (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 ArrowApply a => 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) |

(>>>) :: Category cat => cat a b -> cat b c -> cat a c

Left-to-right composition

(<<<) :: Category cat => cat b c -> cat a b -> cat a c

Right-to-left composition