-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/

-- | Arrow classes and transformers
--   
--   Several classes that extend the Arrow class, and some transformers
--   that implement or lift these classes.
@package arrows
@version 0.4.4.1

-- | Transformation of state readers.
--   
--   TODO: define operations for this arrow.
module Control.Arrow.Transformer.CoState
newtype CoStateArrow s a b c
CoStateArrow :: (a (s -> b) (s -> c)) -> CoStateArrow s a b c
instance ArrowPlus a => Monoid (CoStateArrow s a b c)
instance ArrowPlus a => Alternative (CoStateArrow s a b)
instance Arrow a => Applicative (CoStateArrow s a b)
instance Arrow a => Functor (CoStateArrow s a b)
instance ArrowPlus a => ArrowPlus (CoStateArrow s a)
instance ArrowZero a => ArrowZero (CoStateArrow s a)
instance ArrowLoop a => ArrowLoop (CoStateArrow s a)
instance Arrow a => Arrow (CoStateArrow s a)
instance Category a => Category (CoStateArrow s a)

-- | Arrow transformers, for making new arrow types out of old ones.
module Control.Arrow.Transformer

-- | Construct a new arrow from an existing one.
class (Arrow a, Arrow (f a)) => ArrowTransformer f a
lift :: ArrowTransformer f a => a b c -> f a b c

-- | Subclasses of Arrow providing additional operations.
--   
--   The signatures are designed to be compatible with the proposed
--   notation for arrows, cf. http://www.haskell.org/arrows/.
module Control.Arrow.Operations

-- | An arrow type that provides a modifiable state, based of section 9 of
--   Generalising Monads to Arrows, by John Hughes, Science of
--   Computer Programming 37:67-111, May 2000.
class Arrow a => ArrowState s a | a -> s
fetch :: ArrowState s a => a e s
store :: ArrowState s a => a s ()

-- | An arrow type that provides a read-only state (an environment). If you
--   also need to modify the state, use ArrowState.
class Arrow a => ArrowReader r a | a -> r
readState :: ArrowReader r a => a b r
newReader :: ArrowReader r a => a e b -> a (e, r) b

-- | An arrow type that collects additional output (of some Monoid
--   type).
class (Monoid w, Arrow a) => ArrowWriter w a | a -> w
write :: ArrowWriter w a => a w ()
newWriter :: ArrowWriter w a => a e b -> a e (b, w)

-- | An arrow type that includes errors (or exceptions).
--   
--   Minimal definition: raise and tryInUnless.
--   
--   TODO: the operations here are inconsistent with other arrow
--   transformers.
class Arrow a => ArrowError ex a | a -> ex where handle f h = tryInUnless f (arr snd) h newError f = handle (f >>> arr Right) (arr (Left . snd))
raise :: ArrowError ex a => a ex b
handle :: ArrowError ex a => a e b -> a (e, ex) b -> a e b
tryInUnless :: ArrowError ex a => a e b -> a (e, b) c -> a (e, ex) c -> a e c
newError :: ArrowError ex a => a e b -> a e (Either ex b)

-- | A suitable value for tryInUnless when the arrow type belongs to
--   ArrowChoice. To use it, you must define either handle or
--   newError.
tryInUnlessDefault :: (ArrowError ex a, ArrowChoice a) => a e b -> a (e, b) c -> a (e, ex) c -> a e c

-- | An arrow type that can be used to interpret synchronous circuits.
class ArrowLoop a => ArrowCircuit a
delay :: ArrowCircuit a => b -> a b b

-- | Simple Mealy-style automata.
module Control.Arrow.Transformer.Automaton

-- | An arrow type comprising Mealy-style automata, each step of which is
--   is a computation in the original arrow type.
newtype Automaton a b c
Automaton :: (a b (c, Automaton a b c)) -> Automaton a b c

-- | Encapsulating an automaton by running it on a stream of inputs,
--   obtaining a stream of outputs.
--   
--   Typical usage in arrow notation:
--   
--   
--   proc p -> do
--   	...
--   	ys <- (|runAutomaton (\x -> ...)|) xs
--   
--   
--   Here xs refers to the input stream and x to
--   individual elements of that stream. ys is bound to the output
--   stream.
runAutomaton :: (ArrowLoop a, ArrowApply a) => Automaton a (e, b) c -> a (e, Stream b) (Stream c)
instance ArrowAddState r a a' => ArrowAddState r (Automaton a) (Automaton a')
instance ArrowAddReader r a a' => ArrowAddReader r (Automaton a) (Automaton a')
instance ArrowAddWriter w a a' => ArrowAddWriter w (Automaton a) (Automaton a')
instance ArrowState s a => ArrowState s (Automaton a)
instance ArrowReader r a => ArrowReader r (Automaton a)
instance ArrowError r a => ArrowError r (Automaton a)
instance ArrowWriter w a => ArrowWriter w (Automaton a)
instance (ArrowLoop a, ArrowApply a) => ArrowAddStream (Automaton a) a
instance ArrowPlus a => Monoid (Automaton a b c)
instance ArrowPlus a => Alternative (Automaton a b)
instance Arrow a => Applicative (Automaton a b)
instance Arrow a => Functor (Automaton a b)
instance ArrowLoop a => ArrowCircuit (Automaton a)
instance ArrowLoop a => ArrowLoop (Automaton a)
instance ArrowPlus a => ArrowPlus (Automaton a)
instance ArrowZero a => ArrowZero (Automaton a)
instance ArrowChoice a => ArrowChoice (Automaton a)
instance Arrow a => Arrow (Automaton a)
instance Arrow a => Category (Automaton a)
instance Arrow a => ArrowTransformer Automaton a

-- | An arrow transformer that adds error handling.
--   
--   TODO: the operations here are inconsistent with other arrow
--   transformers.
module Control.Arrow.Transformer.Error

-- | An arrow that augments an existing arrow with possible errors. The
--   ArrowError class contains methods for raising and handling
--   these errors.
newtype ErrorArrow ex a b c
ErrorArrow :: (a b (Either ex c)) -> ErrorArrow ex a b c

-- | Encapsulate an error-raising computation, by completely handling any
--   errors.
--   
--   Typical usage in arrow notation:
--   
--   
--   proc p -> ...
--   	body `runError` \ex -> handler
--   
runError :: ArrowChoice a => ErrorArrow ex a e b -> a (e, ex) b -> a e b

-- | Adding a ErrorArrow to an arrow type, but not necessarily as
--   the outer arrow transformer.
--   
--   Typically a composite arrow type is built by applying a series of
--   arrow transformer to a base arrow (usually either a function arrow or
--   a Kleisli arrow. One can add a transformer to the top of this
--   stack using the lift method of the ArrowTransformer
--   class, or remove a state transformer from the top of the stack using
--   the runError encapsulation operator. The methods of this class
--   add and remove state transformers anywhere in the stack. In the
--   instance
--   
--   
--   instance Arrow a => ArrowAddError ex (ArrowError ex a) a
--   
--   
--   they are equivalent to lift and runError respectively.
--   Instances are lifted through other transformers with
--   
--   
--   instance ArrowAddError ex a a' =>
--   	ArrowAddError ex (FooArrow a) (FooArrow a')
--   
--   
--   This could be combined with handle, since the resulting arrow
--   is always the arrow of the handler. Separating them has the advantage
--   of consistency with the other arrows, and might give more helpful type
--   error messages.
class (ArrowError ex a, Arrow a') => ArrowAddError ex a a' | a -> a'
liftError :: ArrowAddError ex a a' => a' e b -> a e b
elimError :: ArrowAddError ex a a' => a e b -> a' (e, ex) b -> a' e b
instance (ArrowAddWriter w a a', ArrowChoice a, ArrowChoice a') => ArrowAddWriter w (ErrorArrow ex a) (ErrorArrow ex a')
instance (ArrowAddState s a a', ArrowChoice a, ArrowChoice a') => ArrowAddState s (ErrorArrow ex a) (ErrorArrow ex a')
instance (ArrowAddReader r a a', ArrowChoice a, ArrowChoice a') => ArrowAddReader r (ErrorArrow ex a) (ErrorArrow ex a')
instance (ArrowWriter w a, ArrowChoice a) => ArrowWriter w (ErrorArrow ex a)
instance (ArrowState s a, ArrowChoice a) => ArrowState s (ErrorArrow ex a)
instance (ArrowReader r a, ArrowChoice a) => ArrowReader r (ErrorArrow ex a)
instance (Monoid ex, ArrowChoice a) => ArrowPlus (ErrorArrow ex a)
instance (Monoid ex, ArrowChoice a) => ArrowZero (ErrorArrow ex a)
instance ArrowChoice a => ArrowAddError ex (ErrorArrow ex a) a
instance ArrowChoice a => ArrowError ex (ErrorArrow ex a)
instance (Monoid ex, ArrowChoice a) => Monoid (ErrorArrow ex a b c)
instance (Monoid ex, ArrowChoice a) => Alternative (ErrorArrow ex a b)
instance ArrowChoice a => Applicative (ErrorArrow ex a b)
instance ArrowChoice a => Functor (ErrorArrow ex a b)
instance (ArrowChoice a, ArrowLoop a) => ArrowLoop (ErrorArrow ex a)
instance (ArrowChoice a, ArrowApply a) => ArrowApply (ErrorArrow ex a)
instance ArrowChoice a => ArrowChoice (ErrorArrow ex a)
instance ArrowChoice a => Arrow (ErrorArrow ex a)
instance ArrowChoice a => Category (ErrorArrow ex a)
instance ArrowChoice a => ArrowTransformer (ErrorArrow ex) a

-- | An arrow transformer that adds a modifiable state, based of section 9
--   of Generalising Monads to Arrows, by John Hughes, Science of
--   Computer Programming 37:67-111, May 2000.
module Control.Arrow.Transformer.State

-- | An arrow type that augments an existing arrow with a modifiable state.
--   The ArrowState class contains the operations on this state.
newtype StateArrow s a b c
StateArrow :: (a (b, s) (c, s)) -> StateArrow s a b c

-- | Encapsulation of a state-using computation, exposing the initial and
--   final states.
--   
--   Typical usage in arrow notation:
--   
--   
--   proc p -> do
--   	...
--   	(result, final_state) <- (|runState cmd|) init_state
--   
runState :: Arrow a => StateArrow s a e b -> a (e, s) (b, s)

-- | Adding a StateArrow to an arrow type, but not necessarily as
--   the outer arrow transformer.
--   
--   Typically a composite arrow type is built by applying a series of
--   arrow transformer to a base arrow (usually either a function arrow or
--   a Kleisli arrow. One can add a transformer to the top of this
--   stack using the lift method of the ArrowTransformer
--   class, or remove a state transformer from the top of the stack using
--   the runState encapsulation operator. The methods of this class
--   add and remove state transformers anywhere in the stack. In the
--   instance
--   
--   
--   instance Arrow a => ArrowAddState s (ArrowState s a) a
--   
--   
--   they are equivalent to lift and runState respectively.
--   Instances are lifted through other transformers with
--   
--   
--   instance ArrowAddState s a a' =>
--   	ArrowAddState s (FooArrow a) (FooArrow a')
--   
class (ArrowState s a, Arrow a') => ArrowAddState s a a' | a -> a'
liftState :: ArrowAddState s a a' => a' e b -> a e b
elimState :: ArrowAddState s a a' => a e b -> a' (e, s) (b, s)
instance ArrowAddError ex a a' => ArrowAddError ex (StateArrow s a) (StateArrow s a')
instance ArrowAddWriter w a a' => ArrowAddWriter w (StateArrow s a) (StateArrow s a')
instance ArrowAddReader r a a' => ArrowAddReader r (StateArrow s a) (StateArrow s a')
instance ArrowPlus a => Monoid (StateArrow s a b c)
instance ArrowPlus a => Alternative (StateArrow s a b)
instance Arrow a => Applicative (StateArrow s a b)
instance Arrow a => Functor (StateArrow s a b)
instance ArrowPlus a => ArrowPlus (StateArrow s a)
instance ArrowLoop a => ArrowLoop (StateArrow s a)
instance ArrowApply a => ArrowApply (StateArrow s a)
instance ArrowChoice a => ArrowChoice (StateArrow s a)
instance ArrowWriter w a => ArrowWriter w (StateArrow s a)
instance ArrowReader r a => ArrowReader r (StateArrow s a)
instance ArrowError ex a => ArrowError ex (StateArrow s a)
instance ArrowCircuit a => ArrowCircuit (StateArrow s a)
instance ArrowZero a => ArrowZero (StateArrow s a)
instance Arrow a => ArrowAddState s (StateArrow s a) a
instance Arrow a => ArrowState s (StateArrow s a)
instance Arrow a => ArrowTransformer (StateArrow s) a
instance Arrow a => Arrow (StateArrow s a)
instance Category a => Category (StateArrow s a)

-- | Arrow transformer adding static information.
module Control.Arrow.Transformer.Static

-- | An arrow type that augments the underlying arrow with static
--   information.
newtype StaticArrow f a b c
StaticArrow :: (f (a b c)) -> StaticArrow f a b c

-- | A special case is monads applied to the whole arrow, in contrast to
--   Kleisli arrows, in which the monad is applied to the output.
type StaticMonadArrow m = StaticArrow (WrappedMonad m)

-- | A special case.
type StaticArrowArrow a s = StaticArrow (WrappedArrow a s)
wrap :: (Applicative f, Arrow a) => f (a b c) -> StaticArrow f a b c
unwrap :: (Applicative f, Arrow a) => StaticArrow f a b c -> f (a b c)
wrapA :: (Arrow a, Arrow a') => a s (a' b c) -> StaticArrowArrow a s a' b c
unwrapA :: (Arrow a, Arrow a') => StaticArrowArrow a s a' b c -> a s (a' b c)
wrapM :: (Monad m, Arrow a) => m (a b c) -> StaticMonadArrow m a b c
unwrapM :: (Monad m, Arrow a) => StaticMonadArrow m a b c -> m (a b c)
instance (ArrowAddError ex a a', Applicative f) => ArrowAddError ex (StaticArrow f a) (StaticArrow f a')
instance (ArrowAddWriter w a a', Applicative f) => ArrowAddWriter w (StaticArrow f a) (StaticArrow f a')
instance (ArrowAddReader r a a', Applicative f) => ArrowAddReader r (StaticArrow f a) (StaticArrow f a')
instance (ArrowAddState s a a', Applicative f) => ArrowAddState s (StaticArrow f a) (StaticArrow f a')
instance (ArrowAddStream a a', Applicative f) => ArrowAddStream (StaticArrow f a) (StaticArrow f a')
instance (ArrowPlus a, Applicative f) => Monoid (StaticArrow f a b c)
instance (ArrowPlus a, Applicative f) => Alternative (StaticArrow f a b)
instance (Arrow a, Applicative f) => Applicative (StaticArrow f a b)
instance (Arrow a, Applicative f) => Functor (StaticArrow f a b)
instance (ArrowPlus a, Applicative f) => ArrowPlus (StaticArrow f a)
instance (ArrowLoop a, Applicative f) => ArrowLoop (StaticArrow f a)
instance (ArrowChoice a, Applicative f) => ArrowChoice (StaticArrow f a)
instance (ArrowWriter w a, Applicative f) => ArrowWriter w (StaticArrow f a)
instance (ArrowState s a, Applicative f) => ArrowState s (StaticArrow f a)
instance (ArrowReader r a, Applicative f) => ArrowReader r (StaticArrow f a)
instance (ArrowError ex a, Applicative f) => ArrowError ex (StaticArrow f a)
instance (ArrowCircuit a, Applicative f) => ArrowCircuit (StaticArrow f a)
instance (ArrowZero a, Applicative f) => ArrowZero (StaticArrow f a)
instance (Arrow a, Applicative f) => Arrow (StaticArrow f a)
instance (Category a, Applicative f) => Category (StaticArrow f a)
instance (Arrow a, Applicative f) => ArrowTransformer (StaticArrow f) a

-- | Arrow transformer lifting an arrow to streams.
module Control.Arrow.Transformer.Stream

-- | Arrows between streams.
--   
--   Note: lift is only a functor if *** in the
--   underlying arrow is.
newtype StreamArrow a b c
StreamArrow :: (a (Stream b) (Stream c)) -> StreamArrow a b c

-- | Run a stream processor on a stream of inputs, obtaining a stream of
--   outputs.
--   
--   Typical usage in arrow notation:
--   
--   
--   proc p -> do
--   	...
--   	ys <- (|runStream (\x -> ...)|) xs
--   
--   
--   Here xs refers to the input stream and x to
--   individual elements of that stream. ys is bound to the output
--   stream.
runStream :: ArrowLoop a => StreamArrow a (e, b) c -> a (e, Stream b) (Stream c)

-- | Mappings of streams
type StreamMap = StreamArrow (->)

-- | In-place state updates.
--   
--   Note: this is an arrow type, and lift can be used to
--   promote arrows from Kleisli (ST s): the
--   resulting arrow updates the state for each stream element in turn, and
--   as long as the final state in not required all is well. However,
--   lift does not preserve composition, because this monad isn't
--   commutative. In particular, a composition of lifts of state
--   transformers will not work, as the second will require the final state
--   of the first.
type StreamMapST s = StreamArrow (Kleisli (ST s))

-- | Encapsulate a local state.
runStreamST :: (forall s. StreamMapST s e c) -> StreamMap e c

-- | Adding a StreamArrow to an arrow type, but not necessarily as
--   the outer arrow transformer.
--   
--   Typically a composite arrow type is built by applying a series of
--   arrow transformer to a base arrow (usually either a function arrow or
--   a Kleisli arrow. One can add a transformer to the top of this
--   stack using the lift method of the ArrowTransformer
--   class, or remove a state transformer from the top of the stack using
--   the runStream encapsulation operator. The methods of this class
--   add and remove state transformers anywhere in the stack. In the
--   instance
--   
--   
--   instance Arrow a => ArrowAddStream (ArrowStream a) a
--   
--   
--   they are equivalent to lift and runStream respectively.
--   Instances are lifted through other transformers with
--   
--   
--   instance ArrowAddStream a a' =>
--   	ArrowAddStream (FooArrow a) (FooArrow a')
--   
class (ArrowCircuit a, Arrow a') => ArrowAddStream a a' | a -> a'
liftStream :: ArrowAddStream a a' => a' e b -> a e b
elimStream :: ArrowAddStream a a' => a (e, b) c -> a' (e, Stream b) (Stream c)
instance ArrowLoop a => ArrowAddStream (StreamArrow a) a
instance ArrowPlus a => Monoid (StreamArrow a b c)
instance ArrowPlus a => Alternative (StreamArrow a b)
instance Arrow a => Applicative (StreamArrow a b)
instance Arrow a => Functor (StreamArrow a b)
instance ArrowLoop a => ArrowCircuit (StreamArrow a)
instance ArrowPlus a => ArrowPlus (StreamArrow a)
instance ArrowLoop a => ArrowLoop (StreamArrow a)
instance Arrow a => ArrowChoice (StreamArrow a)
instance ArrowWriter w a => ArrowWriter w (StreamArrow a)
instance ArrowState s a => ArrowState s (StreamArrow a)
instance ArrowZero a => ArrowZero (StreamArrow a)
instance Arrow a => ArrowTransformer StreamArrow a
instance Arrow a => Arrow (StreamArrow a)
instance Category a => Category (StreamArrow a)

-- | Arrow transformer that adds accumulation of output.
module Control.Arrow.Transformer.Writer

-- | An arrow type that augments an existing arrow with accumulating
--   output. The ArrowWriter class contains the relevant operations.
newtype WriterArrow w a b c
WriterArrow :: (a b (c, w)) -> WriterArrow w a b c

-- | Encapsulation of a writer computation, providing the accumulated
--   output.
--   
--   Typical usage in arrow notation:
--   
--   
--   proc p -> do
--   	...
--   	(result, output) <- (|runWriter cmd|)
--   
runWriter :: (Arrow a, Monoid w) => WriterArrow w a e b -> a e (b, w)

-- | Adding a WriterArrow to an arrow type, but not necessarily as
--   the outer arrow transformer.
--   
--   Typically a composite arrow type is built by applying a series of
--   arrow transformer to a base arrow (usually either a function arrow or
--   a Kleisli arrow. One can add a transformer to the top of this
--   stack using the lift method of the ArrowTransformer
--   class, or remove a state transformer from the top of the stack using
--   the runWriter encapsulation operator. The methods of this class
--   add and remove state transformers anywhere in the stack. In the
--   instance
--   
--   
--   instance Arrow a => ArrowAddWriter w (ArrowWriter w a) a
--   
--   
--   they are equivalent to lift and runWriter respectively.
--   Instances are lifted through other transformers with
--   
--   
--   instance ArrowAddWriter w a a' =>
--   	ArrowAddWriter w (FooArrow a) (FooArrow a')
--   
class (ArrowWriter w a, Arrow a') => ArrowAddWriter w a a' | a -> a'
liftWriter :: ArrowAddWriter w a a' => a' e b -> a e b
elimWriter :: ArrowAddWriter w a a' => a e b -> a' e (b, w)
instance (ArrowAddState s a a', Monoid w) => ArrowAddState s (WriterArrow w a) (WriterArrow w a')
instance (ArrowAddReader r a a', Monoid w) => ArrowAddReader r (WriterArrow w a) (WriterArrow w a')
instance (ArrowAddError ex a a', Monoid w) => ArrowAddError ex (WriterArrow w a) (WriterArrow w a')
instance (ArrowState s a, Monoid w) => ArrowState s (WriterArrow w a)
instance (ArrowReader r a, Monoid w) => ArrowReader r (WriterArrow w a)
instance (ArrowError ex a, Monoid w) => ArrowError ex (WriterArrow w a)
instance (ArrowCircuit a, Monoid w) => ArrowCircuit (WriterArrow w a)
instance (Arrow a, Monoid w) => ArrowAddWriter w (WriterArrow w a) a
instance (Arrow a, Monoid w) => ArrowWriter w (WriterArrow w a)
instance (ArrowPlus a, Monoid w) => Monoid (WriterArrow w a b c)
instance (ArrowPlus a, Monoid w) => Alternative (WriterArrow w a b)
instance (Arrow a, Monoid w) => Applicative (WriterArrow w a b)
instance (Arrow a, Monoid w) => Functor (WriterArrow w a b)
instance (ArrowLoop a, Monoid w) => ArrowLoop (WriterArrow w a)
instance (ArrowPlus a, Monoid w) => ArrowPlus (WriterArrow w a)
instance (ArrowZero a, Monoid w) => ArrowZero (WriterArrow w a)
instance (ArrowApply a, Monoid w) => ArrowApply (WriterArrow w a)
instance (ArrowChoice a, Monoid w) => ArrowChoice (WriterArrow w a)
instance (Arrow a, Monoid w) => Arrow (WriterArrow w a)
instance (Arrow a, Monoid w) => Category (WriterArrow w a)
instance (Arrow a, Monoid w) => ArrowTransformer (WriterArrow w) a

-- | Arrow transformer that adds a read-only state (i.e. an environment).
module Control.Arrow.Transformer.Reader

-- | An arrow type that augments an existing arrow with a read-only state
--   (or environment). The ArrowReader class contains the operations
--   on this state.
newtype ReaderArrow r a b c
ReaderArrow :: (a (b, r) c) -> ReaderArrow r a b c

-- | Encapsulation of a state-reading computation, taking a value for the
--   state.
--   
--   Typical usage in arrow notation:
--   
--   
--   proc p -> ...
--   	(|runReader cmd|) env
--   
runReader :: Arrow a => ReaderArrow r a e b -> a (e, r) b

-- | Adding a ReaderArrow to an arrow type, but not necessarily as
--   the outer arrow transformer.
--   
--   Typically a composite arrow type is built by applying a series of
--   arrow transformer to a base arrow (usually either a function arrow or
--   a Kleisli arrow. One can add a transformer to the top of this
--   stack using the lift method of the ArrowTransformer
--   class, or remove a state transformer from the top of the stack using
--   the runReader encapsulation operator. The methods of this class
--   add and remove state transformers anywhere in the stack. In the
--   instance
--   
--   
--   instance Arrow a => ArrowAddReader r (ArrowReader r a) a
--   
--   
--   they are equivalent to lift and runReader respectively.
--   Instances are lifted through other transformers with
--   
--   
--   instance ArrowAddReader r a a' =>
--   	ArrowAddReader r (FooArrow a) (FooArrow a')
--   
class (ArrowReader r a, Arrow a') => ArrowAddReader r a a' | a -> a'
liftReader :: ArrowAddReader r a a' => a' e b -> a e b
elimReader :: ArrowAddReader r a a' => a e b -> a' (e, r) b
instance ArrowPlus a => Monoid (ReaderArrow r a b c)
instance ArrowPlus a => Alternative (ReaderArrow r a b)
instance Arrow a => Applicative (ReaderArrow r a b)
instance Arrow a => Functor (ReaderArrow r a b)
instance ArrowAddWriter s a a' => ArrowAddWriter s (ReaderArrow r a) (ReaderArrow r a')
instance ArrowAddState s a a' => ArrowAddState s (ReaderArrow r a) (ReaderArrow r a')
instance ArrowAddError ex a a' => ArrowAddError ex (ReaderArrow r a) (ReaderArrow r a')
instance ArrowWriter s a => ArrowWriter s (ReaderArrow r a)
instance ArrowState s a => ArrowState s (ReaderArrow r a)
instance ArrowError ex a => ArrowError ex (ReaderArrow r a)
instance ArrowCircuit a => ArrowCircuit (ReaderArrow r a)
instance Arrow a => ArrowAddReader r (ReaderArrow r a) a
instance Arrow a => ArrowReader r (ReaderArrow r a)
instance ArrowLoop a => ArrowLoop (ReaderArrow r a)
instance ArrowPlus a => ArrowPlus (ReaderArrow r a)
instance ArrowZero a => ArrowZero (ReaderArrow r a)
instance ArrowApply a => ArrowApply (ReaderArrow r a)
instance ArrowChoice a => ArrowChoice (ReaderArrow r a)
instance Arrow a => Arrow (ReaderArrow r a)
instance Arrow a => Category (ReaderArrow r a)
instance Arrow a => ArrowTransformer (ReaderArrow r) a

module Control.Arrow.Transformer.All
