X      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQ R S T U 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 { | } ~  Safe*None *+59;<=DIRTagged monad transformer.Type-restricted .Type-restricted .   None +,59;<=DIR The exception monad transformer.The ( function returns a normal value, while  exits on the first exception. $The parameterizable exception monad.4Computations are either exceptions or normal values.The ( function returns a normal value, while  exits on the first exception.!Runs an  3 and returns either an exception or a normal value."@Constructor for computations in the exception monad transformer.#EConstructor for computations in the exception monad (the inverse of !).$Runs an 3 and returns either an exception or a normal value.%CIs used within a monadic computation to begin exception processing.&PA handler function to handle previous exceptions and return to normal execution. !"#$%& !"#$%& #!"$%& !"#$%&None +9;<=?DR'See .(CIs used within a monadic computation to begin exception processing.)QA handler function to handle previous exceptions and return to normal execution.'()*+')('()'()*+None,Runs an  3 and handles the exception with the given function.-Runs an 3 and handles the exception with the given function.,-  !"$')(,- '() !"$-,,-None*T .See ./See .0See .1See .2See .3See .4See .5See .6See  .7See !. ./01234567 ./01234567 012/3.4567 ./01234567None +,59;<=DIR8UThe 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.9!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 89 with the given environment and returns the final value.=Runs a 89 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 . f89:;<=>?'The function to modify the environment./Computation to run in the modified environment.89:;<=>?9;=8:<>?89:;<=>?None +9;<=?DR@See "#.A Retrieves the monad environment.B1Executes a computation in a modified environment.C0Retrieves a function of the current environment.D0Retrieves a function of the current environment.@ABCD2The selector function to apply to the environment.EF@ABCD@ABCD@ABCDEF$None 89:<=@ABCD @ABCD9=8:<None*T GSee $#.HSee $%.ISee $&.JSee $'.KSee $(.LSee $).MSee $*.NSee $+.OSee $,.PSee $-. GHIJKLMNOP GHIJKLMNOP GMNOPHLIJK GHIJKLMNOP None +,59;<=DIR QThe 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.RThe 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.S<Constructor for computations in the state monad transformer.TAConstructor for computations in the state monad (the inverse of X).URuns a QT with the given initial state and returns both the final value and the final state.VRuns a QW with the given initial state and returns the final value, discarding the final state.WRuns a QW with the given initial state and returns the final state, discarding the final value.XRuns a RT with the given initial state and returns both the final value and the final state.YRuns a RW with the given initial state and returns the final value, discarding the final state.ZRuns a RW 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. QRSTUVWXYZ[\ QRSTUVWXYZ[\ RTXYZQSUVW[\ QRSTUVWXYZ[\.None QRSTUVWXYZ[\ None +,59;<=DIR ]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 ]^_`abcdefgh None +9;<=?DRiSee /0.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. ijklmnopqijklmnijklmnijklmnopq1NoneQRSUVWXYZijklmnijklmnRXYZQSUVW None*TrSee 10.sSee 12.tSee 13.uSee 14.vSee 15.wSee 16.xSee 17.ySee 18.zSee 19.{See 1:.|See 1;.}See 1<.~See 1=.See 1>.See 1?.rstuvwxyz{|}~rstuvwxyz{|}~r|~}swy{tuvxzrstuvwxyz{|}~@Nonerstuvwxyz{|}~ANoneQRSUVWXYZijklmnBNone]^_abcdefijklmnijklmn^def]_abc None*TSee B0.See B2.See B3.See B4.See B5.See B6.See B7.See B8.See B9.See B:.See B;.See B<.See B=.See B>.See B?.None+,59;<=DIR 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 +9;<=?DRSee CD.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. ENoneNone*TSee EF.See EG.See ED.See EH.See EI.See EJ.See EK.See EL.See EM.See EN.See EO.See EP.See EQ.See ER.None+,59;<=DIRT@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.None-Creates a tag and a value-level proxy for it. "Foo" "foo" generates the following code: %data Foo foo :: Proxy Foo foo = ProxySNoneg      !"$')(,-89:<=@ABCDQRSUVWXYZijklmnTNoneg     ./01234567GHIJKLMNOPrstuvwxyz{|}~None*,DQR)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 '.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.NoneDRDenotes 0.Denotes r.Denotes .Denotes G.UUVWXYZ[\]^_`abcdefghijklmnopqrstu ! !&%',()+*#+*,-vw#%&'()*+,- 3 2 4 > 5 7 9 6 8 : ; = 3 2 4 > 5 7 9 6 8 : ; = 0 ; = > ? < x y z 0 2 3 4 5 6 7 8 9 : ; < = > ? 0 2 3 4 5 6 7 8 9 : ; < = > ?FGPHQNROIJKDHIJKLM{|FGDHIJKLMNOPQR}}~VW$ether-0.4.1.0-Ct4ST2coiPMBtQpHrUtzac Control.Monad.Trans.Ether.Tagged 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.Ether.Implicit.Reader$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.Writer Control.Monad.Ether.Writer.Class#Control.Monad.Ether.Implicit.Writer"Control.Monad.Trans.Ether.DispatchControl.Ether.THControl.Ether.AbbrControl.Ether.Implicit.AbbrControl.Ether.UtilControl.Monad.Except MonadErrorExceptTExcept MonadExceptthrowcatch runExceptexceptT runExceptThandlehandleTControl.Monad.Reader MonadReaderControl.Monad.Ether.ReaderReaderReaderTreaderT runReaderT runReaderlocalaskreaderasksControl.Monad.Trans.Ether.StateControl.Monad.State MonadStateControl.Monad.Ether.State.LazyStateStateTstateT runStateTrunState evalStateT evalState execStateT execStategetgetsputstatemodify"Control.Monad.Ether.Implicit.StateControl.Monad.Ether.State Control.Monad.Ether.State.StrictControl.Monad.Writer MonadWriterControl.Monad.Ether.WriterWriterTWriterwritertelllistenpasslistenscensor runWriter execWriterwriterT runWriterT execWriterTControl.Monad.EtherControl.Monad.Ether.Implicit TaggedTranspackunpack$fMonadErroreTaggedTrans$fMonadWriterwTaggedTrans$fMonadStatesTaggedTrans$fMonadReaderrTaggedTrans$fMonadContTaggedTrans$fLiftCallCCTaggedTrans$fLiftPassTaggedTrans$fLiftListenTaggedTrans$fLiftCatchTaggedTrans$fLiftLocalTaggedTrans$fMonadBaseControlbTaggedTrans$fMonadTransControlTaggedTrans$fMonadBasebTaggedTrans$fGenericTaggedTrans$fFunctorTaggedTrans$fApplicativeTaggedTrans$fAlternativeTaggedTrans$fMonadTaggedTrans$fMonadPlusTaggedTrans$fMonadFixTaggedTrans$fMonadTransTaggedTrans$fMonadIOTaggedTrans$fMFunctorTaggedTrans$fMMonadTaggedTrans$fMonadThrowTaggedTrans$fMonadCatchTaggedTrans$fMonadMaskTaggedTransexcept$fMonadExceptktaget$fMonadExceptktageTaggedTrans$fMonadReaderktagrt$fMonadReaderktagrTaggedTrans$fMonadStatektagst$fMonadStatektagsTaggedTrans$fMonadStatektagsTaggedTrans0$fMonadWriterktagwt$fMonadWriterktagwTaggedTrans DispatchT K_TagReplace TagReplace K_TagAttach TagAttach tagAttach tagReplace$fMonadWritertOldtOldwDispatchT$fMonadExcepttOldtOldeDispatchT$fMonadStatetOldtOldsDispatchT$fMonadReadertOldtOldrDispatchT$fMonadWriterwDispatchT$fMonadErroreDispatchT$fMonadStatesDispatchT$fMonadReaderrDispatchT$fLiftCallCCDispatchT$fLiftPassDispatchT$fLiftListenDispatchT$fLiftCatchDispatchT$fLiftLocalDispatchT$fMonadBaseControlbDispatchT$fMonadTransControlDispatchT$fMonadBasebDispatchT$fGenericDispatchT$fFunctorDispatchT$fApplicativeDispatchT$fAlternativeDispatchT$fMonadDispatchT$fMonadPlusDispatchT$fMonadFixDispatchT$fMonadTransDispatchT$fMonadIODispatchT$fMFunctorDispatchT$fMMonadDispatchT$fMonadThrowDispatchT$fMonadCatchDispatchT$fMonadMaskDispatchTetherealEther-!-<-><----> ReifyAbbrESWRMonadApplicativefmapghc-primGHC.PrimcoercebaseGHC.Basereturn>>=memptymappendtransformers-0.5.2.0Control.Monad.Trans.Identity IdentityTDispatchTagReplaceTDispatchTagAttachT emptyDataDecl funSimple proxySimple Control.MonadguardjoinMonad>>failFunctorControl.Monad.FixMonadFixmfixData.TraversablemapMsequencemfilter<$!>unless replicateM_ replicateMfoldM_foldM zipWithM_zipWithM mapAndUnzipMforever<=<>=>filterMforM Data.Foldablemsum sequence_forM_mapM_ Data.Functionfix Data.FunctorvoidapliftM5liftM4liftM3liftM2liftMwhen=<< MonadPlusmzeromplus