˻k      !"#$%&'()*+,-./0123456789:;<=>?@ABCD E F G H I J K L M N O P Q 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 { | } ~  None-Creates a tag and a value-level proxy for it. "Foo" "foo" generates the following code: %data Foo foo :: Proxy Foo foo = ProxySafe'(>KLNone&'(13579>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 (0357>CL 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.#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.   None3579See . 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   None&N See .See .See .See .See .See . See .!See ."See  .#See !.  !"#  !"#  !"#  !"#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.$%&'()*+,-. $%&'()*+,-. %')+$&(*,-.$%&'()*+,-.None3579/See "#.0Embed a simple writer action.13Append a value to the accumulator within the monad.2KExecute an action and add its accumulator to the value of the computation.3xExecute an action which returns a value and a function, and return the value, applying the function to the accumulator.4xExecute an action and add the result of applying the given function to its accumulator to the value of the computation.5:Execute an action and apply a function to its accumulator. /012345/012345/012345/012345$None$%&()*+/012345/012345%)+$&(*None&N6See $%.7See $&.8See $#.9See $'.:See $(.;See $).<See $*.=See $+.>See $,.?See $-.@See $..ASee $/.BSee $0.CSee $1.6789:;<=>?@ABC6789:;<=>?@ABC89:;<=>7?@6ABC6789:;<=>?@ABC None (0357>CL DThe 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.EThe 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.F<Constructor for computations in the state monad transformer.GAConstructor for computations in the state monad (the inverse of K).HRuns a DT with the given initial state and returns both the final value and the final state.IRuns a DW with the given initial state and returns the final value, discarding the final state.JRuns a DW with the given initial state and returns the final state, discarding the final value.KRuns a ET with the given initial state and returns both the final value and the final state.LRuns a EW with the given initial state and returns the final value, discarding the final state.MRuns a EW with the given initial state and returns the final state, discarding the final value.N6Fetch the current value of the state within the monad.O,Set the value of the state within the monad.DEFGHIJKLMNO DEFGHIJKLMNO EGKLMDFHIJNODEFGHIJKLMNO2None DEFGHIJKLMNO None (0357>CL PThe 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.QThe 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.R<Constructor for computations in the state monad transformer.SAConstructor for computations in the state monad (the inverse of W).TRuns a PT with the given initial state and returns both the final value and the final state.URuns a PW with the given initial state and returns the final value, discarding the final state.VRuns a PW with the given initial state and returns the final state, discarding the final value.WRuns a QT with the given initial state and returns both the final value and the final state.XRuns a QW with the given initial state and returns the final value, discarding the final state.YRuns a QW with the given initial state and returns the final state, discarding the final value.Z6Fetch the current value of the state within the monad.[,Set the value of the state within the monad.PQRSTUVWXYZ[      PQRSTUVWXYZ[ QSWXYPRTUVZ[PQRSTUVWXYZ[      None3579\See 34.]1Return the state from the internals of the monad.^#Replace the state inside the monad._+Embed a simple state action into the monad.`(Modifies the state inside a state monad.aKGets specific component of the state, using a projection function supplied. \]^_`a\]^_`a\]^_`a\]^_`a5NoneDEFHIJKLM\]^_`a\]^_`aEKLMDFHIJ6NoneDEFHIJKLM\]^_`a None&NbSee 54.cSee 57.dSee 58.eSee 59.fSee 5:.gSee 5;.hSee 5<.iSee 5=.jSee 5>.kSee 5?.lSee 5@.mSee 5A.nSee 5B.oSee 5C.pSee 5D.bcdefghijklmnopbcdefghijklmnopblnopmcgikdefhjbcdefghijklmnopENonebcdefghijklmnopFNonePQRTUVWXY\]^_`a\]^_`aQWXYPRTUV None&NqSee F4.rSee F7.sSee F8.tSee F9.uSee F:.vSee F;.wSee F<.xSee F=.ySee F>.zSee F?.{See F@.|See FA.}See FB.~See FC.See FD.qrstuvwxyz{|}~qrstuvwxyz{|}~q{}~|rvxzstuwyqrstuvwxyz{|}~None (0357>CL 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. !"#$%&'() !"#$%&'()None3579See GH.CIs used within a monadic computation to begin exception processing.QA handler function to handle previous exceptions and return to normal execution.*+*+None0357CN#Wrap a monad to attach a tag to it.6Annotate a polymorphic monadic computation with a tag. ,-./01234 ,-./01234NoneRuns an 3 and handles the exception with the given function.Runs an 3 and handles the exception with the given function. INonec56789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_ $%&()*+/012345DEFHIJKLM\]^_`aNone&(>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 .Denotes \r. 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. `abc `abcNone&N See J.See K.See L.See M.See N.See O.See P.See Q.See R.See S. TNone^56789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_ !"#6789:;<=>?@ABCbcdefghijklmnopNone>LDenotes .Denotes b.Denotes 8.Denotes .defgdefghUVWXYZ[\]^_`a  ! !%&/'0-1.()*#'()*+,%&#'()*+,-./01 8 7 9 C : < > ; = ? @ B 8 7 9 C : < > ; = ? @ B 4 @ B C D A 4 7 8 9 : ; < = > ? @ A B C D 4 7 8 9 : ; < = > ? @ A B C DJKOPbQMNLMNcdefRSghijklJKLMNOPQRSmnopqrstuvwxyz{|}~wxwxwxwx%~ 8  8  Jwxwxwxvwwwxwxwxwwwwwwwwwwwwwwwwwwwwww w  w  wxwxwxwxwxwxwxwxwxwxwx !ether_ENiMCnThSzmCWx7VBK7s3KControl.Ether.THControl.Ether.Tagged Control.Monad.Trans.Ether.Reader Control.Monad.Ether.Reader.Class#Control.Monad.Ether.Implicit.Reader 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.Ether.WrappedControl.Monad.Ether.ExceptControl.Ether.Abbr#Control.Monad.Ether.Implicit.ExceptControl.Ether.Implicit.AbbrControl.Ether.UtilControl.Monad.Reader MonadReaderControl.Monad.Ether.ReaderReaderReaderTreaderT runReaderT runReaderlocalaskreaderasksControl.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 MonadErrorControl.Monad.EtherExceptTExcept MonadExceptthrowcatch runExceptexceptT runExceptThandlehandleTControl.Monad.Ether.ImplicitetherealTaggedUntaggedtaggeduntaggedTagsInnersTaggableTagInner UniqueTags UniqueTagensureUniqueTagsexcept WrappedEther WrapEther unwrapEtheretheredEther-!-<-><----> ReifyAbbrESWR emptyDataDecl funSimple proxySimple MaybeToList++fmapbaseGHC.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$fLiftCallCCReaderT$fLiftPassReaderT$fLiftListenReaderT$fLiftCatchReaderT$fLiftLocalReaderTTFCo:R:StTReaderTa$fMonadBaseControlbReaderT$fMonadTransControlReaderT$fMonadBasebReaderT$fNewtypeReaderT$fMonadReadertagrt$fMonadReadertagrReaderTmemptymappend$fMonadErroreWriterT$fMonadWriterw'WriterT$fMonadStatesWriterT$fMonadReaderrWriterT$fMonadContWriterT$fTaggedWriterTtag$fLiftCallCCWriterT$fLiftPassWriterT$fLiftListenWriterT$fLiftCatchWriterT$fLiftLocalWriterTTFCo:R:StTWriterTa$fMonadBaseControlbWriterT$fMonadTransControlWriterT$fMonadBasebWriterT$fNewtypeWriterT$fMonadWritertagwt$fMonadWritertagwWriterT$fMonadErroreStateT$fMonadWriterwStateT$fMonadStates'StateT$fMonadReaderrStateT$fMonadContStateT$fTaggedStateTtag$fLiftCallCCStateT$fLiftPassStateT$fLiftListenStateT$fLiftCatchStateT$fLiftLocalStateTTFCo:R:StTStateTa$fMonadBaseControlbStateT$fMonadTransControlStateT$fMonadBasebStateT$fNewtypeStateT$fMonadStatetagst$fMonadStatetagsStateT$fMonadStatetagsStateT0$fMonadErrore'ExceptT$fMonadWriterwExceptT$fMonadStatesExceptT$fMonadReaderrExceptT$fMonadContExceptT$fTaggedExceptTtag$fLiftCallCCExceptT$fLiftPassExceptT$fLiftListenExceptT$fLiftCatchExceptT$fLiftLocalExceptTTFCo:R:StTExceptTa$fMonadBaseControlbExceptT$fMonadTransControlExceptT$fMonadBasebExceptT$fNewtypeExceptT$fMonadExcepttaget$fMonadExcepttageExceptT$fMonadWritertagwWrappedEther$fMonadWriterwWrappedEther$fMonadExcepttageWrappedEther$fMonadErroreWrappedEther$fMonadStatetagsWrappedEther$fMonadStatesWrappedEther$fMonadReadertagrWrappedEther$fMonadReaderrWrappedEther$fNewtypeWrappedEtherfail>>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