Lp      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTU V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~    a(c) Andy Gill 2001, (c) Oregon Graduate Institute of Science and Technology, 2001 BSD-style (see the file LICENSE)libraries@haskell.org experimental;non-portable (multi-param classes, functional dependencies)Safe9;<=?pp (a,w) embeds a simple writer action.qq w' is an action that produces the output w.rr m' is an action that executes the action m6 and adds its output to the value of the computation.ss m' is an action that executes the action me, which returns a value and a function, and returns the value, applying the function to the output.tt f m' is an action that executes the action m" and adds the result of applying f/ to the output to the value of the computation. t f m =  (id *** f) (r m)uu f m' is an action that executes the action m and applies the function f4 to its output, leaving the return value unchanged. u f m = s ( (\x -> (x,f)) m)opqrstuvwxyz{|}~oqprstuopqrstuopqrstuvwxyz{|}~a(c) Andy Gill 2001, (c) Oregon Graduate Institute of Science and Technology, 2001 BSD-style (see the file LICENSE)libraries@haskell.org experimentalportableSafe9;<=?a(c) Andy Gill 2001, (c) Oregon Graduate Institute of Science and Technology, 2001 BSD-style (see the file LICENSE)libraries@haskell.org experimental;non-portable (multi-param classes, functional dependencies)Safe9;<=?a      oqprstuopqrstu  a(c) Andy Gill 2001, (c) Oregon Graduate Institute of Science and Technology, 2001 BSD-style (see the file LICENSE)libraries@haskell.org experimental;non-portable (multi-param classes, functional dependencies)Safe9;<=?a      oqprstua(c) Andy Gill 2001, (c) Oregon Graduate Institute of Science and Technology, 2001 BSD-style (see the file LICENSE)libraries@haskell.org experimental;non-portable (multi-param classes, functional dependencies)Safe9;<=?a     oqprstuopqrstua(c) Andy Gill 2001, (c) Oregon Graduate Institute of Science and Technology, 2001 BSD-style (see the file LICENSE)libraries@haskell.org experimental;non-portable (multi-param classes, functional dependencies)Safe9;<=?%Minimal definition is either both of get and put or just state1Return the state from the internals of the monad.#Replace the state inside the monad.+Embed a simple state action into the monad.Monadic state transformer.ZMaps an old state to a new state inside a state monad. The old state is thrown away. Y Main> :t modify ((+1) :: Int -> Int) modify (...) :: (MonadState Int a) => a ()This says that  modify (+1)1 acts over any Monad that is a member of the  MonadState class, with an Int state. A variant of 6 in which the computation is strict in the new state.LGets specific component of the state, using a projection function supplied.a(c) Andy Gill 2001, (c) Oregon Graduate Institute of Science and Technology, 2001 BSD-style (see the file LICENSE)libraries@haskell.org experimental;non-portable (multi-param classes, functional dependencies)Safe9;<=?E !"#$%&'(+*)('&%$#+*))"! a(c) Andy Gill 2001, (c) Oregon Graduate Institute of Science and Technology, 2001 BSD-style (see the file LICENSE)libraries@haskell.org experimental;non-portable (multi-param classes, functional dependencies)Safe9;<=?Ea(c) Andy Gill 2001, (c) Oregon Graduate Institute of Science and Technology, 2001 BSD-style (see the file LICENSE)libraries@haskell.org experimental;non-portable (multi-param classes, functional dependencies)Safe9;<=?E !"#$%&'(+*)(c) Andy Gill 2001, (c) Oregon Graduate Institute of Science and Technology 2001, (c) Jeff Newbern 2003-2007, (c) Andriy Palamarchuk 2007 BSD-style (see the file LICENSE)libraries@haskell.org experimental;non-portable (multi-param classes, functional dependencies)Safe9;<=?See examples in Control.Monad.Reader-. Note, the partially applied function type (->) r$ is a simple reader monad. See the instance declaration below. Retrieves the monad environment.1Executes a computation in a modified environment.0Retrieves a function of the current environment.0Retrieves a function of the current environment.2The selector function to apply to the environment.(c) Andy Gill 2001, (c) Oregon Graduate Institute of Science and Technology 2001, (c) Jeff Newbern 2003-2007, (c) Andriy Palamarchuk 2007 BSD-style (see the file LICENSE)libraries@haskell.org experimental;non-portable (multi-param classes, functional dependencies)Safe9;<=??,-./0143210/.4322-,a(c) Andy Gill 2001, (c) Oregon Graduate Institute of Science and Technology, 2001 BSD-style (see the file LICENSE)libraries@haskell.org experimental;non-portable (multi-param classes, functional dependencies)Safe9;<=?oqprstua(c) Andy Gill 2001, (c) Oregon Graduate Institute of Science and Technology, 2001 BSD-style (see the file LICENSE)libraries@haskell.org experimental;non-portable (multi-param classes, functional dependencies)Safe9;<=?s     CDEFGHIJKLMPONoqprstuMLKJIHGPONNFEDCa(c) Andy Gill 2001, (c) Oregon Graduate Institute of Science and Technology, 2001 BSD-style (see the file LICENSE)libraries@haskell.org experimental;non-portable (multi-param classes, functional dependencies)Safe9;<=?s     56789:;<=>?BA@oqprstu?>=<;:9BA@@8765a(c) Andy Gill 2001, (c) Oregon Graduate Institute of Science and Technology, 2001 BSD-style (see the file LICENSE)libraries@haskell.org experimental;non-portable (multi-param classes, functional dependencies)Safe9;<=?s     CDEFGHIJKLMPONoqprstua(c) Andy Gill 2001, (c) Oregon Graduate Institute of Science and Technology, 2001 BSD-style (see the file LICENSE)libraries@haskell.org experimentalportableSafe9;<=?2QTSRTSRQ(c) Andy Gill 2001, (c) Oregon Graduate Institute of Science and Technology 2001, (c) Jeff Newbern 2003-2006, (c) Andriy Palamarchuk 2006 BSD-style (see the file LICENSE)libraries@haskell.org experimentalportableSafe9;<=?0 !" (c) Michael Weber <michael.weber@post.rwth-aachen.de> 2001, (c) Jeff Newbern 2003-2006, (c) Andriy Palamarchuk 2006 (c) Edward Kmett 2012 BSD-style (see the file LICENSE)libraries@haskell.org experimental+non-portable (multi-parameter type classes)Safe9;<=?The strategy of combining computations that can throw exceptions by bypassing bound functions from the point an exception is thrown to the point that it is handled.hIs parameterized over the type of error information and the monad type constructor. It is common to use  String as the monad type constructor for an error monad in which error descriptions take the form of strings. In that case and many other common cases the resulting monad is already defined as an instance of the _ class. You can also define your own error type and/or use a monad type constructor other than # String or # IOErrorE. In these cases you will have to explicitly define instances of the a and/or  classes.CIs used within a monadic computation to begin exception processing.cA handler function to handle previous errors and return to normal execution. A common idiom is: 5do { action1; action2; action3 } `catchError` handler where the action functions can call . Note that handler1 and the do-block must have the same return type.a`_a`_ (c) Michael Weber <michael.weber@post.rwth-aachen.de> 2001, (c) Jeff Newbern 2003-2006, (c) Andriy Palamarchuk 2006 BSD-style (see the file LICENSE)libraries@haskell.org experimental+non-portable (multi-parameter type classes)Safe9;<=?=UVWXYZ[]\ ]\[WVUZYX (c) Michael Weber <michael.weber@post.rwth-aachen.de> 2001, (c) Jeff Newbern 2003-2006, (c) Andriy Palamarchuk 2006 BSD-style (see the file LICENSE)libraries@haskell.org experimental+non-portable (multi-parameter type classes)Safe9;<=?;^a`_dcb a`_dcbb^y(c) The University of Glasgow 2001, (c) Jeff Newbern 2003-2007, (c) Andriy Palamarchuk 2007 BSD-style (see the file LICENSE)libraries@haskell.org experimentalportableSafe9;<=?callCC? (call-with-current-continuation) calls a function with the current continuation as its argument. Provides an escape continuation mechanism for use with Continuation monads. Escape continuations allow to abort the current computation and return a value immediately. They achieve a similar effect to   and   within an  4 monad. Advantage of this function over calling returnw is that it makes the continuation explicit, allowing more flexibility and better control (see examples in Control.Monad.Cont).The standard idiom used with callCC is to provide a lambda-expression to name the continuation. Then calling the named continuation anywhere within its scope will escape from the computation, even if it is many layers deep within nested computations. y(c) The University of Glasgow 2001, (c) Jeff Newbern 2003-2007, (c) Andriy Palamarchuk 2007 BSD-style (see the file LICENSE)libraries@haskell.org experimentalportableSafe9;<=?:efghijknml kjihgnmllfe$ !"#$%%&&& &!&"&#&$&%&%'(')'*'+','-'.'/'0'1'2'3'34(4)4*4+4,4-4.4/4041424343565758595:5;5<5=5=>?>@>A>B>C>D>E>F>G>H>I>J>K>KL?L@LALBLCLDLELFLGLHLILJLKLKMNMOMPMPQRQSQTQUQVQWQXQYQYZ[Z\Z]ZZ^Z_Z_`a`b`c`d`e`f`g`h`i`i j k l m n o p q r s t u v w x y z {|}~            mtl-2.2.1-BLKBelFsPB3BoFeSWSOYj6Control.Monad.Writer.StrictControl.Monad.Writer.LazyControl.Monad.State.StrictControl.Monad.State.LazyControl.Monad.ReaderControl.Monad.RWS.StrictControl.Monad.RWS.LazyControl.Monad.ListControl.Monad.ExceptControl.Monad.ErrorControl.Monad.Error.ClassControl.Monad.ContControl.Monad.Writer.ClassControl.Monad.State.ClassControl.Monad.Reader.ClassControl.Monad.RWS.ClassControl.Monad.Cont.ClassControl.Monad.TransControl.Monad.WriterControl.Monad.StateControl.Monad.RWSControl.Monad.IdentityDataEither throwError catchErrorErrortransformers-0.5.2.0!Control.Monad.Trans.Writer.Strict mapWriterT execWriterT mapWriter execWriter runWriterWriter runWriterTWriterTControl.Monad.Trans.Writer.Lazy Control.Monad.Trans.State.Strict withStateT mapStateT execStateT evalStateT withStatemapState execState evalStaterunStateState runStateTStateTControl.Monad.Trans.State.LazyControl.Monad.Trans.Reader withReaderT mapReaderT withReader mapReader runReaderReader runReaderTReaderTControl.Monad.Trans.RWS.StrictwithRWSTmapRWSTexecRWSTevalRWSTwithRWSmapRWSexecRWSevalRWSrunRWSrwsRWSrunRWSTRWSTControl.Monad.Trans.RWS.LazyControl.Monad.Trans.ListmapListTrunListTListTControl.Monad.Trans.Except withExceptT mapExceptT runExceptT withExcept mapExcept runExceptExceptExceptTControl.Monad.Trans.Error mapErrorTstrMsgnoMsg runErrorTErrorTControl.Monad.Trans.Cont withContTmapContTwithContmapContrunContcontContrunContTContT MonadWriterwritertelllistenpasslistenscensor$fMonadWriterwStateT$fMonadWriterwStateT0$fMonadWriterwReaderT$fMonadWriterwMaybeT$fMonadWriterwIdentityT$fMonadWriterwExceptT$fMonadWriterwErrorT$fMonadWriterwRWST$fMonadWriterwRWST0$fMonadWriterwWriterT$fMonadWriterwWriterT0 MonadStategetputstatemodifymodify'gets$fMonadStatesWriterT$fMonadStatesWriterT0$fMonadStatesReaderT$fMonadStatesMaybeT$fMonadStatesListT$fMonadStatesIdentityT$fMonadStatesExceptT$fMonadStatesErrorT$fMonadStatesContT$fMonadStatesRWST$fMonadStatesRWST0$fMonadStatesStateT$fMonadStatesStateT0 MonadReaderasklocalreaderasks$fMonadReaderrWriterT$fMonadReaderrWriterT0$fMonadReaderrStateT$fMonadReaderrStateT0$fMonadReaderrMaybeT$fMonadReaderrListT$fMonadReaderrIdentityT$fMonadReaderrExceptT$fMonadReaderrErrorT$fMonadReaderr'ContT$fMonadReaderrRWST$fMonadReaderrRWST0$fMonadReaderrReaderT$fMonadReaderr(->)MonadRWS$fMonadRWSrwsMaybeT$fMonadRWSrwsIdentityT$fMonadRWSrwsErrorT$fMonadRWSrwsExceptT$fMonadRWSrwsRWST$fMonadRWSrwsRWST0 MonadError$fMonadErroreWriterT$fMonadErroreWriterT0$fMonadErroreStateT$fMonadErroreStateT0$fMonadErroreRWST$fMonadErroreRWST0$fMonadErroreReaderT$fMonadErroreMaybeT$fMonadErroreListT$fMonadErroreIdentityT$fMonadErroreExceptT$fMonadErroreErrorT$fMonadErroreEither$fMonadErrorIOExceptionIO MonadContcallCC$fMonadContWriterT$fMonadContWriterT0$fMonadContStateT$fMonadContStateT0$fMonadContRWST$fMonadContRWST0$fMonadContReaderT$fMonadContMaybeT$fMonadContListT$fMonadContIdentityT$fMonadContExceptT$fMonadContErrorT$fMonadContContTbaseGHC.BaseliftMControl.Monad.IO.ClassMonadIOliftIOControl.Monad.Trans.Class MonadTranslift Control.MonadguardjoinMonadfail>>=>>returnFunctorfmapControl.Monad.FixMonadFixmfixData.TraversablemapMsequenceMonoidmemptymappendmconcatmfilter<$!>unless replicateM_ replicateMfoldM_foldM zipWithM_zipWithM mapAndUnzipMforever<=<>=>filterMforM Data.Foldablemsum sequence_forM_mapM_ Data.Monoid<>DualgetDualEndoappEndoAllgetAllAnygetAnySumgetSumProduct getProductFirstgetFirstLastgetLastAltgetAlt Data.Functionfix Data.FunctorvoidapliftM5liftM4liftM3liftM2when=<< MonadPlusmzeromplusData.Functor.IdentityIdentity runIdentity Data.Either