Copyright	(c) Ross Paterson 2002
License	BSD-style (see the LICENSE file in the distribution)
Maintainer	libraries@haskell.org
Stability	provisional
Portability	portable
Safe Haskell	Trustworthy
Language	Haskell2010

GHC.Internal.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.

These papers and more information on arrows can be found at http://www.haskell.org/arrows/.

Synopsis

class Category a => Arrow (a :: Type -> Type -> Type) 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 :: Type -> Type) 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
(>>>) :: forall {k} cat (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c
(<<<) :: forall {k} cat (b :: k) (c :: k) (a :: k). 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 :: Type -> Type -> Type) where
- zeroArrow :: a b c
class ArrowZero a => ArrowPlus (a :: Type -> Type -> Type) where
- (<+>) :: a b c -> a b c -> a b c
class Arrow a => ArrowChoice (a :: Type -> Type -> Type) 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 :: Type -> Type -> Type) where
- app :: a (a b c, b) c
newtype ArrowMonad (a :: Type -> Type -> Type) b = ArrowMonad (a () b)
leftApp :: ArrowApply a => a b c -> a (Either b d) (Either c d)
class Arrow a => ArrowLoop (a :: Type -> Type -> Type) where
- loop :: a (b, d) (c, d) -> a b c

Arrows

class Category a => Arrow (a :: Type -> Type -> Type) where Source #

The basic arrow class.

Instances should satisfy the following laws:

```
arr id = id
```
```
arr (f >>> g) = arr f >>> arr g
```
```
first (arr f) = arr (first f)
```
```
first (f >>> g) = first f >>> first g
```
```
first f >>> arr fst = arr fst >>> f
```

first f >>> arr (id *** g) = arr (id *** g) >>> first f

first (first f) >>> arr assoc = arr assoc >>> first f

where

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

The other combinators have sensible default definitions, which may be overridden for efficiency.

Minimal complete definition

arr, (first | (***))

Methods

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

Lift a function to an arrow.

  b ╭───╮ c
>───┤ f ├───>
    ╰───╯

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.

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

  b ╭─────╮ c
>───┼─ f ─┼───>
>───┼─────┼───>
  d ╰─────╯ d

second :: a b c -> a (d, b) (d, c) Source #

Send the second component of the input through the argument arrow, and copy the rest unchanged to the output.

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

  d ╭─────╮ d
>───┼─────┼───>
>───┼─ f ─┼───>
  b ╰─────╯ c

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

  b ╭─────╮ b'
>───┼─ f ─┼───>
>───┼─ g ─┼───>
  c ╰─────╯ c'

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

    ╭───────╮ c
  b │ ┌─ f ─┼───>
>───┼─┤     │
    │ └─ g ─┼───>
    ╰───────╯ c'

Instances

Instances details

Monad m => Arrow (Kleisli m) Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Control.Arrow Methods arr :: (b -> c) -> Kleisli m b c Source # first :: Kleisli m b c -> Kleisli m (b, d) (c, d) Source # second :: Kleisli m b c -> Kleisli m (d, b) (d, c) Source # (***) :: Kleisli m b c -> Kleisli m b' c' -> Kleisli m (b, b') (c, c') Source # (&&&) :: Kleisli m b c -> Kleisli m b c' -> Kleisli m b (c, c') Source #
Arrow (->) Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Control.Arrow Methods arr :: (b -> c) -> b -> c Source # first :: (b -> c) -> (b, d) -> (c, d) Source # second :: (b -> c) -> (d, b) -> (d, c) Source # (***) :: (b -> c) -> (b' -> c') -> (b, b') -> (c, c') Source # (&&&) :: (b -> c) -> (b -> c') -> b -> (c, c') Source #

newtype Kleisli (m :: Type -> Type) a b Source #

Kleisli arrows of a monad.

Constructors

Kleisli
Fields runKleisli :: a -> m b

Instances

Instances details

Monad m => Category (Kleisli m :: Type -> Type -> Type) Source #

Since: base-3.0

Instance details

Defined in GHC.Internal.Control.Arrow

Methods

id :: Kleisli m a a Source #

(.) :: Kleisli m b c -> Kleisli m a b -> Kleisli m a c Source #

Generic1 (Kleisli m a :: Type -> Type) Source #

Instance details

Defined in GHC.Internal.Control.Arrow

Associated Types

type Rep1 (Kleisli m a :: Type -> Type)	Since: base-4.14.0.0
Instance details Defined in GHC.Internal.Control.Arrow type Rep1 (Kleisli m a :: Type -> Type) = D1 ('MetaData "Kleisli" "GHC.Internal.Control.Arrow" "ghc-internal" 'True) (C1 ('MetaCons "Kleisli" 'PrefixI 'True) (S1 ('MetaSel ('Just "runKleisli") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) ((FUN 'Many a :: Type -> Type) :.: Rec1 m)))

Methods

from1 :: Kleisli m a a0 -> Rep1 (Kleisli m a) a0 Source #

to1 :: Rep1 (Kleisli m a) a0 -> Kleisli m a a0 Source #

Monad m => Arrow (Kleisli m) Source #

Since: base-2.1

Instance details

Defined in GHC.Internal.Control.Arrow

Methods

arr :: (b -> c) -> Kleisli m b c Source #

first :: Kleisli m b c -> Kleisli m (b, d) (c, d) Source #

second :: Kleisli m b c -> Kleisli m (d, b) (d, c) Source #

(***) :: Kleisli m b c -> Kleisli m b' c' -> Kleisli m (b, b') (c, c') Source #

(&&&) :: Kleisli m b c -> Kleisli m b c' -> Kleisli m b (c, c') Source #

Monad m => ArrowApply (Kleisli m) Source #

Since: base-2.1

Instance details

Defined in GHC.Internal.Control.Arrow

Methods

app :: Kleisli m (Kleisli m b c, b) c Source #

Monad m => ArrowChoice (Kleisli m) Source #

Since: base-2.1

Instance details

Defined in GHC.Internal.Control.Arrow

Methods

left :: Kleisli m b c -> Kleisli m (Either b d) (Either c d) Source #

right :: Kleisli m b c -> Kleisli m (Either d b) (Either d c) Source #

(+++) :: Kleisli m b c -> Kleisli m b' c' -> Kleisli m (Either b b') (Either c c') Source #

(|||) :: Kleisli m b d -> Kleisli m c d -> Kleisli m (Either b c) d Source #

MonadFix m => ArrowLoop (Kleisli m) Source #

Beware that for many monads (those for which the >>= operation is strict) this instance will not satisfy the right-tightening law required by the ArrowLoop class.

Since: base-2.1

Instance details

Defined in GHC.Internal.Control.Arrow

Methods

loop :: Kleisli m (b, d) (c, d) -> Kleisli m b c Source #

MonadPlus m => ArrowPlus (Kleisli m) Source #

Since: base-2.1

Instance details

Defined in GHC.Internal.Control.Arrow

Methods

(<+>) :: Kleisli m b c -> Kleisli m b c -> Kleisli m b c Source #

MonadPlus m => ArrowZero (Kleisli m) Source #

Since: base-2.1

Instance details

Defined in GHC.Internal.Control.Arrow

Methods

zeroArrow :: Kleisli m b c Source #

Alternative m => Alternative (Kleisli m a) Source #

Since: base-4.14.0.0

Instance details

Defined in GHC.Internal.Control.Arrow

Methods

empty :: Kleisli m a a0 Source #

(<|>) :: Kleisli m a a0 -> Kleisli m a a0 -> Kleisli m a a0 Source #

some :: Kleisli m a a0 -> Kleisli m a [a0] Source #

many :: Kleisli m a a0 -> Kleisli m a [a0] Source #

Applicative m => Applicative (Kleisli m a) Source #

Since: base-4.14.0.0

Instance details

Defined in GHC.Internal.Control.Arrow

Methods

pure :: a0 -> Kleisli m a a0 Source #

(<*>) :: Kleisli m a (a0 -> b) -> Kleisli m a a0 -> Kleisli m a b Source #

liftA2 :: (a0 -> b -> c) -> Kleisli m a a0 -> Kleisli m a b -> Kleisli m a c Source #

(*>) :: Kleisli m a a0 -> Kleisli m a b -> Kleisli m a b Source #

(<*) :: Kleisli m a a0 -> Kleisli m a b -> Kleisli m a a0 Source #

Functor m => Functor (Kleisli m a) Source #

Since: base-4.14.0.0

Instance details

Defined in GHC.Internal.Control.Arrow

Methods

fmap :: (a0 -> b) -> Kleisli m a a0 -> Kleisli m a b Source #

(<$) :: a0 -> Kleisli m a b -> Kleisli m a a0 Source #

Monad m => Monad (Kleisli m a) Source #

Since: base-4.14.0.0

Instance details

Defined in GHC.Internal.Control.Arrow

Methods

(>>=) :: Kleisli m a a0 -> (a0 -> Kleisli m a b) -> Kleisli m a b Source #

(>>) :: Kleisli m a a0 -> Kleisli m a b -> Kleisli m a b Source #

return :: a0 -> Kleisli m a a0 Source #

MonadPlus m => MonadPlus (Kleisli m a) Source #

Since: base-4.14.0.0

Instance details

Defined in GHC.Internal.Control.Arrow

Methods

mzero :: Kleisli m a a0 Source #

mplus :: Kleisli m a a0 -> Kleisli m a a0 -> Kleisli m a a0 Source #

Generic (Kleisli m a b) Source #

Instance details

Defined in GHC.Internal.Control.Arrow

Associated Types

type Rep (Kleisli m a b)	Since: base-4.14.0.0
Instance details Defined in GHC.Internal.Control.Arrow type Rep (Kleisli m a b) = D1 ('MetaData "Kleisli" "GHC.Internal.Control.Arrow" "ghc-internal" 'True) (C1 ('MetaCons "Kleisli" 'PrefixI 'True) (S1 ('MetaSel ('Just "runKleisli") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (a -> m b))))

Methods

from :: Kleisli m a b -> Rep (Kleisli m a b) x Source #

to :: Rep (Kleisli m a b) x -> Kleisli m a b Source #

type Rep1 (Kleisli m a :: Type -> Type) Source #

Since: base-4.14.0.0

Instance details

Defined in GHC.Internal.Control.Arrow

type Rep1 (Kleisli m a :: Type -> Type) = D1 ('MetaData "Kleisli" "GHC.Internal.Control.Arrow" "ghc-internal" 'True) (C1 ('MetaCons "Kleisli" 'PrefixI 'True) (S1 ('MetaSel ('Just "runKleisli") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) ((FUN 'Many a :: Type -> Type) :.: Rec1 m)))

type Rep (Kleisli m a b) Source #

Since: base-4.14.0.0

Instance details

Defined in GHC.Internal.Control.Arrow

type Rep (Kleisli m a b) = D1 ('MetaData "Kleisli" "GHC.Internal.Control.Arrow" "ghc-internal" 'True) (C1 ('MetaCons "Kleisli" 'PrefixI 'True) (S1 ('MetaSel ('Just "runKleisli") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (a -> m b))))

Derived combinators

returnA :: Arrow a => a b b Source #

The identity arrow, which plays the role of return in arrow notation.

  b
>───>

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

(>>>) :: forall {k} cat (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c infixr 1 Source #

Left-to-right composition. This is useful if you want to write a morphism as a pipeline going from left to right.

(<<<) :: forall {k} cat (b :: k) (c :: k) (a :: k). Category cat => cat b c -> cat a b -> cat a c infixr 1 Source #

Right-to-left composition. This is a synonym for (.), but it can be useful to make the order of composition more apparent.

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 operations

class Arrow a => ArrowZero (a :: Type -> Type -> Type) where Source #

Methods

zeroArrow :: a b c Source #

Instances

Instances details

MonadPlus m => ArrowZero (Kleisli m) Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Control.Arrow Methods zeroArrow :: Kleisli m b c Source #

class ArrowZero a => ArrowPlus (a :: Type -> Type -> Type) where Source #

A monoid on arrows.

Methods

(<+>) :: a b c -> a b c -> a b c infixr 5 Source #

An associative operation with identity zeroArrow.

Instances

Instances details

MonadPlus m => ArrowPlus (Kleisli m) Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Control.Arrow Methods (<+>) :: Kleisli m b c -> Kleisli m b c -> Kleisli m b c Source #

Conditionals

class Arrow a => ArrowChoice (a :: Type -> Type -> Type) where Source #

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

Instances should satisfy the following laws:

```
left (arr f) = arr (left f)
```
```
left (f >>> g) = left f >>> left g
```
```
f >>> arr Left = arr Left >>> left f
```

left f >>> arr (id +++ g) = arr (id +++ g) >>> left f

left (left f) >>> arr assocsum = arr assocsum >>> left 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.

Minimal complete definition

(left | (+++))

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

Monad m => ArrowChoice (Kleisli m) Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Control.Arrow Methods left :: Kleisli m b c -> Kleisli m (Either b d) (Either c d) Source # right :: Kleisli m b c -> Kleisli m (Either d b) (Either d c) Source # (+++) :: Kleisli m b c -> Kleisli m b' c' -> Kleisli m (Either b b') (Either c c') Source # (\|\|\|) :: Kleisli m b d -> Kleisli m c d -> Kleisli m (Either b c) d Source #
ArrowChoice (->) Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Control.Arrow Methods left :: (b -> c) -> Either b d -> Either c d Source # right :: (b -> c) -> Either d b -> Either d c Source # (+++) :: (b -> c) -> (b' -> c') -> Either b b' -> Either c c' Source # (\|\|\|) :: (b -> d) -> (c -> d) -> Either b c -> d Source #

Arrow application

class Arrow a => ArrowApply (a :: Type -> Type -> Type) where Source #

Some arrows allow application of arrow inputs to other inputs. Instances should satisfy the following laws:

first (arr (\x -> arr (\y -> (x,y)))) >>> app = id

first (arr (g >>>)) >>> app = second g >>> app

```
first (arr (>>> h)) >>> app = app >>> h
```

Such arrows are equivalent to monads (see ArrowMonad).

Methods

app :: a (a b c, b) c Source #

Instances

Instances details

Monad m => ArrowApply (Kleisli m) Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Control.Arrow Methods app :: Kleisli m (Kleisli m b c, b) c Source #
ArrowApply (->) Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Control.Arrow Methods app :: (b -> c, b) -> c Source #

newtype ArrowMonad (a :: Type -> Type -> Type) 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

Instances details

ArrowPlus a => Alternative (ArrowMonad a) Source #	Since: base-4.6.0.0
Instance details Defined in GHC.Internal.Control.Arrow Methods empty :: ArrowMonad a a0 Source # (<\|>) :: ArrowMonad a a0 -> ArrowMonad a a0 -> ArrowMonad a a0 Source # some :: ArrowMonad a a0 -> ArrowMonad a [a0] Source # many :: ArrowMonad a a0 -> ArrowMonad a [a0] Source #
Arrow a => Applicative (ArrowMonad a) Source #	Since: base-4.6.0.0
Instance details Defined in GHC.Internal.Control.Arrow Methods pure :: a0 -> ArrowMonad a a0 Source # (<>) :: ArrowMonad a (a0 -> b) -> ArrowMonad a a0 -> ArrowMonad a b Source # liftA2 :: (a0 -> b -> c) -> ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a c Source # (>) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a b Source # (<*) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a a0 Source #
Arrow a => Functor (ArrowMonad a) Source #	Since: base-4.6.0.0
Instance details Defined in GHC.Internal.Control.Arrow Methods fmap :: (a0 -> b) -> ArrowMonad a a0 -> ArrowMonad a b Source # (<$) :: a0 -> ArrowMonad a b -> ArrowMonad a a0 Source #
ArrowApply a => Monad (ArrowMonad a) Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Control.Arrow Methods (>>=) :: ArrowMonad a a0 -> (a0 -> ArrowMonad a b) -> ArrowMonad a b Source # (>>) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a b Source # return :: a0 -> ArrowMonad a a0 Source #
(ArrowApply a, ArrowPlus a) => MonadPlus (ArrowMonad a) Source #	Since: base-4.6.0.0
Instance details Defined in GHC.Internal.Control.Arrow Methods mzero :: ArrowMonad a a0 Source # mplus :: ArrowMonad a a0 -> ArrowMonad a a0 -> ArrowMonad a a0 Source #

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 :: Type -> Type -> Type) where Source #

The loop 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 should satisfy the following laws:

extension: loop (arr f) = arr (\ b -> fst (fix (\ (c,d) -> f (b,d))))
left tightening: loop (first h >>> f) = h >>> loop f
right tightening: loop (f >>> first h) = loop f >>> h
sliding: loop (f >>> arr (id *** k)) = loop (arr (id *** k) >>> f)
vanishing: loop (loop f) = loop (arr unassoc >>> f >>> arr assoc)
superposing: second (loop f) = loop (arr assoc >>> second f >>> arr unassoc)

where

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

Methods

loop :: a (b, d) (c, d) -> a b c Source #

    ╭──────────────╮
  b │     ╭───╮    │ c
>───┼─────┤   ├────┼───>
    │   ┌─┤   ├─┐  │
    │ d │ ╰───╯ │  │
    │   └───<───┘  │
    ╰──────────────╯

Instances

Instances details

MonadFix m => ArrowLoop (Kleisli m) Source #	Beware that for many monads (those for which the `>>=` operation is strict) this instance will not satisfy the right-tightening law required by the `ArrowLoop` class. Since: base-2.1
Instance details Defined in GHC.Internal.Control.Arrow Methods loop :: Kleisli m (b, d) (c, d) -> Kleisli m b c Source #
ArrowLoop (->) Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Control.Arrow Methods loop :: ((b, d) -> (c, d)) -> b -> c Source #