ʯ      !"#$%&'()*+,-./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 { | } ~  None-Creates a tag and a value-level proxy for it. "Foo" "foo" generates the following code: %data Foo foo :: Proxy Foo foo = Proxy Safe-Inferred'(=JKNone&'(12468=JK The h type class establishes a relationship between a tagged monad transformer and its untagged counterpart.The ] type function returns a type-level list of all tags in a monad transformer stack. Requires  instances.The # type function recursively applies  / and returns the results in a type-level list.The h class defines the type families to manage tags in monad transformer stacks. Its kind is restricted to * -> *! to prevent incorrect instances.The  type family equals Nothing> for most types, but for tagged monad transformers it equals Just tag. The   type family equals Nothing> for most types, but for monad transformers with inner monad m it equals Just m. The   constraint placed on a type variable representing a monad transformer stack ensures that every tag in the stack appears only once. The main purpose of the   class is to provide clear error messages when the tag uniqueness property is violated. You should never write instances for it unless you know what you're doing. Type-restricted version of  that adds a  + constraint to the provided monadic value.%     None (0246=BK UThe 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 vinal value.Runs a  9 with the given environment and returns the vinal value.#Transform the computation inside a  .  tag ( tag f m) = f .  tag mLExecute a computation in a modified environment (a more general version of ).  tag ( tag f m) =  tag m . fLift a catchE operation to the new monad.Lift a callCC operation to the new monad.#Fetch the value of the environment.FExecute a computation in a modified environment (a specialization of ).  tag ( tag f m) =  tag m . f 'The function to modify the environment./Computation to run in the modified environment.'The function to modify the environment./Computation to run in the modified environment.    None (0246=BKThe 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.!#Transform the computation inside a .  tag (! tag f m) = f ( tag m)"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.%Lift a catchE operation to the new monad.&Lift a callCC operation to the new monad.'Lift a listen operation to the new monad.(Lift a pass operation to the new monad. !"#$%&'( !"#$%&'( !"#$&%'( !"#$%&'(None (0246=BK)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 0).-Runs a )T with the given initial state and returns both the final value and the final state..Runs a )W with the given initial state and returns the final value, discarding the final state./Runs a )W with the given initial state and returns the final state, discarding the final value.0Runs a *T with the given initial state and returns both the final value and the final state.1Runs a *W with the given initial state and returns the final value, discarding the final state.2Runs a *W with the given initial state and returns the final state, discarding the final value.3#Transform the computation inside a ). - tag (3 tag f m) = f . - tag m46Fetch the current value of the state within the monad.5,Set the value of the state within the monad.6Lift a catchE operation to the new monad.7Lift a listen operation to the new monad.8In-situ lifting of a callCC operation to the new monad. This version uses the current state on entering the continuation. It does not satisfy the uniformity property (see Control.Monad.Signatures).9Lift a pass operation to the new monad.)*+,-./0123456789)*+,-./0123456789*,012)+-./3456879)*+,-./0123456789None)*+,-./0123456789None (0246=BK: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 A).>Runs a :T with the given initial state and returns both the final value and the final state.?Runs a :W with the given initial state and returns the final value, discarding the final state.@Runs a :W with the given initial state and returns the final state, discarding the final value.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.D#Transform the computation inside a :. > tag (D tag f m) = f . > tag mE6Fetch the current value of the state within the monad.F,Set the value of the state within the monad.GLift a catchE operation to the new monad.HLift a listen operation to the new monad.IIn-situ lifting of a callCC operation to the new monad. This version uses the current state on entering the continuation. It does not satisfy the uniformity property (see Control.Monad.Signatures).JLift a pass operation to the new monad.:;<=>?@ABCDEFGHIJ:;<=>?@ABCDEFGHIJ;=ABC:<>?@DEFGIHJ:;<=>?@ABCDEFGHIJNone (0246=BK K The exception monad transformer.The ( function returns a normal value, while  exits on the first exception.L$The parameterizable exception monad.4Computations are either exceptions or normal values.The ( function returns a normal value, while  exits on the first exception.MRuns an L3 and returns either an exception or a normal value.N@Constructor for computations in the exception monad transformer.OEConstructor for computations in the exception monad (the inverse of M).PRuns an K3 and returns either an exception or a normal value.Q%Transforms the computation inside an K. P tag (Q tag f m) = f (P tag m)RCIs used within a monadic computation to begin exception processing.SPA handler function to handle previous exceptions and return to normal execution.TLift a callCC operation to the new monad.ULift a listen operation to the new monad.VLift a pass operation to the new monad.WLift a catchE operation to the new monad.KLMNOPQRSTUVW  KLMNOPQRSTUVW LOMKNPQRSTUVWKLMNOPQRSTUVW  None2468XSee .Y Retrieves the monad environment.Z1Executes a computation in a modified environment.[0Retrieves a function of the current environment.\0Retrieves a function of the current environment.XYZ'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.   XYZ[\XYZ[\XYZ[\   None XYZ[\ XYZ[\  None&M ]See .^See ._See .`See .aSee .bSee .cSee .dSee .eSee .fSee  .gSee !. ]^_`abcdefg ]^_`abcdefg ]defg^b_`ac ]^_`abcdefg None2468hSee "#.i1Return the state from the internals of the monad.j#Replace the state inside the monad.k+Embed a simple state action into the monad.l(Modifies the state inside a state monad.mKGets specific component of the state, using a projection function supplied.hijklm !"#$%&'()*+hijklmhijklmhijklm !"#$%&'()*+$None)*+-./0123hijklmhijklm*012)+-./3%None)*+-./0123hijklm None&MnSee $#.oSee $&.pSee $'.qSee $(.rSee $).sSee $*.tSee $+.uSee $,.vSee $-.wSee $..xSee $/.ySee $0.zSee $1.{See $2.|See $3.}See $4.nopqrstuvwxyz{|}nopqrstuvwxyz{|}ny{|}zosuwpqrtvxnopqrstuvwxyz{|}5Nonenopqrstuvwxyz{|}6None:;<>?@ABCDhijklmhijklm;ABC:<>?@D None&M~See 6#.See 6&.See 6'.See 6(.See 6).See 6*.See 6+.See 6,.See 6-.See 6..See 6/.See 60.See 61.See 62.See 63.See 64.~~~~ None2468See 78.CIs used within a monadic computation to begin exception processing.QA handler function to handle previous exceptions and return to normal execution.,-./0123456789:,-./0123456789:NoneRuns an L3 and handles the exception with the given function.Runs an K3 and handles the exception with the given function. KLMNPQ LMKNPQNone&M See 9.See :.See ;.See <.See =.See >.See ?.See @.See AJ. Note that due to implicit tagging the exception type cannot be changed.See B.See C. None2468See DE.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.;<=>?@ABCDEFG;<=>?@ABCDEFGNone246BM#Wrap a monad to attach a tag to it.6Annotate a polymorphic monadic computation with a tag. HIJKLMNO HIJKLMNOFNone ! !GNonefPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxy  !)*+-./0123KLMNPQXYZ[\hijklmNone&MSee FH.See FI.See FE.See FJ.See FK.See FL.See FM.See FN.See FO.See FP.See FQ.See FR.See FS.See FT.UNone`PQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxy]^_`abcdefgnopqrstuvwxyz{|}zVWXYZ[\]^_`ab cdeHIRJSPTQfKLMdegh'&(3)+-*,./02dgih'&(3)+-*,./02dgih9:>?j@A<=eghd !          ! # 0 2 3 4 1 # & ' ( ) * + , - . / 0 1 2 3 4 # & ' ( ) * + , - . / 0 1 2 3 4 ; < =BC9:;<=>?@ABCEJKLMNOklmnHIEJKLMNOPQRSTopqrstuvwxyz{|}~xyxyxxH''9 xyxyxywxxxxxyxyxxxxx x x x x xxxxxxxxxxxxxxxxxxx x!x"x#x$x%& ether-0.2.0.0Control.Ether.THControl.Ether.Tagged Control.Monad.Trans.Ether.Reader Control.Monad.Trans.Ether.Writer$Control.Monad.Trans.Ether.State.Lazy&Control.Monad.Trans.Ether.State.Strict Control.Monad.Trans.Ether.Except Control.Monad.Ether.Reader.Class#Control.Monad.Ether.Implicit.ReaderControl.Monad.Ether.State.Class'Control.Monad.Ether.Implicit.State.Lazy)Control.Monad.Ether.Implicit.State.Strict Control.Monad.Ether.Except.ClassControl.Monad.Ether.Except#Control.Monad.Ether.Implicit.Except Control.Monad.Ether.Writer.ClassControl.Ether.Wrapped#Control.Monad.Ether.Implicit.WriterControl.Ether.UtilControl.Monad.Trans.Ether.StateControl.Monad.Reader MonadReaderControl.Monad.Ether.ReaderReaderReaderTreaderT runReaderT runReader mapReaderTlocalaskreaderasksControl.Monad.State MonadStateControl.Monad.Ether.State.LazyControl.Monad.Ether.StateStateStateTstateT runStateTrunState evalStateT evalState execStateT execState mapStateTgetgetsputstatemodify"Control.Monad.Ether.Implicit.State Control.Monad.Ether.State.StrictControl.Monad.Except MonadErrorExceptTExcept MonadExceptthrowcatch runExceptexceptT runExceptT mapExceptThandlehandleTControl.Monad.Writer MonadWriterControl.Monad.Ether.WriterControl.Monad.EtherWriterTWriterwritertelllistenpasslistenscensor runWriter execWriterwriterT runWriterT execWriterTControl.Monad.Ether.ImplicitetherealTaggedUntaggedtaggeduntaggedTagsInnersTaggableTagInner UniqueTags UniqueTagensureUniqueTags withReaderT liftCatch liftCallCC mapWriterT liftListenliftPass liftCallCC'except WrappedEther WrapEther unwrapEtherethered emptyDataDecl funSimple proxySimple MaybeToList++liftCatch_ExceptTliftListen_WriterTliftPass_WriterTfmapbaseGHC.BaseidInners' ListMapTagUniqueIsUnique$fTaggableWriterT$fTaggableWriterT0$fTaggableStateT$fTaggableStateT0$fTaggableReaderT$fTaggableMaybeT$fTaggableListT$fTaggableIdentityT$fTaggableExceptT$fTaggableContT $fTaggableST $fTaggableST0$fTaggableProxy$fTaggableEither $fTaggableSTM$fTaggable(->)$fTaggableFirst$fTaggableLast$fTaggableMaybe$fTaggableIdentity $fTaggableIOreturn>>=$fMonadErroreReaderT$fMonadWriterwReaderT$fMonadStatesReaderT$fMonadReaderr'ReaderT$fMonadContReaderT$fTaggedReaderTtag$fNewtypeReaderT Data.Monoidmemptymappend$fMonadErroreWriterT$fMonadWriterw'WriterT$fMonadStatesWriterT$fMonadReaderrWriterT$fMonadContWriterT$fTaggedWriterTtag$fNewtypeWriterT$fMonadErroreStateT$fMonadWriterwStateT$fMonadStates'StateT$fMonadReaderrStateT$fMonadContStateT$fTaggedStateTtag$fNewtypeStateT$fMonadErrore'ExceptT$fMonadWriterwExceptT$fMonadStatesExceptT$fMonadReaderrExceptT$fMonadContExceptT$fTaggedExceptTtag$fNewtypeExceptT$fMonadReadertagrWriterT$fMonadReadertagrWriterT0$fMonadReadertagrStateT$fMonadReadertagrStateT0$fMonadReadertagrReaderT$fMonadReadertagrMaybeT$fMonadReadertagrListT$fMonadReadertagrIdentityT$fMonadReadertagrExceptT$fMonadReadertagrContT$fMonadReadertagrExceptT0$fMonadReadertagrStateT1$fMonadReadertagrStateT2$fMonadReadertagrWriterT1$fMonadReadertagrReaderT0$fMonadReadertagrReaderT1$fMonadStatetagsWriterT$fMonadStatetagsWriterT0$fMonadStatetagsStateT$fMonadStatetagsStateT0$fMonadStatetagsReaderT$fMonadStatetagsMaybeT$fMonadStatetagsListT$fMonadStatetagsIdentityT$fMonadStatetagsExceptT$fMonadStatetagsContT$fMonadStatetagsExceptT0$fMonadStatetagsWriterT1$fMonadStatetagsReaderT0$fMonadStatetagsStateT1$fMonadStatetagsStateT2$fMonadStatetagsStateT3$fMonadStatetagsStateT4$fMonadExcepttageWriterT$fMonadExcepttageWriterT0$fMonadExcepttageStateT$fMonadExcepttageStateT0$fMonadExcepttageReaderT$fMonadExcepttageMaybeT$fMonadExcepttageListT$fMonadExcepttageIdentityT$fMonadExcepttageExceptT$fMonadExcepttageStateT1$fMonadExcepttageStateT2$fMonadExcepttageWriterT1$fMonadExcepttageReaderT0$fMonadExcepttageExceptT0$fMonadExcepttageExceptT1$fMonadWritertagwWriterT$fMonadWritertagwStateT$fMonadWritertagwStateT0$fMonadWritertagwReaderT$fMonadWritertagwMaybeT$fMonadWritertagwIdentityT$fMonadWritertagwExceptT$fMonadWritertagwStateT1$fMonadWritertagwStateT2$fMonadWritertagwExceptT0$fMonadWritertagwReaderT0$fMonadWritertagwWriterT0$fMonadWritertagwWriterT1$fMonadWritertagwWrappedEther$fMonadWriterwWrappedEther$fMonadExcepttageWrappedEther$fMonadErroreWrappedEther$fMonadStatetagsWrappedEther$fMonadStatesWrappedEther$fMonadReadertagrWrappedEther$fMonadReaderrWrappedEtherfail>>Control.Monad.Fixmfix Control.MonadguardliftMjoinMonadFunctorMonadFix MonadPlus Data.FunctionfixmfilterapliftM5liftM4liftM3liftM2unlesswhen replicateM_ replicateMfoldM_foldM zipWithM_zipWithM mapAndUnzipMvoidforever<=<>=>msumforM_forMfilterMmapM_mapM sequence_sequence=<<mplusmzero