X:      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmno p q r s t u v w x y z { | } ~   Safe,DT Safe +,9:;<=DQR +Returns a boolean value indicating whether f0 belongs to the group of effects identified by name. This allows  MemberEffect6 to infer the associated types for arbitrary effects. The class of "s that do not contain deletions (`).A constraint specifying that e is a member of the  l.+Returns the index of the first instance of e in the  l. The class of  s with statically known lengths.Returns the length of the  l.Appends two type level s.)A type level list with explicit removals.The empty list.Prepends an element (cons).&Deletes the first instance an element. 555None+,DQRTNone%&,QRa 7Represents a union of the list of type constructors in l parameterized by a. As an effect, it represents the union of each type constructor's corresponding effect. From the user's perspective, it provides a way to encapsulate multiple effects.   None+,9:;<=DOQRT  A refined ship constraint that can infer f from l , given name . In order for this to be used,  name f must be defined. For example: data Reader r a = ... type instance Is Reader f = IsReader f type IsReader f where IsReader (Reader r) = True IsReader f = False type ReaderEffect r l = MemberEffect Reader (Reader r) l ask :: ReaderEffect r l => Effect l r ask = ...Given the constraint ReaderEffect r l in the above example, r can be inferred from l. 6The class of types which result in an effect. That is: 3Effect l r a -> Effect l r a -> b -> Effect l r ... EDetermines the effects associated with the return type of a function. An effectful computation. An  Effect l aB may perform any of the effects specified by the list of effects l# before returning a result of type a6. The definition is isomorphic to the following GADT: >data Effect l a where Done :: a -> Effect l a Side ::   l (Effect l a) -> Effect l a FConverts an computation that produces no effects into a regular value.Executes an effect of type f& that produces a return value of type a.Executes an effect of type f& that produces a return value of type r>. Note that a specific instance of this function is of type *Member f l => f (Effect l a) -> Effect l a?, which allows users to send effects parameterized by effects.Handles an effect without eliminating it. The second function parameter is passed an effect value and a continuation function.2The most common instantiation of this function is: O(a -> Effect l b) -> (f (Effect l b) -> Effect l b) -> Effect l a -> Effect l bsCompletely handles an effect. The second function parameter is passed an effect value and a continuation function.2The most common instantiation of this function is: V(a -> Effect l b) -> (f (Effect l b) -> Effect l b) -> Effect (f ': l) a -> Effect l b8Adds an arbitrary effect to the head of the effect list./Enables an effect that was previously disabled.Hides an effect fd by translating each instance of the effect into an equivalent effect further into the effect list.1conceal = eliminate return (\x k -> send x >>= k)Hides an effect ff by translating each instance of the effect into an equivalent effect at the head of the effect list.CTranslates the first effect in the effect list into another effect.Frename f = eliminate return (\x k -> send (f x) >>= k) . swap . extend0Reorders the first two effects in a computation.1Rotates the first three effects in a computation.!Distributes the sub-effects of a   effect across a computation..Collects some effects in a computation into a   effect.Converts a set of effects l into a single effect f.  mask f =  .  f . Converts an effect f into a set of effects l.  unmask f =  .  f .   !"#        !"#None%&,9:;<=DOQRT%:An effect describing the generation of unique identifiers.&+A unique identifier associated with a type aE. If two tokens are equal, then so are their associated types. Use  to safely cast between types.'Generates a new, unique &.(Completely handles a %u effect. The Rank-2 quantifier ensures that unique identifiers cannot escape the context in which they were created. $%&'()*$%&'($%(&' $%&'()*None ,9:;<=DQR -EAn effect where a state value is threaded throughout the computation..Gets the current state./5Gets a value that is a function of the current state.0Replaces the current state.1+Applies a pure modifier to the state value.2fApplies a pure modifier to the state value. The modified value is converted to weak head normal form.3$Lifts a stateful computation to the   monad.4/Runs a computation with a modified state value.withState f x = modify f >> x5Completely handles a -L effect by providing an initial state, and making the final state explicit.6Completely handles a -& effect, and discards the final state.7Completely handles a -& effect, and discards the final value.,-./0123456789 ,-./01234567 ,-567./01234,-./0123456789None%&,9:;<=DQR;*An effect that allows accumulating output.<Writes a value to the output.=Executes a computation, and obtains the writer output. The writer output of the inner computation is still written to the writer output of the outer computation.>Like =2, but the writer output is run through a function.?Runs a computation that returns a value and a function, applies the function to the writer output, and then returns the value.@9Applies a function to the writer output of a computation.AGExecutes a writer computation which sends its output to a state effect.B?Completely handles a writer effect. The writer value must be a . " is used as an initial value, and ^ is used to combine values. Returns the result of the computation and the final output value.:;<=>?@ABCD :;<=>?@AB :;B<=>?@A:;<=>?@ABCDNone%&,9:;<=DQRF0An effect that provides an implicit environment.G"Retrieves the current environment.H@Retrieves a value that is a function of the current environment.I/Runs a computation with a modified environment.JWExecutes a reader computation which obtains its environment value from a state effect.KCompletely handles a FQ effect by providing an environment value to be used throughout the computation. EFGHIJKLMEFGHIJKEFKGHIJ EFGHIJKLMNone ,9:;DQR OGDescribes a Prolog-like cut effect. This effect must be used with the Q effect.Q'A nondeterminism (backtracking) effect.R9Nondeterministically chooses a value from the input list.SDDescribes a nondeterministic computation that never returns a value.TANondeterministically chooses a value from a list of computations.UYObtains all possible values from a computation parameterized by a nondeterminism effect.VdPrevents backtracking past the point this value was invoked, in the style of Prolog's "!" operator.W\Prevents backtracking past the point this value was invoked. Unlike Prolog's "!" operator, WX will cause the current computation to fail immediately, instead of when it backtracks.X Handles the O effect. VNs have no effect beyond the scope of the computation passed to this function.NOPQRSTUVWXYZ[\ NOPQRSTUVWX PQURSTNOXVWNOPQRSTUVWXYZ[\None ,9:;<=DQR^An effect described by a monad.a%Lifts a monadic value into an effect.b%Lifts a monadic value into an effect.cSConverts a computation containing only monadic effects into a monadic computation. ]^_`abcde]^_`abc]^_`cab]^_`abcdeNone,9:;QRg0An effect that describes concurrent computation.h$Yields to the next available thread.iForks a child thread.j*Immediately terminates the current thread.kUExecutes a threaded computation synchronously. Completes when the main thread exits.l`Executes a threaded computation synchronously. Does not complete until all threads have exited.m/Executes a threaded computation asynchronously.fghijklmnfghijklmfgklmhij fghijklmn None ,9:;<=DQRoA suspended computation.p!Describes a finished computation.q7Describes a computation that provided a value of type i and awaits a value of type o.s/An effect describing a suspendable computation.t?Suspends the current computation by providing a value of type i& and then waiting for a value of type o.u Converts a s effect into an o.v;Evaluates an iterator by providing it with an input stream. opqrstuvwopqrstuvrsutopqvopqrstuvw None%&,9:;<=DOQRT x%A handler for an exception. Use with .z=The type of placeholder values indicating an exception class.{rProvides a base effect for exceptions. This effect allows the dynamic generation of exception classes at runtime.|zCreates a new tag. The function parameter describes the error message that is shown in the case of an uncaught exception.}5Raises an exception of the specified class and value.~4Specifies a handler for exceptions of a given class.xSpecifies a number of handlers for exceptions thrown by the given computation. This is prefered over chained calles to ~, i.e. %exceptWith t2 (exceptWith t1 m h1) h2because h2" could catch exceptions thrown by h1.-Intercepts all exceptions. Used to implement ~ and . Not exported. Is it really a good thing to allow catching all exceptions? The most common use case for catching all exceptions is to do cleanup, which is what bracket is for.`Executes a computation with a resource, and ensures that the resource is cleaned up afterwards.A specialized version of  which does not require an acquire operation. Executes a {& effect. The Rank-2 type ensures that zs do not escape their scope.xyz{|}~The acquire operation.The release operation.The computation to perform. xyz{|}~ y{z|}~xxyz{|}~ None ,9:;<=DQR4An effect that describes the possibility of failure.Raises an exception.8Handles an exception. Intended to be used in infix form. 0myComputation `except` \ex -> doSomethingWith ex'Completely handles an exception effect. Noneq $%&'(,-./01234567:;<=>?@ABEFGHIJKNOPQRSTUVWX]^_`abcfghijklmopqrstuvxyz{|}~          !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnoopqrstuvwxyz{|}~                       %&')*)*%&'+,7>b         #effin-0.3.0.3-TYJONUOCn47tJRC6jQj77Control.Monad.EffectControl.Effect.WitnessControl.Effect.StateControl.Effect.WriterControl.Effect.ReaderControl.Effect.ListControl.Effect.LiftControl.Effect.ThreadControl.Effect.CoroutineControl.Effect.BracketControl.Effect.Exception Data.Type.Nat Data.Type.Row Data.Index Data.UnionControl.EffectIs InclusiveMember KnownLength:++RowNil:+:-Union MemberEffect Effectful EffectsOfEffect runEffectsend sendEffect intercept eliminateextendenableconcealrevealrenameswaprotateflatten unflattenmaskunmask$fMemberEffectknamefl$fEffectfull(->)$fEffectfullEffect $fMonadEffect$fApplicativeEffect$fFunctorEffect EffectWitnessWitnessTokennewToken runWitness$fEffectWitnesssl$fTestEqualityTYPEToken $fEqToken EffectStateStategetgetsputmodifymodify'state withStaterunState evalState execState$fEffectStatesl$fMonadStatesEffect EffectWriterWritertelllistenlistenspasscensor stateWriter runWriter$fEffectWriterwl$fMonadWriterwEffect EffectReaderReaderaskaskslocal stateReader runReader$fEffectReaderrl$fMonadReaderrEffect CutEffectCut EffectListListchooseneverselectrunListcutcutFalserunCut $fCutEffectl$fMonadPlusEffect$fAlternativeEffect $fEffectListl EffectLiftLiftunLiftlift liftEffectrunLift$fEffectLiftml$fMonadIOEffect EffectThreadThreadyieldforkabortrunMainrunSyncrunAsync$fEffectThreadlIteratorDoneNextEffectCoroutine Coroutinesuspend runCoroutine evalIterator$fEffectCoroutineiolHandler EffectBracketTagBracketnewTag raiseWith exceptWith exceptAnybracketfinally runBracket$fEffectBracketsl$fTestEqualityTYPETagEffectException Exceptionraiseexcept runException$fEffectExceptionsel$fMonadErroreEffectKnownNatnatValNatZeroSucc$fKnownNatSucc$fKnownNatZeroIndexOfLengthRemoveElemInstanceOfNone InstanceOf NthIndexOf$fInclusivea:+$fInclusiveaNil $fMemberael$fKnownLengthalIndexzeroindexabsurdtrivialsizepushpopdisableprependappendsplit$fTestEqualitykIndexwrapunwrapinjectprojectrelayunEffect translatebaseData.Type.Equality testEquality WitnessType IsWitnessNewToken unsafeReflIsStateGHC.BaseMonoidmemptymappendIsWriterTellpointbindIsReaderAskCutFalseIsListIsLift ThreadASTYieldASTForkASTAbortASTYieldForkAborttoAST IsCoroutine exceptAll IsBracketRaiseBWitnessconvert IsException