!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^ _ ` 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 { | } ~  Safe&None &'0357>CLTagged monad transformer.Type-restricted .Type-restricted .   None '(0357>CL The writer monad transformer.The  function produces the output , while 4 combines the outputs of the subcomputations using . The parametrizable writer monad.+Computations can accumulate a monoid value.The  function produces the output , while 4 combines the outputs of the subcomputations using .=Constructor for computations in the writer monad transformer.BConstructor for computations in the writer monad (the inverse of ).Runs a > and returns both the normal value and the final accumulator.Runs a > and returns both the normal value and the final accumulator.Runs a A and returns the final accumulator, discarding the normal value.Runs a A and returns the final accumulator, discarding the normal value.4Appends a value to the accumulator within the monad.LExecutes an action and adds its accumulator to the value of the computation.zExecutes an action which returns a value and a function, and returns the value, applying the function to the accumulator.    None '3579>LSee .Embed a simple writer action.3Append a value to the accumulator within the monad.KExecute an action and add its accumulator to the value of the computation. xExecute an action which returns a value and a function, and return the value, applying the function to the accumulator.!xExecute an action and add the result of applying the given function to its accumulator to the value of the computation.":Execute an action and apply a function to its accumulator.  !" !" !" !"None !" !"None&N#See .$See .%See .&See .'See .(See .)See .*See .+See  .,See !.-See "..See #./See $.0See %.#$%&'()*+,-./0#$%&'()*+,-./0%&'()*+$,-#./0#$%&'()*+,-./0None '(0357>CL 1The state monad transformer.The , function leaves the state unchanged, while S uses the final state of the first computation as the initial state of the second.2The parametrizable state monad.,Computations have access to a mutable state.The , function leaves the state unchanged, while S uses the final state of the first computation as the initial state of the second.3<Constructor for computations in the state monad transformer.4AConstructor for computations in the state monad (the inverse of 8).5Runs a 1T with the given initial state and returns both the final value and the final state.6Runs a 1W with the given initial state and returns the final value, discarding the final state.7Runs a 1W with the given initial state and returns the final state, discarding the final value.8Runs a 2T with the given initial state and returns both the final value and the final state.9Runs a 2W with the given initial state and returns the final value, discarding the final state.:Runs a 2W with the given initial state and returns the final state, discarding the final value.;6Fetch the current value of the state within the monad.<,Set the value of the state within the monad. 123456789:;< 123456789:;< 2489:13567;< 123456789:;<&None 123456789:;<None '(0357>CL =The state monad transformer.The , function leaves the state unchanged, while S uses the final state of the first computation as the initial state of the second.>The parametrizable state monad.,Computations have access to a mutable state.The , function leaves the state unchanged, while S uses the final state of the first computation as the initial state of the second.?<Constructor for computations in the state monad transformer.@AConstructor for computations in the state monad (the inverse of D).ARuns a =T with the given initial state and returns both the final value and the final state.BRuns a =W with the given initial state and returns the final value, discarding the final state.CRuns a =W with the given initial state and returns the final state, discarding the final value.DRuns a >T with the given initial state and returns both the final value and the final state.ERuns a >W with the given initial state and returns the final value, discarding the final state.FRuns a >W with the given initial state and returns the final state, discarding the final value.G6Fetch the current value of the state within the monad.H,Set the value of the state within the monad. =>?@ABCDEFGH =>?@ABCDEFGH >@DEF=?ABCGH =>?@ABCDEFGHNone '3579>LISee '(.J1Return the state from the internals of the monad.K#Replace the state inside the monad.L+Embed a simple state action into the monad.M(Modifies the state inside a state monad.NKGets specific component of the state, using a projection function supplied. IJKLMNIJKLMNIJKLMNIJKLMN)None12356789:IJKLMNIJKLMN289:13567*None12356789:IJKLMNNone&NOSee )(.PSee )+.QSee ),.RSee )-.SSee )..TSee )/.USee )0.VSee )1.WSee )2.XSee )3.YSee )4.ZSee )5.[See )6.\See )7.]See )8.OPQRSTUVWXYZ[\]OPQRSTUVWXYZ[\]OY[\]ZPTVXQRSUWOPQRSTUVWXYZ[\]9NoneOPQRSTUVWXYZ[\]:None=>?ABCDEFIJKLMNIJKLMN>DEF=?ABC None&N^See :(._See :+.`See :,.aSee :-.bSee :..cSee :/.dSee :0.eSee :1.fSee :2.gSee :3.hSee :4.iSee :5.jSee :6.kSee :7.lSee :8.^_`abcdefghijkl^_`abcdefghijkl^hjkli_ceg`abdf^_`abcdefghijkl None '(0357>CLm The exception monad transformer.The ( function returns a normal value, while  exits on the first exception.n$The parameterizable exception monad.4Computations are either exceptions or normal values.The ( function returns a normal value, while  exits on the first exception.oRuns an n3 and returns either an exception or a normal value.p@Constructor for computations in the exception monad transformer.qEConstructor for computations in the exception monad (the inverse of o).rRuns an m3 and returns either an exception or a normal value.sCIs used within a monadic computation to begin exception processing.tPA handler function to handle previous exceptions and return to normal execution.mnopqrstmnopqrstnqomprstmnopqrst None '3579>LuSee ;<.vCIs used within a monadic computation to begin exception processing.wQA handler function to handle previous exceptions and return to normal execution.uvwuvwuvwuvw NonexRuns an n3 and handles the exception with the given function.yRuns an m3 and handles the exception with the given function.xy mnopruvwxy uvwnompryxxy None&N zSee  =.{See  >.|See  ?.}See  @.~See  A.See  B.See  C.See  D.See  E.See  F. z{|}~ z{|}~ |}~{z z{|}~None '(0357>CLUThe reader monad transformer, which adds a read-only environment to the given monad.The ) function ignores the environment, while ; passes the inherited environment to both subcomputations.!The parameterizable reader monad.3Computations are functions of a shared environment.The ) function ignores the environment, while ; passes the inherited environment to both subcomputations.=Constructor for computations in the reader monad transformer.BConstructor for computations in the reader monad (the inverse of ).Runs a 9 with the given environment and returns the final value.Runs a 9 with the given environment and returns the final value.#Fetch the value of the environment.FExecute a computation in a modified environment (a specialization of  withReaderT).  tag ( tag f m) =  tag m . f'The function to modify the environment./Computation to run in the modified environment.None '3579>LSee GH. 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.'The function to modify the environment.Reader$ to run in the modified environment.2The selector function to apply to the environment.2The selector function to apply to the environment.None'(0357>CLN@Wrap a monad to change its tags. Under the hood this is simply ., all the work is happening on the type level."Encode type-level information for ."Encode type-level information for .Type-restricted .Type-restricted .&Attach a tag to untagged transformers.Replace a tag with another tag.INone None&N See IH.See IJ.See IK.See IL.See IM.See IN.See IO.See IP.See IQ.See IR. None-Creates a tag and a value-level proxy for it. "Foo" "foo" generates the following code: %data Foo foo :: Proxy Foo foo = ProxySNonef#$%&'()*+,-./0OPQRSTUVWXYZ[\]z{|}~TNonef !"12356789:IJKLMNmnopruvwxyNone&(>KL)Reify a list of constraint abbreviations. Bf :: Ether '[Foo --> r, Bar <-- w, Baz <-> s, Quux -!- e] m => m a expands into }f :: ( MonadReader Foo r m , MonadWriter Bar w m , MonadState Baz s m , MonadExcept Quux e m ) => m aDenotes u.Denotes Ir. The mnemonic is that you can both read from and write into the state, thus the arrow points in both directions.Denotes 0. The mnemonic is that you write values of type w& to the writer accumulator tagged by tag, thus the arrows points from w to tag.Denotes /. The mnemonic is that you read values of type r( from the reader environment tagged by tag, thus the arrows points from tag to r.0Turns an abbreviation into an actual constraint.  None>LDenotes |.Denotes O.Denotes %.Denotes .     UUVWXYZ[\]^_`abcd#$!%"  !"#$%,+-7.02/1346,+-7.02/1346(46785(+,-./012345678 ( + , - . / 0 1 2 3 4 5 6 7 8 = > B C e D @ A ? @ A E F = > ? @ A B C D E FKJLQMNPOHPOQRfghijklHJKLMNOPQRmnopqrstuvwxyz{|}~~~~ VWf~~~y~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ether_9FddITpA6aY84hoTs1Ts29 Control.Monad.Trans.Ether.Tagged Control.Monad.Trans.Ether.Writer Control.Monad.Ether.Writer.Class#Control.Monad.Ether.Implicit.Writer$Control.Monad.Trans.Ether.State.Lazy&Control.Monad.Trans.Ether.State.StrictControl.Monad.Ether.State.Class'Control.Monad.Ether.Implicit.State.Lazy)Control.Monad.Ether.Implicit.State.Strict Control.Monad.Trans.Ether.Except Control.Monad.Ether.Except.ClassControl.Monad.Ether.Except#Control.Monad.Ether.Implicit.Except Control.Monad.Trans.Ether.Reader Control.Monad.Ether.Reader.Class"Control.Monad.Trans.Ether.Dispatch#Control.Monad.Ether.Implicit.ReaderControl.Ether.THControl.Ether.AbbrControl.Ether.Implicit.AbbrControl.Ether.UtilControl.Monad.Writer MonadWriterControl.Monad.Ether.WriterWriterTWriterwritertelllistenpasslistenscensor runWriter execWriterwriterT runWriterT execWriterTControl.Monad.Trans.Ether.StateControl.Monad.State MonadStateControl.Monad.Ether.State.LazyControl.Monad.Ether.StateStateStateTstateT runStateTrunState evalStateT evalState execStateT execStategetgetsputstatemodify"Control.Monad.Ether.Implicit.State Control.Monad.Ether.State.StrictControl.Monad.Except MonadErrorExceptTExcept MonadExceptthrowcatch runExceptexceptT runExceptThandlehandleTControl.Monad.Reader MonadReaderControl.Monad.Ether.ReaderReaderReaderTreaderT runReaderT runReaderlocalaskreaderasksControl.Monad.Ether.ImplicitControl.Monad.Ether TaggedTranspackunpack$fMonadErroreTaggedTrans$fMonadWriterwTaggedTrans$fMonadStatesTaggedTrans$fMonadReaderrTaggedTrans$fMonadContTaggedTrans$fLiftCallCCTaggedTrans$fLiftPassTaggedTrans$fLiftListenTaggedTrans$fLiftCatchTaggedTrans$fLiftLocalTaggedTrans$fMonadBaseControlbTaggedTrans$fMonadTransControlTaggedTrans$fMonadBasebTaggedTransexcept DispatchT K_TagReplace TagReplace K_TagAttach TagAttach tagAttach tagReplaceetherealEther-!-<-><----> ReifyAbbrESWRMonadApplicativefmapghc-primGHC.PrimcoerceTFCo:R:StTTaggedTransabaseGHC.Basereturnmempty>>=mappend$fMonadWriterktagwt$fMonadWriterktagwTaggedTrans$fMonadStatektagst$fMonadStatektagsTaggedTrans$fMonadStatektagsTaggedTrans0$fMonadExceptktaget$fMonadExceptktageTaggedTrans$fMonadReaderktagrt$fMonadReaderktagrTaggedTranstrans_GZTjP9K5WFq01xC9BAGQpFControl.Monad.Trans.Identity IdentityTDispatchTagReplaceTDispatchTagAttachT$fMonadWriterktOldwDispatchT$fMonadExceptktOldeDispatchT$fMonadStatektOldsDispatchT$fMonadReaderktOldrDispatchT$fMonadWriterwDispatchT$fMonadErroreDispatchT$fMonadStatesDispatchT$fMonadReaderrDispatchT$fLiftCallCCDispatchT$fLiftPassDispatchT$fLiftListenDispatchT$fLiftCatchDispatchT$fLiftLocalDispatchTTFCo:R:StTDispatchTa$fMonadBaseControlbDispatchT$fMonadTransControlDispatchT$fMonadBasebDispatchT emptyDataDecl funSimple proxySimplefail>>Control.Monad.Fixmfix Control.MonadguardjoinMonadFunctorMonadFixmfilter<$!>unless replicateM_ replicateMfoldM_foldM zipWithM_zipWithM mapAndUnzipMforever<=<>=>filterMData.TraversableforMsequencemapM Data.Foldablemsum sequence_forM_mapM_ Data.Functionfix Data.FunctorvoidapliftM5liftM4liftM3liftM2liftMwhen=<<mplusmzero MonadPlusTFCo:R:ReifyAbbr-!-mTFCo:R:ReifyAbbr<->mTFCo:R:ReifyAbbr<--mTFCo:R:ReifyAbbr-->mTFCo:R:ReifyAbbrEmTFCo:R:ReifyAbbrSmTFCo:R:ReifyAbbrWmTFCo:R:ReifyAbbrRm