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

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)

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 ╭─────╮ c
>───┼─ f ─┼───>
>───┼─ g ─┼───>
  b'╰─────╯ 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 #

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 #

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 #

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.Monad.Fix

Methods

loop :: Kleisli m (b, d) (c, d) -> 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 #

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 #

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.