4      !"#$%&'()*+,-./0123456789: ; < = > ? @ A B C D E FGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  (c) Ross Paterson 20034BSD-style (see the LICENSE file in the distribution)ross@soi.city.ac.uk experimental+non-portable (multi-parameter type classes)Safe>?A.AAn arrow type that can be used to interpret synchronous circuits.A delay component.3An arrow type that includes errors (or exceptions).Minimal definition:  and .TODO:D the operations here are inconsistent with other arrow transformers.Raise an error. Traditional exception construct. Typical usage in arrow notation: 4 proc p -> ... body `handle` \ex -> handler$Exception construct in the style of Exceptional Syntax&, by Nick Benton and Andrew Kennedy, JFP 11(4):395-410, July 2001. Typical usage in arrow notation: x proc p -> ... (|tryInUnless body (\res -> success) (\ex -> handler) |)*Handler that returns the error as a value.7An arrow type that collects additional output (of some  type).!Add a piece of additional output. QRun a subcomputation in the same arrow, making its additional output accessible. Typical usage in arrow notation: F proc p -> do ... (value, output) <- (|newWriter cmd|) GAn 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. &Obtain the current value of the state.  Assign a new value to the state. kAn arrow type that provides a read-only state (an environment). If you also need to modify the state, use  .&Obtain the current value of the state.Run a subcomputation in the same arrow, but with a different environment. The environment of the outer computation is unaffected. Typical usage in arrow notation: - proc p -> ... (|newReader cmd|) envA suitable value for ! when the arrow type belongs to %. To use it, you must define either  or .the value to return initially.9an arrow that propagates its input with a one-tick delay.!computation that may raise errorscomputation to handle errors!computation that may raise errors)computation to receive successful resultscomputation to handle errors!computation that may raise errors)computation to receive successful resultscomputation to handle errors      (c) Ross Paterson 20034BSD-style (see the LICENSE file in the distribution)ross@soi.city.ac.uk experimental+non-portable (multi-parameter type classes)Safe>?A Adding a  G 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 G arrow. One can add a transformer to the top of this stack using the   method of the L class, or remove a state transformer from the top of the stack using the ~ encapsulation operator. The methods of this class add and remove state transformers anywhere in the stack. In the instance 7 instance Arrow a => ArrowAddStream (ArrowStream a) athey are equivalent to   and D respectively. Instances are lifted through other transformers with S instance ArrowAddStream a a' => ArrowAddStream (FooArrow a) (FooArrow a')<Lift a computation from an arrow to a stream processing one. Typical usage in arrow notation: * proc p -> ... (|liftStream cmd|)MRun a stream processor on a stream of inputs, obtaining a stream of outputs. Typical usage in arrow notation: E proc p -> do ... ys <- (|elimStream (\x -> ...)|) xsHere xs refers to the input stream and x* to individual elements of that stream. ys is bound to the output stream. Adding a G 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 G arrow. One can add a transformer to the top of this stack using the   method of the L class, or remove a state transformer from the top of the stack using the ~ 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) athey are equivalent to   and D respectively. Instances are lifted through other transformers with W instance ArrowAddError ex a a' => ArrowAddError ex (FooArrow a) (FooArrow a')This could be combined with , 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.<Lift a computation from an arrow to one with error handling. Typical usage in arrow notation: ) proc p -> ... (|liftError cmd|)MElimination of errors from a computation, by completely handling any errors. Typical usage in arrow notation: 7 proc p -> ... body `elimError` \ex -> handler Adding a G 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 G arrow. One can add a transformer to the top of this stack using the   method of the L class, or remove a state transformer from the top of the stack using the ~ 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) athey are equivalent to   and D respectively. Instances are lifted through other transformers with W instance ArrowAddWriter w a a' => ArrowAddWriter w (FooArrow a) (FooArrow a'):Lift a computation from an arrow to one with added output. Typical usage in arrow notation: * proc p -> ... (|liftWriter cmd|)VElimination of an output writer from a computation, providing the accumulated output. Typical usage in arrow notation: H proc p -> do ... (result, output) <- (|elimWriter cmd|) Adding a G 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 G arrow. One can add a transformer to the top of this stack using the   method of the L class, or remove a state transformer from the top of the stack using the ~ 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) athey are equivalent to   and D respectively. Instances are lifted through other transformers with W instance ArrowAddReader r a a' => ArrowAddReader r (FooArrow a) (FooArrow a')BLift a computation from an arrow to one with an added environment. Typical usage in arrow notation: * proc p -> ... (|liftReader cmd|)PElimination of a state reader from a computation, taking a value for the state. Typical usage in arrow notation: . proc p -> ... (|elimReader cmd|) env Adding a G 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 G arrow. One can add a transformer to the top of this stack using the   method of the L class, or remove a state transformer from the top of the stack using the ~ encapsulation operator. The methods of this class add and remove state transformers anywhere in the stack. In the instance 9 instance Arrow a => ArrowAddState s (ArrowState s a) athey are equivalent to   and D respectively. Instances are lifted through other transformers with U instance ArrowAddState s a a' => ArrowAddState s (FooArrow a) (FooArrow a')<Lift a computation from an arrow to one with an added state. Typical usage in arrow notation: ) proc p -> ... (|liftState cmd|)^Elimination of a state transformer from a computation, exposing the initial and final states. Typical usage in arrow notation: W proc p -> do ... (result, final_state) <- (|elimState cmd|) init_state(c) Ross Paterson 20034BSD-style (see the LICENSE file in the distribution)ross@soi.city.ac.uk experimentalportableSafe>?A +Construct a new arrow from an existing one.!'A transformation of arrows, preserving ,  and . Typical usage in arrow notation: $ proc p -> ... (|lift cmd|) ! ! !(c) Ross Paterson 20034BSD-style (see the LICENSE file in the distribution)R.Paterson@city.ac.uk experimental+non-portable (multi-parameter type classes)Safe;=>?A"rAn arrow type comprising Mealy-style automata, each step of which is is a computation in the original arrow type.$_Encapsulating an automaton by running it on a stream of inputs, obtaining a stream of outputs. Typical usage in arrow notation: G proc p -> do ... ys <- (|runAutomaton (\x -> ...)|) xsHere xs refers to the input stream and x* to individual elements of that stream. ys is bound to the output stream."#$"#$"# (c) Ross Paterson 20034BSD-style (see the LICENSE file in the distribution)R.Paterson@city.ac.uk experimental+non-portable (multi-parameter type classes)Safe>?A:;:;:;(c) Ross Paterson 20034BSD-style (see the LICENSE file in the distribution)R.Paterson@city.ac.uk experimental+non-portable (multi-parameter type classes)Safe;=>?AoFDAn arrow that augments an existing arrow with possible errors. The ? class contains methods for raising and handling these errors.HMEncapsulate an error-raising computation, by completely handling any errors. Typical usage in arrow notation: 6 proc p -> ... body `runError` \ex -> handlerH!computation that may raise errorscomputation to handle errorsFGHFGHFG(c) Ross Paterson 20034BSD-style (see the LICENSE file in the distribution)R.Paterson@city.ac.uk experimental+non-portable (multi-parameter type classes)Safe;=>?A&^]An arrow type that augments an existing arrow with a read-only state (or environment). The  . class contains the operations on this state.`LEncapsulation of a state-reading computation, taking a value for the state. Typical usage in arrow notation: - proc p -> ... (|runReader cmd|) env^_`^_`^_(c) Ross Paterson 20034BSD-style (see the LICENSE file in the distribution)R.Paterson@city.ac.uk experimental+non-portable (multi-parameter type classes)Safe;=>?AYwMAn arrow type that augments an existing arrow with a modifiable state. The  - class contains the operations on this state.ySEncapsulation of a state-using computation, exposing the initial and final states. Typical usage in arrow notation: V proc p -> do ... (result, final_state) <- (|runState cmd|) init_statewxywxywx (c) Ross Paterson 20034BSD-style (see the LICENSE file in the distribution)R.Paterson@city.ac.uk experimental+non-portable (multi-parameter type classes)Safe;=>?AEA special case is monads applied to the whole arrow, in contrast to 5 arrows, in which the monad is applied to the output.A special case.IAn arrow type that augments the underlying arrow with static information. (c) Ross Paterson 20034BSD-style (see the LICENSE file in the distribution)R.Paterson@city.ac.uk experimental+non-portable (multi-parameter type classes)Safe ;=>?AQV In-place state updates.Note: this is an arrow type, and !% can be used to promote arrows from  ( 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, !i does not preserve composition, because this monad isn't commutative. In particular, a composition of !`s of state transformers will not work, as the second will require the final state of the first.Mappings of streamsArrows between streams.Note: ! is only a functor if  in the underlying arrow is.MRun a stream processor on a stream of inputs, obtaining a stream of outputs. Typical usage in arrow notation: D proc p -> do ... ys <- (|runStream (\x -> ...)|) xsHere xs refers to the input stream and x* to individual elements of that stream. ys is bound to the output stream.Encapsulate a local state.  (c) Ross Paterson 20034BSD-style (see the LICENSE file in the distribution)R.Paterson@city.ac.uk experimental+non-portable (multi-parameter type classes)Safe;=>?ANAn arrow type that augments an existing arrow with accumulating output. The ( class contains the relevant operations.HEncapsulation of a writer computation, providing the accumulated output. Typical usage in arrow notation: G proc p -> do ... (result, output) <- (|runWriter cmd|)Safe>?An0"#$:;FGH^_`wxy !"#$%&'() * + , - . / 0 1 2 3 4 5 6 7 8 99:;<=>?@ABCDEFGHIJKLMNO P P Q R S T U V W X Y Z[\]^_`abcdefghijklmnopqrstuvwxyz{|}~       %arrows-0.4.4.2-BkGdO3PE0I7JcR5HZtrRdRControl.Arrow.Operations Control.Arrow.Transformer.StreamControl.Arrow.Transformer.Error Control.Arrow.Transformer.Writer Control.Arrow.Transformer.ReaderControl.Arrow.Transformer.StateControl.Arrow.Transformer#Control.Arrow.Transformer.Automaton!Control.Arrow.Transformer.CoState Control.Arrow.Transformer.StaticControl.Arrow.Internals StreamArrowliftArrowTransformer runStream ErrorArrowrunErrorhandle WriterArrow runWriter ReaderArrow runReader StateArrowrunStateControl.Arrow.Transformer.All ArrowCircuitdelay ArrowErrorraise tryInUnlessnewError ArrowWriterwrite newWriter ArrowStatefetchstore ArrowReader readState newReadertryInUnlessDefaultArrowAddStream liftStream elimStream ArrowAddError liftError elimErrorArrowAddWriter liftWriter elimWriterArrowAddReader liftReader elimReader ArrowAddState liftState elimState Automaton runAutomaton"$fArrowAddStaterAutomatonAutomaton#$fArrowAddReaderrAutomatonAutomaton#$fArrowAddWriterwAutomatonAutomaton$fArrowStatesAutomaton$fArrowReaderrAutomaton$fArrowErrorrAutomaton$fArrowWriterwAutomaton$fArrowAddStreamAutomatona$fMonoidAutomaton$fSemigroupAutomaton$fAlternativeAutomaton$fApplicativeAutomaton$fFunctorAutomaton$fArrowCircuitAutomaton$fArrowLoopAutomaton$fArrowPlusAutomaton$fArrowZeroAutomaton$fArrowChoiceAutomaton$fArrowAutomaton$fCategoryTYPEAutomaton$fArrowTransformerAutomatona CoStateArrow$fMonoidCoStateArrow$fSemigroupCoStateArrow$fAlternativeCoStateArrow$fApplicativeCoStateArrow$fFunctorCoStateArrow$fArrowPlusCoStateArrow$fArrowZeroCoStateArrow$fArrowLoopCoStateArrow$fArrowCoStateArrow$fCategoryTYPECoStateArrow%$fArrowAddWriterwErrorArrowErrorArrow$$fArrowAddStatesErrorArrowErrorArrow%$fArrowAddReaderrErrorArrowErrorArrow$fArrowWriterwErrorArrow$fArrowStatesErrorArrow$fArrowReaderrErrorArrow$fArrowPlusErrorArrow$fArrowZeroErrorArrow$fArrowAddErrorexErrorArrowa$fArrowErrorexErrorArrow$fMonoidErrorArrow$fSemigroupErrorArrow$fAlternativeErrorArrow$fApplicativeErrorArrow$fFunctorErrorArrow$fArrowLoopErrorArrow$fArrowApplyErrorArrow$fArrowChoiceErrorArrow$fArrowErrorArrow$fCategoryTYPEErrorArrow$fArrowTransformerErrorArrowa$fMonoidReaderArrow$fSemigroupReaderArrow$fAlternativeReaderArrow$fApplicativeReaderArrow$fFunctorReaderArrow'$fArrowAddWritersReaderArrowReaderArrow&$fArrowAddStatesReaderArrowReaderArrow'$fArrowAddErrorexReaderArrowReaderArrow$fArrowWritersReaderArrow$fArrowStatesReaderArrow$fArrowErrorexReaderArrow$fArrowCircuitReaderArrow$fArrowAddReaderrReaderArrowa$fArrowReaderrReaderArrow$fArrowLoopReaderArrow$fArrowPlusReaderArrow$fArrowZeroReaderArrow$fArrowApplyReaderArrow$fArrowChoiceReaderArrow$fArrowReaderArrow$fCategoryTYPEReaderArrow$fArrowTransformerReaderArrowa%$fArrowAddErrorexStateArrowStateArrow%$fArrowAddWriterwStateArrowStateArrow%$fArrowAddReaderrStateArrowStateArrow$fMonoidStateArrow$fSemigroupStateArrow$fAlternativeStateArrow$fApplicativeStateArrow$fFunctorStateArrow$fArrowPlusStateArrow$fArrowLoopStateArrow$fArrowApplyStateArrow$fArrowChoiceStateArrow$fArrowWriterwStateArrow$fArrowReaderrStateArrow$fArrowErrorexStateArrow$fArrowCircuitStateArrow$fArrowZeroStateArrow$fArrowAddStatesStateArrowa$fArrowStatesStateArrow$fArrowTransformerStateArrowa$fArrowStateArrow$fCategoryTYPEStateArrowStaticMonadArrowStaticArrowArrow StaticArrowwrapunwrapwrapAunwrapAwrapMunwrapM'$fArrowAddErrorexStaticArrowStaticArrow'$fArrowAddWriterwStaticArrowStaticArrow'$fArrowAddReaderrStaticArrowStaticArrow&$fArrowAddStatesStaticArrowStaticArrow&$fArrowAddStreamStaticArrowStaticArrow$fMonoidStaticArrow$fSemigroupStaticArrow$fAlternativeStaticArrow$fApplicativeStaticArrow$fFunctorStaticArrow$fArrowPlusStaticArrow$fArrowLoopStaticArrow$fArrowChoiceStaticArrow$fArrowWriterwStaticArrow$fArrowStatesStaticArrow$fArrowReaderrStaticArrow$fArrowErrorexStaticArrow$fArrowCircuitStaticArrow$fArrowZeroStaticArrow$fArrowStaticArrow$fCategoryTYPEStaticArrow$fArrowTransformerStaticArrowa StreamMapST StreamMap runStreamST$fArrowAddStreamStreamArrowa$fMonoidStreamArrow$fSemigroupStreamArrow$fAlternativeStreamArrow$fApplicativeStreamArrow$fFunctorStreamArrow$fArrowCircuitStreamArrow$fArrowPlusStreamArrow$fArrowLoopStreamArrow$fArrowChoiceStreamArrow$fArrowWriterwStreamArrow$fArrowStatesStreamArrow$fArrowZeroStreamArrow$fArrowTransformerStreamArrowa$fArrowStreamArrow$fCategoryTYPEStreamArrow&$fArrowAddStatesWriterArrowWriterArrow'$fArrowAddReaderrWriterArrowWriterArrow'$fArrowAddErrorexWriterArrowWriterArrow$fArrowStatesWriterArrow$fArrowReaderrWriterArrow$fArrowErrorexWriterArrow$fArrowCircuitWriterArrow$fArrowAddWriterwWriterArrowa$fArrowWriterwWriterArrow$fMonoidWriterArrow$fSemigroupWriterArrow$fAlternativeWriterArrow$fApplicativeWriterArrow$fFunctorWriterArrow$fArrowLoopWriterArrow$fArrowPlusWriterArrow$fArrowZeroWriterArrow$fArrowApplyWriterArrow$fArrowChoiceWriterArrow$fArrowWriterArrow$fCategoryTYPEWriterArrow$fArrowTransformerWriterArrowabaseGHC.BaseMonoid Control.Arrow ArrowChoiceKleisliarrControl.Category>>>firstGHC.STST***