cq      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXY Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p   Safe-Inferred(=Mqrstuvwqrstuqrsutvw  Safe-Inferred '(2346=JK +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.x+Returns the index of the first instance of e in the  l. The class of  s with statically known lengths.yReturns the length of the  l.Appends two type level s.)A type level list with explicit removals.&Deletes the first instance an element.Prepends an element (cons).The empty list.z{|}~xy }xyz{|}~xyNone'(=JKMNone!"(JKW 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 '(2346=HJKM  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!"(2346=HJKM;An effect describing the generation of unique identifiers. +A unique identifier associated with a type aG. If two tokens are equal, then so are their associated types. Use  to safely cast between types. !Generates a new, unique  . "Completely handles a w effect. The Rank-2 quantifier ensures that unique identifiers cannot escape the context in which they were created.  !" !"" !  !"None (2346=JK $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.'Replaces the current state.(+Applies a pure modifier to the state value.)fApplies a pure modifier to the state value. The modified value is converted to weak head normal form.*$Lifts a stateful computation to the   monad.+/Runs a computation with a modified state value.withState f x = modify f >> x,Completely handles a $L effect by providing an initial state, and making the final state explicit.-Completely handles a $& effect, and discards the final state..Completely handles a $& effect, and discards the final value.#$%&'()*+,-. #$%&'()*+,-. #$,-.%&'()*+#$%&'()*+,-.None!"(2346=JK0*An effect that allows accumulating output.1Writes a value to the output.2Executes 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.3Like 22, but the writer output is run through a function.4Runs a computation that returns a value and a function, applies the function to the writer output, and then returns the value.59Applies a function to the writer output of a computation.6GExecutes a writer computation which sends its output to a state effect.7?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./01234567 /01234567 /07123456/01234567None!"(2346=JK90An effect that provides an implicit environment.:"Retrieves the current environment.;@Retrieves a value that is a function of the current environment.</Runs a computation with a modified environment.=WExecutes a reader computation which obtains its environment value from a state effect.>Completely handles a 9Q effect by providing an environment value to be used throughout the computation. 89:;<=>89:;<=>89>:;<= 89:;<=>None (234=JK @HDescribes a Prolog-like cut effect. This effect must be used with the B effect. B(A nondeterminism (backtracking) effect. C:Nondeterministically chooses a value from the input list. DEDescribes a nondeterministic computation that never returns a value. EBNondeterministically chooses a value from a list of computations. F[Obtains all possible values from a computation parameterized by a nondeterminism effect. GfPrevents backtracking past the point this value was invoked, in the style of Prolog's "!" operator. H]Prevents backtracking past the point this value was invoked. Unlike Prolog's "!" operator, HZ will cause the current computation to fail immediately, instead of when it backtracks. I Handles the @ effect. GPs have no effect beyond the scope of the computation passed to this function. ?@ABCDEFGHI ?@ABCDEFGHI ABFCDE?@IGH?@ABCDEFGHINone (2346=JKKAn effect described by a monad.N%Lifts a monadic value into an effect.O%Lifts a monadic value into an effect.PSConverts a computation containing only monadic effects into a monadic computation. JKLMNOPJKLMNOPJKLMPNO JKLMNOPNone(234JKR1An effect that describes concurrent computation. S%Yields to the next available thread. TForks a child thread. U+Immediately terminates the current thread. VWExecutes a threaded computation synchronously. Completes when the main thread exits. WbExecutes a threaded computation synchronously. Does not complete until all threads have exited. X0Executes a threaded computation asynchronously. QRSTUVWXQRSTUVWXQRVWXSTU QRSTUVWX None (2346=JKYA suspended computation. Z8Describes a computation that provided a value of type i and awaits a value of type o. ["Describes a finished computation. ]0An effect describing a suspendable computation. ^@Suspends the current computation by providing a value of type i& and then waiting for a value of type o. _ Converts a ] effect into an Y. `<Evaluates an iterator by providing it with an input stream. YZ[\]^_`YZ[\]^_`\]_^Y[Z` Y[Z\]^_` None!"(2346=HJKM a%A handler for an exception. Use with h. c>The type of placeholder values indicating an exception class. dtProvides a base effect for exceptions. This effect allows the dynamic generation of exception classes at runtime. e|Creates a new tag. The function parameter describes the error message that is shown in the case of an uncaught exception. f6Raises an exception of the specified class and value. g5Specifies a handler for exceptions of a given class. hySpecifies a number of handlers for exceptions thrown by the given computation. This is prefered over chained calles to g, i.e.  &exceptWith t2 (exceptWith t1 m h1) h2 because h2" could catch exceptions thrown by h1. -Intercepts all exceptions. Used to implement g and i. 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. ibExecutes a computation with a resource, and ensures that the resource is cleaned up afterwards. jA specialized version of i which does not require an acquire operation. k Executes a d& effect. The Rank-2 type ensures that cs do not escape their scope. abcdefghiThe acquire operation. The release operation. The computation to perform. jk abcdefghijk bdkcefgahijabcdefghijk None (2346=JKm4An effect that describes the possibility of failure.nRaises an exception.o8Handles an exception. Intended to be used in infix form. 0myComputation `except` \ex -> doSomethingWith exp'Completely handles an exception effect. lmnoplmnoplmpno lmnopNoneq  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnop          !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefgh i j k l m n o p q r s t u v w x y z { | } ~             %&')*)*%&'+,15S  m  q  s        effin-0.2.1.3Control.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:++Row:-:+NilUnion MemberEffect Effectful EffectsOfEffect runEffectsend sendEffect intercept eliminateextendenableconcealrevealrenameswaprotateflatten unflattenmaskunmask EffectWitnessWitnessTokennewToken runWitness EffectStateStategetgetsputmodifymodify'state withStaterunState evalState execState EffectWriterWritertelllistenlistenspasscensor stateWriter runWriter EffectReaderReaderaskaskslocal stateReader runReader CutEffectCut EffectListListchooseneverselectrunListcutcutFalserunCut EffectLiftLiftunLiftlift liftEffectrunLift EffectThreadThreadyieldforkabortrunMainrunSyncrunAsyncIteratorNextDoneEffectCoroutine Coroutinesuspend runCoroutine evalIteratorHandler EffectBracketTagBracketnewTag raiseWith exceptWith exceptAnybracketfinally runBracketEffectException Exceptionraiseexcept runExceptionKnownNatnatValNatSuccZero$fKnownNatSucc$fKnownNatZeroIndexOfLengthRemoveElemInstanceOfNone InstanceOf NthIndexOf$fInclusivek:+$fInclusivekNil $fMemberkel$fKnownLengthklIndexzeroindexabsurdtrivialsizepushpopdisableprependappendsplit$fTestEqualitykIndexwrapunwrapinjectprojectrelayunEffect translate$fMemberEffectknamefl$fEffectfull(->)$fEffectfullEffect $fMonadEffect$fApplicativeEffect$fFunctorEffectbaseData.Type.Equality testEquality WitnessType IsWitnessNewToken unsafeRefl$fEffectWitnessslTFCo:R:Is(->)Witnessf$fTestEquality*TokenIsState$fEffectStateslTFCo:R:Is(->)Statef$fMonadStatesEffect Data.MonoidMonoidmemptymappendIsWriterTellpointbind$fEffectWriterwlTFCo:R:Is(->)Writerf$fMonadWriterwEffectIsReaderAsk$fEffectReaderrlTFCo:R:Is(->)Readerf$fMonadReaderrEffectCutFalseIsList $fCutEffectl$fMonadPlusEffect$fAlternativeEffect $fEffectListlTFCo:R:Is(->)ListfIsLift$fEffectLiftmlTFCo:R:Is(->)Liftf$fMonadIOEffect ThreadASTAbortASTForkASTYieldASTAbortForkYieldtoAST$fEffectThreadl IsCoroutine$fEffectCoroutineiolTFCo:R:Is(->)Coroutinef exceptAll IsBracketBWitnessRaiseconvert$fEffectBracketslTFCo:R:Is(->)Bracketf$fTestEquality*Tag IsExceptionCatch$fEffectExceptionelTFCo:R:Is(->)Exceptionf$fMonadErroreEffect