!~Ӻw      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~            !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuv(c) Michael Szvetits, 2020BSD3 (see the file LICENSE)typedbyte@qualified.namestableportableNone,-.;<=>?@ACHMSUVXk@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, 2020 BSD3 (see the file LICENSE) typedbyte@qualified.name stable  portable None,-.;<=>?@ACHMSUVXkH 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.TRoughly speaking, a higher-order effect is a type class whose monad type parameter mc 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.SRoughly speaking, a first-order effect is a type class whose monad type parameter mh 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.effet]This constraint synonym indicates that an effect is handled by a specific monad transformer.effetVThe kind of monad transformers, also known as effect handlers or effect interpreters.effetTThe 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 effsY to their handlers which are located somewhere further down the monad transformer stack.   (c) Michael Szvetits, 2020BSD3 (see the file LICENSE)typedbyte@qualified.namestableportableNone,-.;<=>?@ACHMSUVXkh 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. 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 w' 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 (Q (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 'Lift'/'Control') (MyEffect a b c) t m => MyEffect a b c ( '[] t m) where ... "The first instance indicates that MyEffectL 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 TemplateHaskellj, 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.#effetmGenerates 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  R does, but also some additional things. Consider the following effect type class:  class wv 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 J 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 lAll 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.%effet Similar to  L, but only generates the effect type class instance for handling an effect.&effet Similar to  o, but only generates the effect type class instance for finding the effect in the tail of the type level list.'effet Similar to  K, but only generates the effect type class instance for lifting an effect.(effetAdds an effect effO 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 effQ 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.  !"#$%&'() %&'#$!"()(c) Michael Szvetits, 2020BSD3 (see the file LICENSE)typedbyte@qualified.namestableportableNone,-.;<=>?@ACHMSUVXkExyz{|}~  !"#$%&'()(c) Michael Szvetits, 2020BSD3 (see the file LICENSE)typedbyte@qualified.namestableportableNone,-.;<=>?@ACHMSUVXka*effetTAn effect that equips a computation with the ability to throw and catch exceptions.+effetLThrows an exception during the computation and begins exception processing.,effetJCatches an exception in order to handle it and return to normal execution.3effet Lifts an  e into any * e.4effetThe untagged version of 3.5effet4Runs the error effect by wrapping exceptions in the  type.6effetThe untagged version of 5. *+,-./0123456 *+,-123456./0(c) Michael Szvetits, 2020BSD3 (see the file LICENSE)typedbyte@qualified.namestableportableNone,-.;<=>?@ACHMSUVXk<effet"An effect that integrates a monad n into the computation m.=effetMonadic actions in n can be lifted into m via D.D is like y, but not limited to  . In fact, y can be realized using D by specializing n to IO.>effetLThe finalization interpreter of the embed effect. This type implements the @> type class by declaring the integrated monad the final monad m! (also called the "base monad").hChances 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.?effetNThe transformation interpreter of the embed effect. This type implements the @1 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.Eeffet;Runs the embed effect by transforming the integrated monad n into another integrated monad t.FeffetThe untagged version of E.GeffetHRuns the embed effect by declaring the integrated monad the final monad.HeffetThe untagged version of G.Eeffet&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.Geffet1The program whose embed effect should be handled.effet*The program with its embed effect handled. <=>?@ABCDEFGH <=@D?EF>GHABC(c) Michael Szvetits, 2020BSD3 (see the file LICENSE)typedbyte@qualified.namestableportableNone,-.;<=>?@ACHMSUVXk$ceffet>An effect that adds an abortive continuation to a computation.deffetAdapted 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.leffet=Runs the continuation effect with a given final continuation.meffetThe untagged version of l.neffet"Runs the continuation effect with  as final continuation.oeffetThe untagged version of n. cdghijklmno cdgklmnohij(c) Michael Szvetits, 2020BSD3 (see the file LICENSE)typedbyte@qualified.namestableportableNone,-.;<=>?@ACHMSUVXkseffetuAn effect that allows a computation to allocate resources which are guaranteed to be released after the computation.teffetzAcquire a resource by specifying an acquisition action and a release action to be used for cleanup after the computation.ueffetOThe bracket-based interpreter of the managed effect. This type implements the s 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 {.teffet,The computation which acquires the resource.effet,The computation which releases the resource.effetThe acquired resource. stuvwxyz{| stvzu{|wxy(c) Michael Szvetits, 2020BSD3 (see the file LICENSE)typedbyte@qualified.namestableportableNone,-.;<=>?@ACHMSUVXk effetSAn 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<Updates the value that corresponds to a given key. Passing > as the updated value removes the key-value pair from the map.effet7Deletes a key and its corresponding value from the map.effetThe untagged version of .effet'Checks if the map contains a given key.effetThe untagged version of .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.effetThe untagged version of .effetyUpdates the value that corresponds to a given key. If the key cannot be found, a corresponding default value is assumed.effetThe untagged version of .effet8The default value that is assumed if the key is missing.effetoThe 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,-.;<=>?@ACHMSUVXkeffetBThe 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.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,-.;<=>?@ACHMSUVXk effetDThe 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.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,-.;<=>?@ACHMSUVXk!effetAn 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.effetUGets a specific component of the environment, using the provided projection function.effetUGets a specific component of the environment, using the provided projection function.effetThe untagged version of .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,-.;<=>?@ACHMSUVXk@z effetqAn effect that allows a computation to allocate resources which are guaranteed to be released after their usage.effetFAcquire a resource, use it, and then release the resource after usage.effetLike Z, but only performs the release computation if the usage computation throws an exception.effetKThe 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.effetA simpler version of ; where one computation is guaranteed to run after another.effetThe untagged version of .effetA simpler version of m where one computation is guaranteed to run after another in case the first computation throws an exception.effetThe untagged version of .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.effetXThe computation to run afterwards, even if the first computation throws an exception.effet$The result of the first computation.effetThe computation to run.effetXThe 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,-.;<=>?@ACHMSUVXkL, effet;An effect that adds a mutable state to a given computation.effetGets the current state.effet$Replaces the state with a new value.effetBUpdates the state and produces a value based on the current state.effetOGets a specific component of the state, using the provided projection function.effetThe untagged version of .effet0Modifies the state, using the provided function.effetThe untagged version of .effet]Modifies the state, using the provided function. The computation is strict in the new state.effetThe untagged version of .(c) Michael Szvetits, 2020BSD3 (see the file LICENSE)typedbyte@qualified.namestableportableNone,-.;<=>?@ACHMSUVXk\ effet3Runs the state effect and discards the final state.effetThe untagged version of .effetIRuns the state effect and discards the result of the interpreted program.effetThe untagged version of . effetaRuns the state effect and returns both the final state and the result of the interpreted program. effetThe untagged version of  .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.effetEThe program with its state effect handled, producing the final state s. effetThe initial state.effet1The program whose state effect should be handled.effetEThe 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,-.;<=>?@ACHMSUVXkk` effet3Runs the state effect and discards the final state. effetThe untagged version of  . effet2Runs the state effect and returns the final state.effetThe untagged version of  .effetaRuns the state effect and returns both the final state and the result of the interpreted program.effetThe untagged version of . 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.effetEThe program with its state effect handled, producing the final state s.effetThe initial state.effet1The program whose state effect should be handled.effetEThe 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,-.;<=>?@ACHMSUVXk{SeffetLAn 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.effetBExecutes 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.effetThe untagged version of .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.effetAThe result of the sub-computation, including the modified output.  (c) Michael Szvetits, 2020BSD3 (see the file LICENSE)typedbyte@qualified.namestableportableNone,-.;<=>?@ACHMSUVXk&effetEThe tagging interpreter of the RWS effect. This type implements the )T type class by tagging/retagging/untagging its reader, writer and state components.When interpreting the effect, you usually don't interact with this type directly, but instead use one of its corresponding interpretation functions.'effetGThe 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.)effetBAn 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)*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,-.;<=>?@ACHMSUVXkLeffetDThe 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.Meffet1Runs the RWS effect and discards the final state.NeffetThe untagged version of M.OeffetGRuns the RWS effect and discards the result of the interpreted program.PeffetThe untagged version of O.QeffetlRuns the RWS effect and returns the final output, the final state and the result of the interpreted program.ReffetThe untagged version of Q.MeffetThe initial environment.effetThe initial state.effet/The program whose RWS effect should be handled.effetEThe program with its RWS effect handled, producing the final output w and the result a.OeffetThe initial environment.effetThe initial state.effet/The program whose RWS effect should be handled.effetEThe program with its RWS effect handled, producing the final output w and the final state s.QeffetThe initial environment.effetThe initial state.effet/The program whose RWS effect should be handled.effetEThe program with its RWS effect handled, producing the final output w, the final state s and the result a.LMNOPQRLMOQNPR(c) Michael Szvetits, 2020BSD3 (see the file LICENSE)typedbyte@qualified.namestableportableNone,-.;<=>?@ACHMSUVXkp_effet1Runs the RWS effect and discards the final state.`effetThe untagged version of _.aeffetGRuns the RWS effect and discards the result of the interpreted program.beffetThe untagged version of a.ceffetmRuns the RWS effect and returns the final output, the final state and the result of the interpreted program.deffetThe untagged version of c._effetThe initial environment.effetThe initial state.effet/The program whose RWS effect should be handled.effetEThe program with its RWS effect handled, producing the final output w and the result a.aeffetThe initial environment.effetThe initial state.effet/The program whose RWS effect should be handled.effetEThe program with its RWS effect handled, producing the final output w and the final state s.ceffetThe initial environment.effetThe initial state.effet/The program whose RWS effect should be handled.effetEThe program with its RWS effect handled, producing the final output w, the final state s and the result a._`abcd_ac`bd(c) Michael Szvetits, 2020BSD3 (see the file LICENSE)typedbyte@qualified.namestableportableNone,-.;<=>?@ACHMSUVXkpeeffet4Runs the writer effect and returns the final output.feffetThe untagged version of e.geffetcRuns the writer effect and returns both the final output and the result of the interpreted program.heffetThe untagged version of g.eeffet2The program whose writer effect should be handled.effetGThe program with its writer effect handled, producing the final output w.geffet2The program whose writer effect should be handled.effetGThe program with its writer effect handled, producing the final output w and the result a.efghegfh(c) Michael Szvetits, 2020BSD3 (see the file LICENSE)typedbyte@qualified.namestableportableNone,-.;<=>?@ACHMSUVXkwieffetGThe 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.jeffet4Runs the writer effect and returns the final output.keffetThe untagged version of j.leffetcRuns the writer effect and returns both the final output and the result of the interpreted program.meffetThe untagged version of l.jeffet2The program whose writer effect should be handled.effetGThe program with its writer effect handled, producing the final output w.leffet2The program whose writer effect should be handled.effetGThe program with its writer effect handled, producing the final output w and the result a.ijklmijlkmNone,-.;<=>?@ACHMSUVXkӕ !"#$%&'()*+,-./01123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                 !"#$%&'()*+,-./0123456789:;<=>?@AB.CDEFGHIJK !"#$%&'LMNOPQRSTUVWXYZ[\]^MNOPQR_`abc_`abdefghijklmnompqmprstustvwxywxzs{|s{|s{}~~~~~~~~~]~~~~~~~~~~~~~~~~~~~~~s{s{s{wxmmmmnmm$effet-0.3.0.1-55JHG6RpdZeKZMp2pVg6EqControl.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_effetTagger runTagger$fApplicativeTagger$fFunctorTagger $fMonadTagger$fMonadIOTagger$fMonadTransTagger$fMonadTransControlTagger$fMonadBaseTagger$fMonadBaseControlTaggerControlLiftFindHandle TransformerEffect SomeMonadGViaEachViarunVia$fMonadBaseControlbEachVia$fMonadBasebEachVia$fApplicativeEachVia$fFunctorEachVia$fMonadEachVia$fMonadIOEachVia$fMonadTransEachVia$fMonadTransControlEachViaremoveApostrophe makeEffect makeTaggermakeTaggerWithmakeTaggedEffectmakeTaggedEffectWith makeHandler makeFinder makeLifterliftLrunLError tagError' retagError' untagError' throwError catchError liftEither' liftEither runError'runError$fError'ktageExceptT$fError'ktageTagger$fError'ktageEachVia$fError'ktageEachVia0$fError'ktageEachVia1Embed'embed' FinalizationTransformationEmbed tagEmbed' retagEmbed' untagEmbed'embed runEmbed'runEmbed runFinal'runFinal$fEmbed'ktagIdentityIdentity$fEmbed'ktag[][]$fEmbed'ktagMaybeMaybe$fEmbed'ktagIOIO$fEmbed'ktagnTagger$fEmbed'ktagnEachVia$fEmbed'ktagnEachVia0$fEmbed'ktagnEachVia1$fEmbed'ktagnTransformation$fEmbed'ktagnFinalization$fApplicativeTransformation$fFunctorTransformation$fMonadTransformation$fMonadIOTransformation$fMonadTransTransformation!$fMonadTransControlTransformation$fMonadBaseTransformation $fMonadBaseControlTransformation$fApplicativeFinalization$fFunctorFinalization$fMonadFinalization$fMonadIOFinalization$fMonadTransFinalization$fMonadTransControlFinalization$fMonadBaseFinalization$fMonadBaseControlFinalizationCont'callCC'$fCont'ktagEachVia$fCont'ktagEachVia0ConttagCont' retagCont' untagCont'callCCrunCont'runCont evalCont'evalCont$fCont'ktagContT$fCont'ktagEachVia1$fCont'ktagTaggerManaged'manage'BracketManaged tagManaged' retagManaged' untagManaged'manage runManaged' runManaged$fManaged'ktagTagger$fManaged'ktagEachVia$fManaged'ktagEachVia0$fManaged'ktagEachVia1$fManaged'ktagBracket$fApplicativeBracket$fFunctorBracket$fMonadBracket$fMonadIOBracket$fMonadTransBracket$fMonadTransControlBracket$fMonadBaseBracket$fMonadBaseControlBracketMap'clear'lookup'update'MaptagMap' retagMap' untagMap'clearlookupupdatedelete'deleteexists'existsinsert'insertmodify'modify$fMap'ktagkvTagger$fMap'ktagkvEachVia$fMap'ktagkvEachVia0$fMap'ktagkvEachVia1LazyMaprunMap'runMap$fMap'ktagkvLazyMap$fApplicativeLazyMap$fFunctorLazyMap$fMonadLazyMap$fMonadIOLazyMap$fMonadTransLazyMap$fMonadTransControlLazyMap$fMonadBaseLazyMap$fMonadBaseControlLazyMap StrictMap$fMap'ktagkvStrictMap$fApplicativeStrictMap$fFunctorStrictMap$fMonadStrictMap$fMonadIOStrictMap$fMonadTransStrictMap$fMonadTransControlStrictMap$fMonadBaseStrictMap$fMonadBaseControlStrictMapask'reader'Reader tagReader' retagReader' untagReader'asklocalreaderasks'asks runReader' runReader$fReader'ktagrRWST$fReader'ktagrRWST0$fReader'ktagrReaderT$fReader'ktagrTagger$fReader'ktagrEachVia$fReader'ktagrEachVia0$fReader'ktagrEachVia1 Resource'bracket'bracketOnError'LowerIOResource tagResource'retagResource'untagResource'bracketbracketOnErrorfinally'finally onException' onExceptionrunResourceIO' runResourceIO$fResource'ktagTagger$fResource'ktagEachVia$fResource'ktagEachVia0$fResource'ktagEachVia1$fResource'ktagLowerIO$fApplicativeLowerIO$fFunctorLowerIO$fMonadLowerIO$fMonadIOLowerIO$fMonadTransLowerIO$fMonadTransControlLowerIO$fMonadBaseLowerIO$fMonadBaseControlLowerIOget'put'state'State tagState' retagState' untagState'getputstategets'gets modifyStrict' modifyStrict$fState'ktagsRWST$fState'ktagsRWST0$fState'ktagsStateT$fState'ktagsStateT0$fState'ktagsTagger$fState'ktagsEachVia$fState'ktagsEachVia0$fState'ktagsEachVia1 evalState' evalState execState' execState runState'runStateWriter'tell'listen'censor'Writer tagWriter' retagWriter' untagWriter'telllistencensorlistens'listens$fWriter'ktagwRWST$fWriter'ktagwRWST0$fWriter'ktagwWriterT$fWriter'ktagwWriterT0$fWriter'ktagwTagger$fWriter'ktagwEachVia$fWriter'ktagwEachVia0$fWriter'ktagwEachVia1 SeparationRWSRWS'runSeparatedRWS'runSeparatedRWStagRWS' retagRWS' untagRWS'$fRWS'ktagrwsRWST$fRWS'ktagrwsRWST0$fRWS'ktagrwsEachVia$fRWS'ktagrwsEachVia0$fRWS'ktagrwsEachVia1$fRWS'ktagrwsSeparation$fState'ktagsSeparation$fWriter'ktagwSeparation$fReader'ktagrSeparation$fRWS'ktagrwsTagger$fApplicativeSeparation$fFunctorSeparation$fMonadSeparation$fMonadIOSeparation$fMonadTransSeparation$fMonadTransControlSeparation$fMonadBaseSeparation$fMonadBaseControlSeparationRWSTevalRWS'evalRWSexecRWS'execRWSrunRWS'runRWS$fMonadTransControlRWST$fMonadBaseControlbRWST$fMonadBasebRWST$fApplicativeRWST $fFunctorRWST $fMonadRWST $fMonadIORWST$fMonadTransRWST $fRWS'RWST $fReader'RWST $fWriter'RWST $fState'RWST execWriter' execWriter runWriter' runWriterWriterT$fMonadTransControlWriterT$fMonadBaseControlbWriterT$fMonadBasebWriterT$fApplicativeWriterT$fFunctorWriterT$fMonadWriterT$fMonadIOWriterT$fMonadTransWriterT$fWriter'WriterTbaseGHC.BaseMonadControl.Monad.IO.ClassMonadIOliftIO+transformers-0.5.6.2-I9SzqoyagSNIbUNkJkeRZ3Control.Monad.Trans.Class MonadTranslift0transformers-base-0.4.5.2-4XH5NHnY6x1GOuXqh5jjB7Control.Monad.Base MonadBaseliftBaseControl.Monad.Trans.Identity IdentityT runIdentityT,monad-control-1.0.2.3-7Sj5TsOqOpBHFtAx9bqWsdControl.Monad.Trans.Control liftThroughliftBaseOpDiscardliftBaseDiscard liftBaseOp_ liftBaseOpcaptureMcaptureTembed_controldefaultRestoreMdefaultLiftBaseWithdefaultRestoreT2defaultLiftWith2defaultRestoreTdefaultLiftWithMonadTransControlStTliftWithrestoreTRun RunDefault RunDefault2MonadBaseControlStM liftBaseWithrestoreM RunInBase ComposeStRunInBaseDefault liftCatch liftCallCC mapIdentityTliftBaseDefault Data.EitherEitherghc-prim GHC.TypesIO GHC.MaybeMaybeData.Functor.IdentityIdentitypureControl.Exception.BaseNothingversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName