h">7      !"#$%&'()*+,-./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 { | } ~                    (c) The University of Glasgow 2001, (c) Jeff Newbern 2003-2007, (c) Andriy Palamarchuk 2007 BSD-style (see the file LICENSE)libraries@haskell.org experimentalportableSafepmtlcallCC (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 return 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.{mtlopop (c) Michael Weber 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)Safe> ~mtlThe 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.Is 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  IOError. In these cases you will have to explicitly define instances of the ~) class. (If you are using the deprecated Control.Monad.Error or Control.Monad.Trans.Error!, you may also have to define an a instance.)mtlIs used within a monadic computation to begin exception processing.mtlA 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.mtl Lifts an  e into any ~ e. -do { val <- liftEither =<< action1; action2 }where action1 returns an  to represent errors.mtlmtla`_~a`_~(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 experimentalportableSafe?8(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)Safe>mtlSee examples in Control.Monad.Reader-. Note, the partially applied function type (->) r$ is a simple reader monad. See the instance declaration below.mtl Retrieves the monad environment.mtl1Executes a computation in a modified environment.mtl0Retrieves a function of the current environment.mtl0Retrieves a function of the current environment.mtlmtl'The function to modify the environment.mtlReader$ to run in the modified environment.mtl2The selector function to apply to the environment.mtl2The selector function to apply to the environment.(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)Safe>mtl%Minimal definition is either both of get and put or just statemtl1Return the state from the internals of the monad.mtl#Replace the state inside the monad.mtl+Embed a simple state action into the monad.mtlMonadic state transformer.Maps an old state to a new state inside a state monad. The old state is thrown away.  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.mtl A variant of 6 in which the computation is strict in the new state.mtlGets specific component of the state, using a projection function supplied.mtl(c) Andy Gill 2001, (c) Oregon Graduate Institute of Science and Technology, 2001 BSD-style (see the file LICENSE)libraries@haskell.org experimentalportableSafe(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)Safe(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)Safei !"#$%&'(+*)('&%$#+*)"! (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)Safe !"#$%&'(+*)(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)Safe,-./0143210/.432-,(c) Andy Gill 2001, (c) Oregon Graduate Institute of Science and Technology, 2001 BSD-style (see the file LICENSE)libraries@haskell.org experimentalportableSafe!74QTSRTSRQ (c) Michael Weber 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)Safe"UVWXYZ[]\~ ~]\[WVUZYX (c) Michael Weber 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)Safe$f=^a`_dcb~ ~a`_dcb^ (c) The University of Glasgow 2001, (c) Jeff Newbern 2003-2007, (c) Andriy Palamarchuk 2007 BSD-style (see the file LICENSE)libraries@haskell.org experimentalportableSafe%<efghijknmlop opkjihgnmlfe(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)Safe>*mtl (a,w) embeds a simple writer action.mtl w' is an action that produces the output w.mtl m' is an action that executes the action m6 and adds its output to the value of the computation.mtl m' is an action that executes the action m, which returns a value and a function, and returns the value, applying the function to the output.mtl 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.  f m =  (id *** f) ( m)mtl f m' is an action that executes the action m and applies the function f4 to its output, leaving the return value unchanged.  f m =  ( (\x -> (x,f)) m)mtlmtlNOTE$: This instance is only defined for  base >= 4.9.0.(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)Safe>,mtl(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)Safe-@56789:;<=>?BA@?>=<;:9BA@8765(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)Safe/1CDEFGHIJKLMPONMLKJIHGPONFEDC(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)Safe1"CDEFGHIJKLMPON(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)Safe3   (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)Safe4 (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)Safe6 !"##$$$$$ $!$"$#$#%&%'%(%)%*%+%,%-%.%/%0%1%12&2'2(2)2*2+2,2-2.2/2021213435363738393:3;3;<=<><?<@<A<B<C<D<E<F<G<H<I<IJ=J>J?J@JAJBJCJDJEJFJGJHJIJIKLKMKNKNOPOQOROSOTOUOVOWOWXYXZX[XX\X]X]^_^`^a^b^c^d^e^f^g^g h i j k l m n o p q r s t u v w   x y z { | } ~          mtl-2.2.2Control.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.Cont.ClassControl.Monad.Reader.ClassControl.Monad.State.ClassControl.Monad.Writer.ClassControl.Monad.RWS.Class throwError catchErrorErrorControl.Monad.IdentityControl.Monad.TransControl.Monad.StateControl.Monad.RWSControl.Monad.Writertransformers-0.5.6.2!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 MonadContcallCC$fMonadContWriterT$fMonadContWriterT0$fMonadContStateT$fMonadContStateT0$fMonadContRWST$fMonadContRWST0$fMonadContReaderT$fMonadContMaybeT$fMonadContListT$fMonadContIdentityT$fMonadContExceptT$fMonadContErrorT$fMonadContContT MonadError liftEither$fMonadErroreWriterT$fMonadErroreWriterT0$fMonadErroreStateT$fMonadErroreStateT0$fMonadErroreRWST$fMonadErroreRWST0$fMonadErroreReaderT$fMonadErroreMaybeT$fMonadErroreListT$fMonadErroreIdentityT$fMonadErroreExceptT$fMonadErroreErrorT$fMonadErroreEither$fMonadError()Maybe$fMonadErrorIOExceptionIO MonadReaderasklocalreaderasks$fMonadReaderrWriterT$fMonadReaderrWriterT0$fMonadReaderrStateT$fMonadReaderrStateT0$fMonadReaderrMaybeT$fMonadReaderrListT$fMonadReaderrIdentityT$fMonadReaderrExceptT$fMonadReaderrErrorT$fMonadReaderr'ContT$fMonadReaderrRWST$fMonadReaderrRWST0$fMonadReaderrReaderT$fMonadReaderr-> MonadStategetputstatemodifymodify'gets$fMonadStatesWriterT$fMonadStatesWriterT0$fMonadStatesReaderT$fMonadStatesMaybeT$fMonadStatesListT$fMonadStatesIdentityT$fMonadStatesExceptT$fMonadStatesErrorT$fMonadStatesContT$fMonadStatesRWST$fMonadStatesRWST0$fMonadStatesStateT$fMonadStatesStateT0 MonadWriterwritertelllistenpasslistenscensor$fMonadWriterwStateT$fMonadWriterwStateT0$fMonadWriterwReaderT$fMonadWriterwMaybeT$fMonadWriterwIdentityT$fMonadWriterwExceptT$fMonadWriterwErrorT$fMonadWriterwRWST$fMonadWriterwRWST0$fMonadWriterwWriterT$fMonadWriterwWriterT0$fMonadWriterw(,)MonadRWS$fMonadRWSrwsMaybeT$fMonadRWSrwsIdentityT$fMonadRWSrwsErrorT$fMonadRWSrwsExceptT$fMonadRWSrwsRWST$fMonadRWSrwsRWST0base Data.EitherEither Control.MonadguardGHC.BasejoinMonad>>>>=returnFunctorfmap<$Control.Monad.FixMonadFixmfixControl.Monad.Fail MonadFailfailData.TraversablemapMsequencemfilter<$!>unless replicateM_ replicateMfoldM_foldM zipWithM_zipWithM mapAndUnzipMforever<=<>=>filterMforMData.Functor.IdentityIdentity runIdentity Data.Foldablemsum sequence_forM_mapM_ Data.Functionfix Data.FunctorvoidapliftM5liftM4liftM3liftM2liftMwhen=<< MonadPlusmzeromplusControl.Monad.Trans.Identity liftCatch liftCallCC mapIdentityT IdentityT runIdentityTControl.Monad.IO.ClassMonadIOliftIOControl.Monad.Trans.Class MonadTranslift<>Monoidmconcatmemptymappend Data.MonoidFirstgetFirstLastgetLastApgetApData.Semigroup.InternalDualgetDualEndoappEndoAllgetAllAnygetAnySumgetSumProduct getProductAltgetAlt