-- 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.1


-- | 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 <a>Arrow</a> providing additional operations.
--   
--   The signatures are designed to be compatible with the proposed
--   notation for arrows, cf. <a>http://www.haskell.org/arrows/</a>.
module Control.Arrow.Operations

-- | An arrow type that provides a modifiable state, based of section 9 of
--   <i>Generalising Monads to Arrows</i>, by John Hughes, <i>Science of
--   Computer Programming</i> 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 <a>ArrowState</a>.
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 <a>Monoid</a>
--   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: <a>raise</a> and <a>tryInUnless</a>.
--   
--   <i>TODO:</i> the operations here are inconsistent with other arrow
--   transformers.
class (Arrow a) => ArrowError ex a | a -> ex
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 <a>tryInUnless</a> when the arrow type belongs to
--   <a>ArrowChoice</a>. To use it, you must define either <a>handle</a> or
--   <a>newError</a>.
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


-- | Transformation of state readers.
--   
--   <i>TODO:</i> define operations for this arrow.
module Control.Arrow.Transformer.CoState
data 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)


-- | 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:
--   
--   <pre>
--   proc p -&gt; do
--   	...
--   	ys &lt;- (|runAutomaton (\x -&gt; ...)|) xs
--   </pre>
--   
--   Here <tt>xs</tt> refers to the input stream and <tt>x</tt> to
--   individual elements of that stream. <tt>ys</tt> 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.
--   
--   <i>TODO:</i> 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
--   <a>ArrowError</a> class contains methods for raising and handling
--   these errors.
data ErrorArrow ex a b c

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

-- | Adding a Control.Arrow.Transformer.Error.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 <a>Kleisli</a> arrow. One can add a transformer to the top of this
--   stack using the Control.Arrow.Transformer.lift method of the
--   Control.Arrow.Transformer.ArrowTransformer class, or remove a state
--   transformer from the top of the stack using the
--   Control.Arrow.Transformer.Error.runError encapsulation operator. The
--   methods of this class add and remove state transformers anywhere in
--   the stack. In the instance
--   
--   <pre>
--   instance Arrow a =&gt; ArrowAddError ex (ArrowError ex a) a
--   </pre>
--   
--   they are equivalent to Control.Arrow.Transformer.lift and
--   Control.Arrow.Transformer.Error.runError respectively. Instances are
--   lifted through other transformers with
--   
--   <pre>
--   instance ArrowAddError ex a a' =&gt;
--   	ArrowAddError ex (FooArrow a) (FooArrow a')
--   </pre>
--   
--   This could be combined with Control.Arrow.Transformer.Error.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 <i>Generalising Monads to Arrows</i>, by John Hughes, <i>Science of
--   Computer Programming</i> 37:67-111, May 2000.
module Control.Arrow.Transformer.State

-- | An arrow type that augments an existing arrow with a modifiable state.
--   The <a>ArrowState</a> class contains the operations on this state.
data StateArrow s a b c

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

-- | Adding a Control.Arrow.Transformer.State.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 <a>Kleisli</a> arrow. One can add a transformer to the top of this
--   stack using the Control.Arrow.Transformer.lift method of the
--   Control.Arrow.Transformer.ArrowTransformer class, or remove a state
--   transformer from the top of the stack using the
--   Control.Arrow.Transformer.State.runState encapsulation operator. The
--   methods of this class add and remove state transformers anywhere in
--   the stack. In the instance
--   
--   <pre>
--   instance Arrow a =&gt; ArrowAddState s (ArrowState s a) a
--   </pre>
--   
--   they are equivalent to Control.Arrow.Transformer.lift and
--   Control.Arrow.Transformer.State.runState respectively. Instances are
--   lifted through other transformers with
--   
--   <pre>
--   instance ArrowAddState s a a' =&gt;
--   	ArrowAddState s (FooArrow a) (FooArrow a')
--   </pre>
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.
data StaticArrow f a b c

-- | A special case is monads applied to the whole arrow, in contrast to
--   <a>Kleisli</a> 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)
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.
--   
--   <i>Note</i>: <a>lift</a> is only a functor if <a>***</a> in the
--   underlying arrow is.
data StreamArrow a b c

-- | Run a stream processor on a stream of inputs, obtaining a stream of
--   outputs.
--   
--   Typical usage in arrow notation:
--   
--   <pre>
--   proc p -&gt; do
--   	...
--   	ys &lt;- (|runStream (\x -&gt; ...)|) xs
--   </pre>
--   
--   Here <tt>xs</tt> refers to the input stream and <tt>x</tt> to
--   individual elements of that stream. <tt>ys</tt> 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.
--   
--   <i>Note</i>: this is an arrow type, and <a>lift</a> can be used to
--   promote arrows from <tt><a>Kleisli</a> (<a>ST</a> s)</tt>: 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,
--   <a>lift</a> does not preserve composition, because this monad isn't
--   commutative. In particular, a composition of <a>lift</a>s 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 Control.Arrow.Transformer.Stream.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 <a>Kleisli</a> arrow. One can add a transformer to the top of this
--   stack using the Control.Arrow.Transformer.lift method of the
--   Control.Arrow.Transformer.ArrowTransformer class, or remove a state
--   transformer from the top of the stack using the
--   Control.Arrow.Transformer.Stream.runStream encapsulation operator. The
--   methods of this class add and remove state transformers anywhere in
--   the stack. In the instance
--   
--   <pre>
--   instance Arrow a =&gt; ArrowAddStream (ArrowStream a) a
--   </pre>
--   
--   they are equivalent to Control.Arrow.Transformer.lift and
--   Control.Arrow.Transformer.Stream.runStream respectively. Instances are
--   lifted through other transformers with
--   
--   <pre>
--   instance ArrowAddStream a a' =&gt;
--   	ArrowAddStream (FooArrow a) (FooArrow a')
--   </pre>
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 <a>ArrowWriter</a> class contains the relevant operations.
data WriterArrow w a b c

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

-- | Adding a Control.Arrow.Transformer.Writer.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 <a>Kleisli</a> arrow. One can add a transformer to the top of this
--   stack using the Control.Arrow.Transformer.lift method of the
--   Control.Arrow.Transformer.ArrowTransformer class, or remove a state
--   transformer from the top of the stack using the
--   Control.Arrow.Transformer.Writer.runWriter encapsulation operator. The
--   methods of this class add and remove state transformers anywhere in
--   the stack. In the instance
--   
--   <pre>
--   instance Arrow a =&gt; ArrowAddWriter w (ArrowWriter w a) a
--   </pre>
--   
--   they are equivalent to Control.Arrow.Transformer.lift and
--   Control.Arrow.Transformer.Writer.runWriter respectively. Instances are
--   lifted through other transformers with
--   
--   <pre>
--   instance ArrowAddWriter w a a' =&gt;
--   	ArrowAddWriter w (FooArrow a) (FooArrow a')
--   </pre>
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 <a>ArrowReader</a> class contains the operations
--   on this state.
data ReaderArrow r a b c

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

-- | Adding a Control.Arrow.Transformer.Reader.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 <a>Kleisli</a> arrow. One can add a transformer to the top of this
--   stack using the Control.Arrow.Transformer.lift method of the
--   Control.Arrow.Transformer.ArrowTransformer class, or remove a state
--   transformer from the top of the stack using the
--   Control.Arrow.Transformer.Reader.runReader encapsulation operator. The
--   methods of this class add and remove state transformers anywhere in
--   the stack. In the instance
--   
--   <pre>
--   instance Arrow a =&gt; ArrowAddReader r (ArrowReader r a) a
--   </pre>
--   
--   they are equivalent to Control.Arrow.Transformer.lift and
--   Control.Arrow.Transformer.Reader.runReader respectively. Instances are
--   lifted through other transformers with
--   
--   <pre>
--   instance ArrowAddReader r a a' =&gt;
--   	ArrowAddReader r (FooArrow a) (FooArrow a')
--   </pre>
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