̫      !"#$%&'()*+,-./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 = ProxyCompose  n times. $( 5) = fmap.fmap.fmap.fmap.fmap a function n levels deep. $( 3 [| f |]) = $( 3) f ($( 2) f ($( 1) f id))Safe'(>KLNone&'(134579>KL 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 (03457>CKL 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 (03457>CKLThe 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 (03457>CKL+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 2)./Runs a +T with the given initial state and returns both the final value and the final state.0Runs a +W with the given initial state and returns the final value, discarding the final state.1Runs a +W with the given initial state and returns the final state, discarding the final value.2Runs a ,T with the given initial state and returns both the final value and the final state.3Runs a ,W with the given initial state and returns the final value, discarding the final state.4Runs a ,W with the given initial state and returns the final state, discarding the final value.5#Transform the computation inside a +. / tag (5 tag f m) = f . / tag m66Fetch the current value of the state within the monad.7,Set the value of the state within the monad.8Lift a catchE operation to the new monad.9Lift a listen operation to the new monad.:In-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).;Lift a pass operation to the new monad.+,-./0123456789:;+,-./0123456789:;,.234+-/015678:9;+,-./0123456789:;None+,-./0123456789:;None (03457>CKL<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 C).@Runs a <T with the given initial state and returns both the final value and the final state.ARuns a <W with the given initial state and returns the final value, discarding the final state.BRuns a <W with the given initial state and returns the final state, discarding the final value.CRuns a =T with the given initial state and returns both the final value and the final state.DRuns a =W with the given initial state and returns the final value, discarding the final state.ERuns a =W with the given initial state and returns the final state, discarding the final value.F#Transform the computation inside a <. @ tag (F tag f m) = f . @ tag mG6Fetch the current value of the state within the monad.H,Set the value of the state within the monad.ILift a catchE operation to the new monad.JLift a listen operation to the new monad.KIn-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).LLift a pass operation to the new monad.<=>?@ABCDEFGHIJKL<=>?@ABCDEFGHIJKL=?CDE<>@ABFGHIKJL<=>?@ABCDEFGHIJKLNone (03457>CKL M 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.S%Transforms the computation inside an M. R tag (S tag f m) = f (R tag m)TCIs used within a monadic computation to begin exception processing.UPA handler function to handle previous exceptions and return to normal execution.VLift a callCC operation to the new monad.WLift a listen operation to the new monad.XLift a pass operation to the new monad.YLift a catchE operation to the new monad.MNOPQRSTUVWXY  MNOPQRSTUVWXY NQOMPRSTUVWXYMNOPQRSTUVWXY  None&(34579>CIKLNZSee .[ 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.Z[\'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.   Z[\]^Z[\]^Z[\]^   None Z[\]^ Z[\]^ None&N _See .`See .aSee .bSee .cSee .dSee .eSee .fSee .gSee .hSee  .iSee !. _`abcdefghi _`abcdefghi _fghi`dabce _`abcdefghi None&(34579>CIKLNjSee "#.k1Return the state from the internals of the monad.l#Replace the state inside the monad.m+Embed a simple state action into the monad.n(Modifies the state inside a state monad.oKGets specific component of the state, using a projection function supplied.jklmno !"#$%&'()*+jklmnojklmnojklmno !"#$%&'()*+$None+,-/012345jklmnojklmno,234+-/015%None+,-/012345jklmno None&NpSee $#.qSee $&.rSee $'.sSee $(.tSee $).uSee $*.vSee $+.wSee $,.xSee $-.ySee $..zSee $/.{See $0.|See $1.}See $2.~See $3.See $4.pqrstuvwxyz{|}~pqrstuvwxyz{|}~p{}~|quwyrstvxzpqrstuvwxyz{|}~5Nonepqrstuvwxyz{|}~6None<=>@ABCDEFjklmnojklmno=CDE<>@ABF None&NSee 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. None&(34579>CIKLNSee 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:9None MNOPRS NOMPRSNone&N See 9:.See 9;.See 9<.See 9=.See 9>.See 9?.See 9@.See 9A.See 9BJ. Note that due to implicit tagging the exception type cannot be changed. NoneBasic building block for  . Runs an  with a handler.Handle n# exceptions with supplied handlers. c$(try 3) monadicComputation (\Exception1 -> ...) (\Exception2 -> ...) (\Exception3 -> ...)None&(34579>CIKLNSee 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.;<=>?@ABCDEFG;<=>?@ABCDEFGNone3457CN#Wrap a monad to attach a tag to it.6Annotate a polymorphic monadic computation with a tag. HIJKLMNO HIJKLMNOENone !"# "!#None&NSee 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.PSTUVWXYZ[\]^_`a bcdFGPHQNROeIJKcdfg'&(3)+-*,./02cfhg'&(3)+-*,./02cfhg:;?@iAB=>dfgc !          ! # 0 2 3 4 1 # & ' ( ) * + , - . / 0 1 2 3 4 # & ' ( ) * + , - . / 0 1 2 3 4 < = >:;<=>?@ABjkDHIJKLMlmnoFGDHIJKLMNOPQRpqrstuvwxyzpq{|}~pqpqpqpqF'': ether_H28FzcpfjEu1NiwcpOwFT9Control.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.Class#Control.Monad.Ether.Implicit.Except&Control.Monad.Ether.Implicit.Except.TH 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 MonadErrorControl.Monad.Ether.ExceptExceptTExcept MonadExceptthrowcatch runExceptexceptT runExceptT mapExceptTControl.Monad.Writer MonadWriterControl.Monad.Ether.WriterWriterTWriterwritertelllistenpasslistenscensor runWriter execWriterwriterT runWriterT execWriterTetherealfmapNdeepNTaggedUntaggedtaggeduntaggedTagsInnersTaggableTagInner UniqueTags UniqueTagensureUniqueTags withReaderT liftCatch liftCallCC mapWriterT liftListenliftPass liftCallCC'excepttry'try WrappedEther WrapEther unwrapEtheretheredbaseGHC.Basefmap emptyDataDecl funSimple proxySimple MaybeToList++liftCatch_ExceptTliftListen_WriterTliftPass_WriterTidInners' 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$fNewtypeReaderTmemptymappend$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$fMonadReaderrWrappedEther