Control.Arrow (original) (raw)

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](Control-Arrow.html#v:returnA "Control.Arrow") and [loop](Control-Arrow.html#v:loop "Control.Arrow")) from

• A New Notation for Arrows, by Ross Paterson, in ICFP 2001, Firenze, Italy, pp229-240.

These papers and more information on arrows can be found athttp://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
• (>>>) :: Category cat => cat a b -> cat b c -> cat a c
• (<<<) :: Category cat => cat b c -> cat a b -> cat a c
• (<<^) :: 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 Category a => Arrow a where Source #

Methods

arr :: (b -> c) -> a b c Source #

Lift a function to an arrow.

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](Control-Arrow.html#v:first "Control.Arrow").

The default definition may be overridden with a more efficient version if desired.

(***) :: a b c -> a b' c' -> a (b, b') (c, c') infixr 3 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') infixr 3 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.

newtype Kleisli m a b Source #

Kleisli arrows of a monad.

Instances

Instances details

Derived combinators

(^>>) :: Arrow a => (b -> c) -> a c d -> a b d infixr 1 Source #

Precomposition with a pure function.

(>>^) :: Arrow a => a b c -> (c -> d) -> a b d infixr 1 Source #

Postcomposition with a pure function.

(>>>) :: Category cat => cat a b -> cat b c -> cat a c infixr 1 Source #

Left-to-right composition

(<<<) :: Category cat => cat b c -> cat a b -> cat a c infixr 1 Source #

Right-to-left composition

Right-to-left variants

(<<^) :: Arrow a => a c d -> (b -> c) -> a b d infixr 1 Source #

Precomposition with a pure function (right-to-left variant).

(^<<) :: Arrow a => (c -> d) -> a b c -> a b d infixr 1 Source #

Postcomposition with a pure function (right-to-left variant).

Monoid operationsConditionals

class Arrow a => ArrowChoice a where Source #

Choice, for arrows that support it. This class underlies theif and case constructs in arrow notation.

Instances should satisfy the following laws:

• [left](Control-Arrow.html#v:left "Control.Arrow") ([arr](Control-Arrow.html#v:arr "Control.Arrow") f) = [arr](Control-Arrow.html#v:arr "Control.Arrow") ([left](Control-Arrow.html#v:left "Control.Arrow") f)
• [left](Control-Arrow.html#v:left "Control.Arrow") (f >>> g) = [left](Control-Arrow.html#v:left "Control.Arrow") f >>> [left](Control-Arrow.html#v:left "Control.Arrow") g
• f >>> [arr](Control-Arrow.html#v:arr "Control.Arrow") [Left](Data-Either.html#v:Left "Data.Either") = [arr](Control-Arrow.html#v:arr "Control.Arrow") [Left](Data-Either.html#v:Left "Data.Either") >>> [left](Control-Arrow.html#v:left "Control.Arrow") f
• [left](Control-Arrow.html#v:left "Control.Arrow") f >>> [arr](Control-Arrow.html#v:arr "Control.Arrow") ([id](Control-Category.html#v:id "Control.Category") +++ g) = [arr](Control-Arrow.html#v:arr "Control.Arrow") ([id](Control-Category.html#v:id "Control.Category") +++ g) >>> [left](Control-Arrow.html#v:left "Control.Arrow") f
• [left](Control-Arrow.html#v:left "Control.Arrow") ([left](Control-Arrow.html#v:left "Control.Arrow") f) >>> [arr](Control-Arrow.html#v:arr "Control.Arrow") assocsum = [arr](Control-Arrow.html#v:arr "Control.Arrow") assocsum >>> [left](Control-Arrow.html#v:left "Control.Arrow") f

where

assocsum (Left (Left x)) = Left x assocsum (Left (Right y)) = Right (Left y) assocsum (Right z) = Right (Right z)

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](Control-Arrow.html#v:left "Control.Arrow").

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') infixr 2 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 infixr 2 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

Instances details

Arrow applicationFeedback

class Arrow a => ArrowLoop a where Source #

The [loop](Control-Arrow.html#v:loop "Control.Arrow") operator expresses computations in which an output value is fed back as input, although the computation occurs only once. It underlies the rec value recursion construct in arrow notation.[loop](Control-Arrow.html#v:loop "Control.Arrow") should satisfy the following laws:

extension

`[loop](Control-Arrow.html#v:loop "Control.Arrow")` (`[arr](Control-Arrow.html#v:arr "Control.Arrow")` f) = `[arr](Control-Arrow.html#v:arr "Control.Arrow")` (\ b -> `[fst](Data-Tuple.html#v:fst "Data.Tuple")` (`[fix](Control-Monad-Fix.html#v:fix "Control.Monad.Fix")` (\ (c,d) -> f (b,d))))

left tightening

`[loop](Control-Arrow.html#v:loop "Control.Arrow")` (`[first](Control-Arrow.html#v:first "Control.Arrow")` h >>> f) = h >>> `[loop](Control-Arrow.html#v:loop "Control.Arrow")` f

right tightening

`[loop](Control-Arrow.html#v:loop "Control.Arrow")` (f >>> `[first](Control-Arrow.html#v:first "Control.Arrow")` h) = `[loop](Control-Arrow.html#v:loop "Control.Arrow")` f >>> h

sliding

`[loop](Control-Arrow.html#v:loop "Control.Arrow")` (f >>> `[arr](Control-Arrow.html#v:arr "Control.Arrow")` (`[id](Control-Category.html#v:id "Control.Category")` *** k)) = `[loop](Control-Arrow.html#v:loop "Control.Arrow")` (`[arr](Control-Arrow.html#v:arr "Control.Arrow")` (`[id](Control-Category.html#v:id "Control.Category")` *** k) >>> f)

vanishing

`[loop](Control-Arrow.html#v:loop "Control.Arrow")` (`[loop](Control-Arrow.html#v:loop "Control.Arrow")` f) = `[loop](Control-Arrow.html#v:loop "Control.Arrow")` (`[arr](Control-Arrow.html#v:arr "Control.Arrow")` unassoc >>> f >>> `[arr](Control-Arrow.html#v:arr "Control.Arrow")` assoc)

superposing

`[second](Control-Arrow.html#v:second "Control.Arrow")` (`[loop](Control-Arrow.html#v:loop "Control.Arrow")` f) = `[loop](Control-Arrow.html#v:loop "Control.Arrow")` (`[arr](Control-Arrow.html#v:arr "Control.Arrow")` assoc >>> `[second](Control-Arrow.html#v:second "Control.Arrow")` f >>> `[arr](Control-Arrow.html#v:arr "Control.Arrow")` unassoc)

where

assoc ((a,b),c) = (a,(b,c)) unassoc (a,(b,c)) = ((a,b),c)

Instances

Instances details