h$m      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                        (c) Michael Szvetits, 2020BSD3 (see the file LICENSE)typedbyte@qualified.namestableportableNone-./<=>?OeffetRuns a computation using the  monad.1You usually need this when an expression of type Monad m => m a remains after handling all the effects and you want to extract its pure result.(c) Michael Szvetits, 2020BSD3 (see the file LICENSE)typedbyte@qualified.namestableportableNone-./<=>? effetThis type provides instances for effect type classes in order to enable tagging, retagging and untagging of effects. Whenever this type is used as handler of an effect, the effect previously tagged with tag will be tagged with new instead.You usually don't interact with this type directly, since the type class instances for this type are generated by the functions found in the module Control.Effect.Machinery.TH.(c) Michael Szvetits, 2020BSD3 (see the file LICENSE)typedbyte@qualified.namestableportableNone-./<=>?y effetType-level helper function to apply a list of constraints (i.e., effects) to . One should not call this by hand, it will be used by the generated code or called by , ,  and  . effetThis constraint synonym indicates that a higher-order effect is not handled by a specific monad transformer and must thus be delegated ("lifted") further down the monad transformer stack in order to find its associated handler.Roughly speaking, a higher-order effect is a type class whose monad type parameter m appears in negative position when looking at the types of its corresponding class methods (e.g., m- appears in the type of a method parameter).+An example of a higher-order effect is the  ! effect, since its class method   has a parameter of type m a.effetThis constraint synonym indicates that a first-order effect is not handled by a specific monad transformer and must thus be delegated ("lifted") further down the monad transformer stack in order to find its associated handler.Roughly speaking, a first-order effect is a type class whose monad type parameter m appears only in positive position when looking at the types of its corresponding class methods (e.g., m" appears only in the result type).*An example of a first-order effect is the  effect.effet1This constraint synonym indicates that an effect eff is not at the head of the type level list of effects to be handled, so the effect must be found further down in the tail effs.effetThis constraint synonym indicates that an effect is handled by a specific monad transformer.effetThe kind of monad transformers, also known as effect handlers or effect interpreters.effetThe kind of effects, which are type classes with a monad type parameter at the end.effetThe kind of monads.effetThis type is used as tag for all untagged effects. In order words, every effect is tagged, even untagged ones, but all the untagged ones simply have the same tag G (short for "Global", because you can view tags as some kind of namespace mechanism, and all untagged effects live in the same global namespace).If you don't want to use tagged effects (i.e., you write effect type classes without a tag type parameter), you can ignore this type completely.effet?This type synonym can be used to indicate that a single effect eff- is handled by a specific monad transformer t.effet:This type indicates that the effects (i.e., type classes) effs. are handled by a specific monad transformer t. The type is a simple wrapper around the monad transformer itself. The whole purpose of this type is to guide the type system to pick the instances of type classes effs given by the type t5, and to delegate all other effects that are not in effs to their handlers which are located somewhere further down the monad transformer stack.   (c) Michael Szvetits, 2020BSD3 (see the file LICENSE)typedbyte@qualified.namestableportableNone-./<=>?/4 !effetGenerates the effect handling and lifting infrastructure for an effect which does not have a tag type parameter. Requires the TemplateHaskell language extension.)Consider the following effect type class:  class ' m => MyEffect a b c m where ... makeEffect ''MyEffect= then generates three instances for this effect type class ( for first-order effects,   for higher-order effects):  instance ) (MyEffect a b c) t m => MyEffect a b c ( (MyEffect a b c : effs) t m) where ... instance {-# OVERLAPPABLE #-} . (MyEffect a b c) effs t m => MyEffect a b c (3 (other : effs) t m) where ... instance / ) (MyEffect a b c) t m => MyEffect a b c ( '[] t m) where ... "The first instance indicates that MyEffect was found at the head of the type level list of effects to be handled, so MyEffect is delegated to t.#The second instance indicates that MyEffect was not found at the head of the type level list of effects to be handled, so we must find MyEffect in the tail effs of the type level list."The third instance indicates that MyEffect could not be found in the type level list of effects to be handled, so the effect must be delegated further down the monad transformer stack in order to find its corresponding effect handler.Without TemplateHaskell, you have to write these three instances by hand. These instances can also be generated separately, see (, ) and *."effet Similar to $1, but only generates the tag-related definitions.#effet Similar to %1, but only generates the tag-related definitions.$effetGenerates the effect handling and lifting infrastructure for an effect which has a tag type parameter. It is expected that the tag type parameter is the first type parameter of the effect type class. It is also expected that the names of the effect type class and its methods end with an apostrophe "'". If you want more control over the naming convention, use %.4In general, this function generates everything that ! does, but also some additional things. Consider the following effect type class:  class  m => MyEffect' tag a b c m where methodA' :: a -> m () methodB' :: b -> m () methodC' :: c -> m () $ ''MyEffect'0 then generates the following additional things:+A type synonym for the untagged version of  MyEffect' with the name MyEffect (note the missing apostrophe).0Untagged versions of the effect methods, namely methodA, methodB and methodC! (note the missing apostrophes).An instance of  MyEffect' for the type  which does not handle the effect, but simply tags, retags or untags the  MyEffect' constraint of a computation.Three functions  tagMyEffect', retagMyEffect' and untagMyEffect' which make use of the  instance.As a rule of thumb, whenever you see an apostrophe suffix in the name of a definition somewhere in this library, it has something to do with tags. Most of the time you will use such definitions in combination with the language extension TypeApplications, like:  ... forall tag ... methodA' @tag ... tagMyEffect' @"newTag" program retagMyEffect' @"oldTag" @"newTag" program untagMyEffect' @"erasedTag" program All the tag-related definitions can also be generated separately (i.e., without the instances generated by !), see " and #.%effet Similar to $, but allows to define a naming convention function for the names of the effect type class and its methods. This function is used to transform the name of a tagged definition (i.e., the type class or its methods) into its untagged counterpart.-The default naming convention is enforced by -, which simply removes the apostrophe "'" at the end of a name.&effetGiven a list of function names, this function generates untagged versions of them, i.e. it removes the tag type parameters from their type signatures (by applying ) and converts tagged effect type classes found in the signature to their corresponding untagged type synonyms using -.'effet Similar to &, but allows to define a naming convention function for the names of the generated functions and the effect type classes modified in the type signatures.-The default naming convention is enforced by -, which simply removes the apostrophe "'" at the end of a name.(effet Similar to !, but only generates the effect type class instance for handling an effect.)effet Similar to !, but only generates the effect type class instance for finding the effect in the tail of the type level list.*effet Similar to !, but only generates the effect type class instance for lifting an effect.+effetAdds an effect eff to the type level list of effects that need to be handled by the transformer t9. From a structural point of view, this is analogous to lift in the mtl; ecosystem. This function comes in handy when writing the %-based instance of an effect by hand.,effetRemoves an effect eff from the type level list of effects that need to be handled by the transformer t=. From a structural point of view, this is analogous to the run... functions in the mtl; ecosystem. This function comes in handy when writing the %-based instance of an effect by hand.-effetExtracts the untagged name from a name which is expected to end with "'". In other words, this function removes the suffix "'" from a given name, or fails otherwise. !"#$%&'()*+,- !()*$%"#&'+,-(c) Michael Szvetits, 2020BSD3 (see the file LICENSE)typedbyte@qualified.namestableportableNone-./<=>?/ !"#$%&'()*+,-(c) Michael Szvetits, 2020BSD3 (see the file LICENSE)typedbyte@qualified.namestableportableNone-./<=>?2.effetAn effect that equips a computation with the ability to throw and catch exceptions./effetThrows an exception during the computation and begins exception processing.0effetCatches an exception in order to handle it and return to normal execution.7effet Lifts an  e into any . e.>effet4Runs the error effect by wrapping exceptions in the  type.?effetThe untagged version of >. ./01234567=>? ./07156=>?234(c) Michael Szvetits, 2020BSD3 (see the file LICENSE)typedbyte@qualified.namestableportableNone-./<=>?:@effet"An effect that integrates a monad n into the computation m.AeffetMonadic actions in n can be lifted into m via G.G is like , but not limited to  . In fact,  can be realized using G by specializing n to IO.BeffetThe transformation interpreter of the embed effect. This type implements the C1 type class by transforming the integrated monad n into another integrated monad t via natural transformation.When interpreting the effect, you usually don't interact with this type directly, but instead use one of its corresponding interpretation functions.Heffet;Runs the embed effect by transforming the integrated monad n into another integrated monad t.ZeffetThe finalization interpreter of the embed effect. This type implements the C> type class by declaring the integrated monad the final monad m! (also called the "base monad").Chances are very high that you only need this interpreter if you have a custom final monad because the @6 effect is already implemented for final monads like , , [] and .When interpreting the effect, you usually don't interact with this type directly, but instead use one of its corresponding interpretation functions.[effetThe untagged version of H.\effetRuns the embed effect by declaring the integrated monad the final monad.feffetThe untagged version of \.Heffet&The natural transformation from monad n to monad t.effet1The program whose embed effect should be handled.effet*The program with its embed effect handled.\effet1The program whose embed effect should be handled.effet*The program with its embed effect handled. @ABCDEFGHZ[\f @ACGBH[Z\fDEF(c) Michael Szvetits, 2020BSD3 (see the file LICENSE)typedbyte@qualified.namestableportableNone-./<=>?@*geffet>An effect that adds an abortive continuation to a computation.heffetAdapted from the mtl library documentation:callCC' (call-with-current-continuation) calls a function with the current continuation as its argument. Provides an escape continuation mechanism for use with continuation monads. Escape continuations allow to abort the current computation and return a value immediately. They achieve a similar result to  and  of the 2 effect. Advantage of this function over calling return is that it makes the continuation explicit, allowing more flexibility and better control.The standard idiom used with callCC' is to provide a lambda-expression to name the continuation. Then calling the named continuation anywhere within its scope will escape from the computation, even if it is many layers deep within nested computations.peffet"Runs the continuation effect with  as final continuation.qeffet=Runs the continuation effect with a given final continuation.ueffetThe untagged version of p.veffetThe untagged version of q. ghklmnopquv ghkopuqvlmn(c) Michael Szvetits, 2020BSD3 (see the file LICENSE)typedbyte@qualified.namestableportableNone-./<=>?D[weffetAn effect that allows a computation to allocate resources which are guaranteed to be released after the computation.xeffetAcquire a resource by specifying an acquisition action and a release action to be used for cleanup after the computation.yeffetThe bracket-based interpreter of the managed effect. This type implements the w type class by using , thus requiring / at the bottom of the monad transformer stack.When interpreting the effect, you usually don't interact with this type directly, but instead use one of its corresponding interpretation functions.effetRuns the managed effect using .effetThe untagged version of .xeffet,The computation which acquires the resource.effet,The computation which releases the resource.effetThe acquired resource. wxyz{|}~ wxz~y{|} (c) Michael Szvetits, 2020BSD3 (see the file LICENSE)typedbyte@qualified.namestableportableNone-./<=>?IieffetAn effect that adds a mutable collection of key-value pairs to a given computation.effet)Deletes all key-value pairs from the map.effet?Searches for a value that corresponds to a given key. Returns  if the key cannot be found.effet as the updated value removes the key-value pair from the map.effet7Deletes a key and its corresponding value from the map.effet'Checks if the map contains a given key.effetInserts a new key-value pair into the map. If the key is already present in the map, the associated value is replaced with the new value.effetUpdates the value that corresponds to a given key. If the key cannot be found, a corresponding default value is assumed.effet8The default value that is assumed if the key is missing.effetThe function for updating the value. This function is also applied to the default value if the key is missing.effet-The key whose corresponding value is updated.effet The operation produces no value. (c) Michael Szvetits, 2020BSD3 (see the file LICENSE)typedbyte@qualified.namestableportableNone-./<=>?M|effetThe lazy interpreter of the map effect. This type implements the  type class in a lazy manner.When interpreting the effect, you usually don't interact with this type directly, but instead use one of its corresponding interpretation functions.effet)Deletes all key-value pairs from the map.effet?Searches for a value that corresponds to a given key. Returns  if the key cannot be found.effet as the updated value removes the key-value pair from the map.effet3Runs the map effect, initialized with an empty map.effetThe untagged version of .effet/The program whose map effect should be handled.effet(The program with its map effect handled. (c) Michael Szvetits, 2020BSD3 (see the file LICENSE)typedbyte@qualified.namestableportableNone-./<=>?Q_effetThe strict interpreter of the map effect. This type implements the  type class in a strict manner.When interpreting the effect, you usually don't interact with this type directly, but instead use one of its corresponding interpretation functions.effet)Deletes all key-value pairs from the map.effet?Searches for a value that corresponds to a given key. Returns  if the key cannot be found.effet as the updated value removes the key-value pair from the map.effet3Runs the map effect, initialized with an empty map.effetThe untagged version of .effet/The program whose map effect should be handled.effet(The program with its map effect handled. (c) Michael Szvetits, 2020BSD3 (see the file LICENSE)typedbyte@qualified.namestableportableNone-./<=>?VeffetAn effect that adds an immutable state (i.e., an "environment") to a given computation. The effect allows to read values from the environment, pass values from function to function, and execute sub-computations in a modified environment.effetGets the environment.effet5Executes a sub-computation in a modified environment.effetGets a specific component of the environment, using the provided projection function.effetGets a specific component of the environment, using the provided projection function.effetRuns the reader effect.effetThe untagged version of .effet'The function to modify the environment.effet7The sub-computation to run in the modified environment.effet"The result of the sub-computation.effet4The projection function to apply to the environment.effetThe result of the projection.effet4The projection function to apply to the environment.effetThe result of the projection.effetThe initial environment.effet2The program whose reader effect should be handled.effet+The program with its reader effect handled. (c) Michael Szvetits, 2020BSD3 (see the file LICENSE)typedbyte@qualified.namestableportableNone-./<=>?^effetAn effect that allows a computation to allocate resources which are guaranteed to be released after their usage.effetAcquire a resource, use it, and then release the resource after usage.effetLike , but only performs the release computation if the usage computation throws an exception.effetA simpler version of ; where one computation is guaranteed to run after another.effetA simpler version of  where one computation is guaranteed to run after another in case the first computation throws an exception.effetThe IO-based interpreter of the resource effect. This type implements the  type class by using , thus requiring / at the bottom of the monad transformer stack.When interpreting the effect, you usually don't interact with this type directly, but instead use one of its corresponding interpretation functions.effetRuns the resource effect using .effetThe untagged version of .effet,The computation which acquires the resource.effet,The computation which releases the resource.effet(The computation which uses the resource.effet6The result of the computation which used the resource.effet,The computation which acquires the resource.effet,The computation which releases the resource.effet(The computation which uses the resource.effet6The result of the computation which used the resource.effetThe computation to run.effetThe computation to run afterwards, even if the first computation throws an exception.effet$The result of the first computation.effetThe computation to run.effetThe computation to run afterwards, only if the first computation throws an exception.effet$The result of the first computation.(c) Michael Szvetits, 2020BSD3 (see the file LICENSE)typedbyte@qualified.namestableportableNone-./<=>?aeffet;An effect that adds a mutable state to a given computation.effetGets the current state.effet$Replaces the state with a new value.effetUpdates the state and produces a value based on the current state.effetGets a specific component of the state, using the provided projection function.effet0Modifies the state, using the provided function.effetModifies the state, using the provided function. The computation is strict in the new state.(c) Michael Szvetits, 2020BSD3 (see the file LICENSE)typedbyte@qualified.namestableportableNone-./<=>?eeffet3Runs the state effect and discards the final state.effetRuns the state effect and discards the result of the interpreted program.effetRuns the state effect and returns both the final state and the result of the interpreted program.effetThe initial state.effet1The program whose state effect should be handled.effet*The program with its state effect handled.effetThe initial state.effet1The program whose state effect should be handled.effetThe program with its state effect handled, producing the final state s.effetThe initial state.effet1The program whose state effect should be handled.effetThe program with its state effect handled, producing the final state s and the result a.(c) Michael Szvetits, 2020BSD3 (see the file LICENSE)typedbyte@qualified.namestableportableNone-./<=>?ieffet3Runs the state effect and discards the final state.effet2Runs the state effect and returns the final state.effetRuns the state effect and returns both the final state and the result of the interpreted program.effetThe initial state.effet1The program whose state effect should be handled.effet*The program with its state effect handled.effetThe initial state.effet1The program whose state effect should be handled.effetThe program with its state effect handled, producing the final state s.effetThe initial state.effet1The program whose state effect should be handled.effetThe program with its state effect handled, producing the final state s and the result a.(c) Michael Szvetits, 2020BSD3 (see the file LICENSE)typedbyte@qualified.namestableportableNone-./<=>?meffetAn effect that adds a write-only, accumulated output to a given computation.effetProduces the output w. In other words, w' is appended to the accumulated output.effet'Executes a sub-computation and appends w to the accumulated output.effetExecutes a sub-computation and applies the function to its output.effetExecutes a sub-computation and applies the function to its output, thus adding an additional value to the result of the sub-computation.effet,The function which is applied to the output.effet7The sub-computation which produces the modified output.effet"The result of the sub-computation.effet,The function which is applied to the output.effet7The sub-computation which produces the modified output.effetThe result of the sub-computation, including the modified output.  (c) Michael Szvetits, 2020BSD3 (see the file LICENSE)typedbyte@qualified.namestableportableNone-./<=>?qeffetAn effect that adds the following features to a given computation:0(R) an immutable environment (the "reader" part)8(W) a write-only, accumulated output (the "writer" part)&(S) a mutable state (the "state" part)effetThe separation interpreter of the RWS effect. This type implements the 3 type class by splitting the effect into separate ,  and 4 effects which can then be interpreted individually.When interpreting the effect, you usually don't interact with this type directly, but instead use one of its corresponding interpretation functions.effet#Runs the RWS effect via separation.effetThe untagged version of .effet/The program whose RWS effect should be handled.effet(The program with its RWS effect handled.(c) Michael Szvetits, 2020BSD3 (see the file LICENSE)typedbyte@qualified.namestableportableNone-./<=>?weffetThe strict interpreter of the RWS effect. This type implements the  type class in a strict manner.When interpreting the effect, you usually don't interact with this type directly, but instead use one of its corresponding interpretation functions.effet1Runs the RWS effect and discards the final state.effetRuns the RWS effect and discards the result of the interpreted program.effetRuns the RWS effect and returns the final output, the final state and the result of the interpreted program.effetThe initial environment.effetThe initial state.effet/The program whose RWS effect should be handled.effetThe program with its RWS effect handled, producing the final output w and the result a.effetThe initial environment.effetThe initial state.effet/The program whose RWS effect should be handled.effetThe program with its RWS effect handled, producing the final output w and the final state s.effetThe initial environment.effetThe initial state.effet/The program whose RWS effect should be handled.effetThe program with its RWS effect handled, producing the final output w, the final state s and the result a.(c) Michael Szvetits, 2020BSD3 (see the file LICENSE)typedbyte@qualified.namestableportableNone-./<=>?|reffet1Runs the RWS effect and discards the final state.effetRuns the RWS effect and discards the result of the interpreted program.effetRuns the RWS effect and returns the final output, the final state and the result of the interpreted program.effetThe initial environment.effetThe initial state.effet/The program whose RWS effect should be handled.effetThe program with its RWS effect handled, producing the final output w and the result a.effetThe initial environment.effetThe initial state.effet/The program whose RWS effect should be handled.effetThe program with its RWS effect handled, producing the final output w and the final state s.effetThe initial environment.effetThe initial state.effet/The program whose RWS effect should be handled.effetThe program with its RWS effect handled, producing the final output w, the final state s and the result a.(c) Michael Szvetits, 2020BSD3 (see the file LICENSE)typedbyte@qualified.namestableportableNone-./<=>?3effet4Runs the writer effect and returns the final output.effetRuns the writer effect and returns both the final output and the result of the interpreted program.effet2The program whose writer effect should be handled.effetThe program with its writer effect handled, producing the final output w.effet2The program whose writer effect should be handled.effetThe program with its writer effect handled, producing the final output w and the result a.(c) Michael Szvetits, 2020BSD3 (see the file LICENSE)typedbyte@qualified.namestableportableNone-./<=>?effetThe strict interpreter of the writer effect. This type implements the  type class in a strict manner.When interpreting the effect, you usually don't interact with this type directly, but instead use one of its corresponding interpretation functions.effet4Runs the writer effect and returns the final output.effetRuns the writer effect and returns both the final output and the result of the interpreted program.effet2The program whose writer effect should be handled.effetThe program with its writer effect handled, producing the final output w.effet2The program whose writer effect should be handled.effetThe program with its writer effect handled, producing the final output w and the result a.None-./<=>?X  !"#$%&'()*+,-./01234456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                        a$effet-0.4.0.0-AVC83IYhVKqA4OEy2o3r6CControl.Effect.IdentityControl.Effect.Machinery.TaggerControl.Effect.Machinery.ViaControl.Effect.Machinery.THControl.Effect.ErrorControl.Effect.EmbedControl.Effect.ContControl.Effect.ManagedControl.Effect.MapControl.Effect.Map.LazyControl.Effect.Map.StrictControl.Effect.ReaderControl.Effect.ResourceControl.Effect.StateControl.Effect.State.LazyControl.Effect.State.StrictControl.Effect.WriterControl.Effect.RWSControl.Effect.RWS.StrictControl.Effect.RWS.LazyControl.Effect.Writer.LazyControl.Effect.Writer.StrictReader'local'State'Control.Effect.Machinery throwError' catchError'Error' Paths_effet runIdentityTagger runTagger$fApplicativeTagger$fFunctorTagger $fMonadTagger$fMonadIOTagger$fMonadTransTagger$fMonadTransControlTagger$fMonadBasebTagger$fMonadBaseControlbTaggerExpandControlLiftFindHandle TransformerEffect SomeMonadGViaEachViarunVia$fMonadBaseControlbEachVia$fMonadBasebEachVia$fApplicativeEachVia$fFunctorEachVia$fMonadEachVia$fMonadIOEachVia$fMonadTransEachVia$fMonadTransControlEachVia makeEffect makeTaggermakeTaggerWithmakeTaggedEffectmakeTaggedEffectWith makeUntaggedmakeUntaggedWith makeHandler makeFinder makeLifterliftLrunLremoveApostropheError tagError' retagError' untagError' throwError catchError liftEither'$fError'ktageExceptT$fError'ktageTagger$fError'ktageEachVia$fError'ktageEachVia0$fError'ktageEachVia1 liftEither runError'runErrorEmbed'embed'TransformationEmbed tagEmbed' retagEmbed' untagEmbed'embed runEmbed'$fEmbed'ktagIdentityIdentity$fEmbed'ktag[][]$fEmbed'ktagMaybeMaybe$fEmbed'ktagIOIO$fEmbed'ktagnTagger$fEmbed'ktagnEachVia$fEmbed'ktagnEachVia0$fEmbed'ktagnEachVia1$fEmbed'ktagnTransformation$fApplicativeTransformation$fFunctorTransformation$fMonadTransformation$fMonadIOTransformation$fMonadTransTransformation!$fMonadTransControlTransformation$fMonadBasebTransformation!$fMonadBaseControlbTransformation FinalizationrunEmbed runFinal'$fEmbed'ktagnFinalization$fApplicativeFinalization$fFunctorFinalization$fMonadFinalization$fMonadIOFinalization$fMonadTransFinalization$fMonadTransControlFinalization$fMonadBasebFinalization$fMonadBaseControlbFinalizationrunFinalCont'callCC'$fCont'ktagEachVia$fCont'ktagEachVia0ConttagCont' retagCont' untagCont'callCC evalCont'runCont'$fCont'ktagContT$fCont'ktagEachVia1$fCont'ktagTaggerevalContrunContManaged'manage'BracketManaged tagManaged' retagManaged' untagManaged'manage runManaged'$fManaged'ktagTagger$fManaged'ktagEachVia$fManaged'ktagEachVia0$fManaged'ktagEachVia1$fManaged'ktagBracket$fApplicativeBracket$fFunctorBracket$fMonadBracket$fMonadIOBracket$fMonadTransBracket$fMonadTransControlBracket$fMonadBasebBracket$fMonadBaseControlbBracket runManagedMap'clear'lookup'update'MaptagMap' retagMap' untagMap'clearlookupupdatedelete'exists'insert'modify'$fMap'ktagkvTagger$fMap'ktagkvEachVia$fMap'ktagkvEachVia0$fMap'ktagkvEachVia1deleteexistsinsertmodifyLazyMaprunMap'$fMap'ktagkvLazyMap$fApplicativeLazyMap$fFunctorLazyMap$fMonadLazyMap$fMonadIOLazyMap$fMonadTransLazyMap$fMonadTransControlLazyMap$fMonadBasebLazyMap$fMonadBaseControlbLazyMaprunMap StrictMap$fMap'ktagkvStrictMap$fApplicativeStrictMap$fFunctorStrictMap$fMonadStrictMap$fMonadIOStrictMap$fMonadTransStrictMap$fMonadTransControlStrictMap$fMonadBasebStrictMap$fMonadBaseControlbStrictMapask'reader'Reader tagReader' retagReader' untagReader'asklocalreaderasks'$fReader'ktagrRWST$fReader'ktagrRWST0$fReader'ktagrReaderT$fReader'ktagrTagger$fReader'ktagrEachVia$fReader'ktagrEachVia0$fReader'ktagrEachVia1asks runReader' runReader Resource'bracket'bracketOnError'Resource tagResource'retagResource'untagResource'bracketbracketOnErrorfinally' onException'$fResource'ktagTagger$fResource'ktagEachVia$fResource'ktagEachVia0$fResource'ktagEachVia1LowerIOfinally onExceptionrunResourceIO'$fResource'ktagLowerIO$fApplicativeLowerIO$fFunctorLowerIO$fMonadLowerIO$fMonadIOLowerIO$fMonadTransLowerIO$fMonadTransControlLowerIO$fMonadBasebLowerIO$fMonadBaseControlbLowerIO runResourceIOget'put'state'State tagState' retagState' untagState'getputstategets' modifyStrict'$fState'ktagsRWST$fState'ktagsRWST0$fState'ktagsStateT$fState'ktagsStateT0$fState'ktagsTagger$fState'ktagsEachVia$fState'ktagsEachVia0$fState'ktagsEachVia1gets modifyStrict evalState' execState' runState' evalState execStaterunStateWriter'tell'listen'censor'Writer tagWriter' retagWriter' untagWriter'telllistencensorlistens'$fWriter'ktagwRWST$fWriter'ktagwRWST0$fWriter'ktagwWriterT$fWriter'ktagwWriterT0$fWriter'ktagwTagger$fWriter'ktagwEachVia$fWriter'ktagwEachVia0$fWriter'ktagwEachVia1listensRWS' SeparationRWStagRWS' retagRWS' untagRWS'runSeparatedRWS'runSeparatedRWS$fRWS'ktagrwsRWST$fRWS'ktagrwsRWST0$fRWS'ktagrwsTagger$fRWS'ktagrwsEachVia$fRWS'ktagrwsEachVia0$fRWS'ktagrwsEachVia1$fRWS'ktagrwsSeparation$fState'ktagsSeparation$fWriter'ktagwSeparation$fReader'ktagrSeparation$fApplicativeSeparation$fFunctorSeparation$fMonadSeparation$fMonadIOSeparation$fMonadTransSeparation$fMonadTransControlSeparation$fMonadBasebSeparation$fMonadBaseControlbSeparationRWSTevalRWS'execRWS'runRWS'$fMonadTransControlRWST$fMonadBaseControlbRWST$fMonadBasebRWST$fApplicativeRWST $fFunctorRWST $fMonadRWST $fMonadIORWST$fMonadTransRWSTevalRWSexecRWSrunRWS execWriter' runWriter' execWriter runWriterWriterT$fMonadTransControlWriterT$fMonadBaseControlbWriterT$fMonadBasebWriterT$fApplicativeWriterT$fFunctorWriterT$fMonadWriterT$fMonadIOWriterT$fMonadTransWriterTbaseData.Functor.IdentityIdentityGHC.BaseMonadControl.Monad.IO.ClassMonadIOliftIOtransformers-0.5.6.2Control.Monad.Trans.Class MonadTranslift0transformers-base-0.4.5.2-2JwY8UMK4YFHH9faaNEDAIControl.Monad.Base MonadBaseliftBaseControl.Monad.Trans.Identity IdentityT runIdentityT,monad-control-1.0.2.3-FNg31cuSvxg1INhTbplQrpControl.Monad.Trans.Control liftThroughliftBaseOpDiscardliftBaseDiscard liftBaseOp_ liftBaseOpcaptureMcaptureTembed_controldefaultRestoreMdefaultLiftBaseWithdefaultRestoreT2defaultLiftWith2defaultRestoreTdefaultLiftWithStTMonadTransControlrestoreTliftWithRun RunDefault RunDefault2StMMonadBaseControlrestoreM liftBaseWith RunInBase ComposeStRunInBaseDefault liftCatch liftCallCC mapIdentityTliftBaseDefault Data.EitherEitherghc-prim GHC.TypesIO GHC.MaybeMaybepureControl.Exception.BaseNothingversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName