úÎíGÙ#Á      !"#$%&'()*+,-./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'(=JKÄÅÆÇÈÉÄÅÆÇÈÉÄÅÆÇÈÉNone&'(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)ú*+,-./0123456789ûüýþÿNone)*+,-./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:;<=>?@ABCDEFGHIJ   None (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.K LMNOPQRSTUVW  KLMNOPQRSTUVW LOMKNPQRSTUVWK LMNOPQRSTUVW 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%&'()*+,-./012345hijklmhijklmhijklm%&'()*+,-./012345&None)*+-./0123hijklmhijklm*012)+-./3'None)*+-./0123hijklm None&MnSee &%.oSee &(.pSee &).qSee &*.rSee &+.sSee &,.tSee &-.uSee &..vSee &/.wSee &0.xSee &1.ySee &2.zSee &3.{See &4.|See &5.}See &6.nopqrstuvwxyz{|}nopqrstuvwxyz{|}ny{|}zosuwpqrtvxnopqrstuvwxyz{|}7Nonenopqrstuvwxyz{|}8None:;<>?@ABCDhijklmhijklm;ABC:<>?@D None&M~See 8%.See 8(.€See 8).See 8*.‚See 8+.ƒSee 8,.„See 8-.…See 8..†See 8/.‡See 80.ˆSee 81.‰See 82.ŠSee 83.‹See 84.ŒSee 85.See 86.~€‚ƒ„…†‡ˆ‰Š‹Œ~€‚ƒ„…†‡ˆ‰Š‹Œ~‰‹ŒŠƒ…‡€‚„†ˆ~€‚ƒ„…†‡ˆ‰Š‹Œ None2468ŽSee 9:.CIs used within a monadic computation to begin exception processing.QA handler function to handle previous exceptions and return to normal execution.Ž6789:;<=>?@ABCDŽŽŽ6789:;<=>?@ABCDNone‘Runs an L3 and handles the exception with the given function.’Runs an K3 and handles the exception with the given function.‘’ KLMNPQŽ‘’ ŽLMKNPQ’‘‘’None&M “See ;.”See <.•See =.–See >.—See ?.˜See @.™See A.šSee B.›See CJ. Note that due to implicit tagging the exception type cannot be changed.œSee D.See E. “”•–—˜™š›œ “”•–—˜™š›œ •–—”˜“™š›œ “”•–—˜™š›œNone2468žSee FG.Ÿ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.žŸ ¡¢£¤EFGHIJKLMNOPQžŸ ¡¢£¤žŸ ¡¢£¤žŸ ¡¢£¤EFGHIJKLMNOPQNone246BM¥#Wrap a monad to attach a tag to it.¨6Annotate a polymorphic monadic computation with a tag. ¥¦§¨RSTUVWXY¥¦§¨¥¦§¨ ¥¦§¨RSTUVWXYHNone !žŸ ¡¢£¤žŸ ¡¢£¤ !INonefZå[\ä]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ  !)*+-./0123KLMNPQXYZ[\hijklmŽ‘’žŸ ¡¢£¤¥¦§¨None&(=JK©)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 aªDenotes Ž.«Denotes hr. The mnemonic is that you can both read from and write into the state, thus the arrow points in both directions.¬Denotes ž+. The mnemonic is that you write values of w& to the writer accumulator tagged by tag, thus the arrows points from w to tag.­Denotes X/. 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&M¯See HJ.°See HK.±See HG.²See HL.³See HM.´See HN.µSee HO.¶See HP.·See HQ.¸See HR.¹See HS.ºSee HT.»See HU.¼See HV.¯°±²³´µ¶·¸¹º»¼¯°±²³´µ¶·¸¹º»¼±²³´µ¶·°¸¹¯º»¼¯°±²³´µ¶·¸¹º»¼WNone`Zå[\ä]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ]^_`abcdefgnopqrstuvwxyz{|}“”•–—˜™š›œ¯°±²³´µ¶·¸¹º»¼None=K½Denotes •.¾Denotes n.¿Denotes ±.ÀDenotes ].½¾¿Àˆ‰Š‹½¾¿ÀÀ¿¾½½¾¿Àˆ‰Š‹ŒXYZ[\]^_`abcd"efg! JKTLURVShMNOfgij)(*5+-/,.0124fikj)(*5+-/,.0124fikj;<@AlBC>?gijf! "#        ! " # % 2 4 5 6 3 % ( ) * + , - . / 0 1 2 3 4 5 6 % ( ) * + , - . / 0 1 2 3 4 5 6 = > ?DE;<=>?@ABCDEGLMNOPQmnopqrstuvJKGLMNOPQRSTUVwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ„… „…¡¢£¤¥¦§¨„©ª„©«J¬­®¯°±‹²)³´µ¶·¸¹)³´µ¶·¸¹;º»¼½¾¿“ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐ Ñ Ò Ó Ô Õ Ö × Ø Ù Ú Û Ü Ý Þ ß à á â ã ä å æ ç è é ê ë ì í î ï ðñòóôõö÷øùúûüýþÿ„…„…„…ƒ„ „  „  „  „…„…„„ „„ „ „ „ „ „ „ „ „ „ „ „ „  „ !„ "„ #„ $„ %„ &„ '„ („ )„ *„ +„ ,„ -„ .„ /„ 0„ 123456789: ether-0.2.1.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.WrappedControl.Ether.Abbr#Control.Monad.Ether.Implicit.WriterControl.Ether.Implicit.AbbrControl.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 unwrapEtheretheredEther-!-<-><----> ReifyAbbrESWR 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=<<mplusmzeroTFCo:R:ReifyAbbr-!-mTFCo:R:ReifyAbbr<->mTFCo:R:ReifyAbbr<--mTFCo:R:ReifyAbbr-->mTFCo:R:ReifyAbbrEmTFCo:R:ReifyAbbrSmTFCo:R:ReifyAbbrWmTFCo:R:ReifyAbbrRm