!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRS T U V W X Y Z [ \ ] ^ _ ` a bcdefghijklm n o p q r s t u v w x y z { | } ~  9Fast type-aligned queue optimized to effectful functions.D(c) 2016 Allele Dev; 2017 Ixperta Solutions s.r.o.; 2017 Alexis KingBSD3#Alexis King <lexi.lambda@gmail.com> experimental!GHC specific language extensions.Safe&'+-3;<=>?AQSTV]hJ(Left view deconstruction data structure.MNon-empty tree. Deconstruction operations make it more and more left-leaning,Build a leaf from a single operation. [O(1)]4Append an operation to the right of the tree. [O(1)]An alias for '(|>)'&Append two trees of operations. [O(1)] An alias for '(><)' (Left view deconstruction. [average O(1)]    >Open unions (type-indexed co-products) for extensible effects.D(c) 2016 Allele Dev; 2017 Ixperta Solutions s.r.o.; 2017 Alexis KingBSD3#Alexis King <lexi.lambda@gmail.com> experimental!GHC specific language extensions.None&'+,-3;<=>?AFQSTV]hE5A constraint that requires that a particular effect, eff&, is a member of the type-level list effs#. This is used to parameterize an < computation over an arbitrary list of effects, so long as eff is  somewhere in the list.\For example, a computation that only needs access to a cell of mutable state containing an % would likely use the following type:  (   ) effs =>  effs () Takes a request of type  t :: * -> *, and injects it into the .O(1)Project a value of type  (t ': r) :: * -> *& into a possible summand of the type  t :: * -> *.  means that  t :: * -> *! is not the value stored in the  (t ': r) :: * -> *.O(1)FInstance resolution for this class fails with a custom type error if  t :: * -> * is not in the list  r :: [* -> *].Find an index of an element  t :: * -> * in a type list  r :: [* -> *]. The element must exist. The  w :: [* -> *]d type represents the entire list, prior to recursion, and it is used to produce better type errors.IThis is essentially a compile-time computation without run-time overhead.Position of the element  t :: * -> * in a type list  r :: [* -> *].MPosition is computed during compilation, i.e. there is no run-time overhead.O(1)Represents position of element  t :: * -> * in a type list  r :: [* -> *].:Open union is a strong sum (existential with an evidence).Takes a request of type  t :: * -> *, and injects it into the .!Summand is assigning a specified . value, which is a position in the type-list (t ': r) :: * -> *.This function is unsafe.O(1)Project a value of type  (t ': r) :: * -> *& into a possible summand of the type  t :: * -> *.  means that  t :: * -> *! is not the value stored in the  (t ': r) :: * -> *.,It is assumed that summand is stored in the  when the . value is the same value as is stored in the .This function is unsafe.O(1)Orthogonal decomposition of a  (t ': r) :: * -> *.  value is returned if the  (t ': r) :: * -> * contains  t :: * -> *, and  when it doesn't. Notice that  value contains Union r :: * -> *, i.e. it can not contain  t :: * -> *.O(1)Specialized version of  for efficiency.O(1)0TODO: Check that it actually adds on efficiency.Specialised version of 'prj'\/'decomp' that works on an  '[t] :: * -> *A which contains only one specific summand. Hence the absence of , and .O(1) Inject whole  r into a weaker  (any ': r) that has one more summand.O(1)QRecursion; element is not at the current position, but is somewhere in the list. :Base case; element is at the current position in the list.!Pass if r is uninstantiated. The incoherence here is safe, since picking this instance doesn t cause any variation in behavior, except possibly the production of an inferior error message. For more information, see lexi-lambda/freer-simple#3, which describes the motivation in more detail.%If we reach an empty list, that s a failure, since it means the type isn t in the list. For GHC >=8, we can render a custom type error that explicitly states what went wrong.  %#"!$ '&   5>Open unions (type-indexed co-products) for extensible effects.D(c) 2016 Allele Dev; 2017 Ixperta Solutions s.r.o.; 2017 Alexis KingBSD3#Alexis King <lexi.lambda@gmail.com> experimental!GHC specific language extensions.None&'+,-3;<=>?AFQSTV]hW(Like , ( eff effs% is a constraint that requires that eff is in the type-level list effs . However, unlike , ( requires m be the final effect in effs.Generally, this is not especially useful, since it is preferable for computations to be agnostic to the order of effects, but it is quite useful in combination with  or . to embed ordinary monadic effects within an  computation.)AA shorthand constraint that represents a combination of multiple & constraints. That is, the following ) constraint: ) '[Foo, Bar, Baz] effs ' &is equivalent to the following set of  constraints: ( Foo effs,  Bar effs,  baz effs) ;Note that, since each effect is translated into a separate , constraint, the order of the effects does not matter. ()  )( Mechanisms to make effects work.D(c) 2016 Allele Dev; 2017 Ixperta Solutions s.r.o.; 2017 Alexis KingBSD3#Alexis King <lexi.lambda@gmail.com> experimental!GHC specific language extensions.None&'+-3;<=>?AFQSTV]h1,4A data type for representing nondeterminstic choice./The /m monad provides the implementation of a computation that performs an arbitrary set of algebraic effects. In / effs a, effs is a type-level list that contains all the effects that the computation may perform. For example, a computation that produces an  by consuming a Q from the global environment and acting upon a single mutable cell containing a  would have the following type: / '[  ,   ]  ANormally, a concrete list of effects is not used to parameterize /. Instead, the  or ) constraints are used to express constraints on the list of effects without coupling a computation to a concrete list of effects. For example, the above example would more commonly be expressed with the following type: ) '[  ,    ] effs => / effs  This abstraction allows the computation to be used in functions that may perform other effects, and it also allows the effects to be handled in any order.0 Pure value ( =  = 0).1Sending a request of type  Union effs with the continuation 2 r b a.2An effectful function from a :: * to b :: *F that is a composition of several effectful functions. The paremeter eff :: [* -> *]a describes the overall effect. The composition members are accumulated in a type-aligned queue.3&Effectful arrow type: a function from a :: * to b :: *$ that also does effects denoted by effs :: [* -> *].4=Function application in the context of an array of effects, 2 effs b w.5!Composition of effectful arrows (2D). Allows for the caller to change the effect environment, as well.6s Sends  an effect, which should be a value defined as part of an effect algebra (see the module documentation for Control.Monad.Freer]), to an effectful computation. This is used to connect the definition of an effect to the /* monad so that it can be used and handled.7 Identical to 6), but specialized to the final effect in effsv to assist type inference. This is useful for running actions in a monad transformer stack used in conjunction with 9.8 Runs a pure / computation, since an / computation that performs no effects (i.e. has no effects in its type-level list) is guaranteed to be pure. This is usually used as the final step of running an effectful computation, after all other effects have been discharged using effect handlers.0Typically, this function is composed as follows: someProgram  runEff1 eff1Arg  runEff2 eff2Arg1 eff2Arg2  8 9Like 8, 9 runs an /' computation and extracts the result. Unlike 8, 9 allows a single effect to remain within the type-level list, which must be a monad. The value returned is a computation in that monad, which is useful in conjunction with 7 or 1 for plugging in traditional transformer stacks.:Like ;L, but with support for an explicit state to help implement the interpreter.;Interpret an effect by transforming it into another effect on top of the stack. The primary use case of this function is allow interpreters to be defined in terms of other ones without leaking intermediary implementation details through the type signature.=.Given a request, either handle it or relay it.>Parameterized =+. Allows sending along some state of type s :: *b to be handled for the target effect, or relayed to a handler that can- handle the target effect.?GIntercept the request and possibly reply to it, but leave it unhandled.@Like ?L, but with support for an explicit state to help implement the interpreter.AEmbeds a less-constrained /2 into a more-constrained one. Analogous to MTL's lift.=Handle a pure value.$Handle a request for effect of type  eff :: * -> *.Result with effects of type  eff :: * -> * handled.>Handle a pure value.$Handle a request for effect of type  eff :: * -> *.Result with effects of type  eff :: * -> * handled., (),-./1023456789:;<=>?@A/013267A89=>?@;:<45,-.,-./01Composable Writer effects.D(c) 2016 Allele Dev; 2017 Ixperta Solutions s.r.o.; 2017 Alexis KingBSD3#Alexis King <lexi.lambda@gmail.com> experimental!GHC specific language extensions.None&'+-3;<=>?AQSTV]hI7Writer effects - send outputs to an effect environment.K*Send a change to the attached environment.LSimple handler for I effects.IJKLIJKLIJComposable Trace effects.D(c) 2016 Allele Dev; 2017 Ixperta Solutions s.r.o.; 2017 Alexis KingBSD3#Alexis King <lexi.lambda@gmail.com> experimental!GHC specific language extensions.None&'+-3;<=>?AQSTV]hMA Trace effect; takes a  and performs output.OPrinting a string in a trace.PAn  handler for M effects.MNOPMNOPMNNon deterministic effects/2017 Ixperta Solutions s.r.o.; 2017 Alexis KingBSD3#Alexis King <lexi.lambda@gmail.com> experimental!GHC specific language extensions.None&'+-3;<=>?AQSTV]hQ&A handler for nondeterminstic effects.,-.QR,-.QR *Generation of fresh integers as an effect.D(c) 2016 Allele Dev; 2017 Ixperta Solutions s.r.o.; 2017 Alexis KingBSD3#Alexis King <lexi.lambda@gmail.com> experimental!GHC specific language extensions.None&'+-3;<=>?AQSTV]hrSFresh effect model.URequest a fresh effect.V Handler for S effects, with an G for a starting value. The return value includes the next fresh value.W Handler for S effects, with an 6 for a starting value. Discards the next fresh value.STUVWSTUVWST #Composable coroutine effects layer.D(c) 2016 Allele Dev; 2017 Ixperta Solutions s.r.o.; 2017 Alexis KingBSD3#Alexis King <lexi.lambda@gmail.com> experimental!GHC specific language extensions.None&'+-3;<=>?AQSTV]h9X!Represents status of a coroutine.Y.Coroutine is done with a result value of type r.ZReporting a value of the type a', and resuming with the value of type b', possibly ending with a value of type x.[*A type representing a yielding of control.&Type variables have following meaning: aThe current type.b'The input to the continuation function.cThe output of the continuation.]7Lifts a value and a function into the Coroutine effect.^BReply to a coroutine effect by returning the Continue constructor._)Launch a coroutine and report its status.`GLaunch a coroutine and report its status, without handling (removing) [B from the typelist. This is useful for reducing nested coroutines. XYZ[\]^_` [\]XYZ_`^XYZ[\%Freer - an extensible effects libraryD(c) 2016 Allele Dev; 2017 Ixperta Solutions s.r.o.; 2017 Alexis KingBSD3#Alexis King <lexi.lambda@gmail.com> experimental!GHC specific language extensions.None&'+-3;<=>?AQSTV]h b`The simplest way to produce an effect handler. Given a natural transformation from some effect eff- to some effectful computation with effects effs), produces a natural transformation from / (eff ': effs) to / effs.cLike bb, but instead of handling the effect, allows responding to the effect while leaving it unhandled.dlInterprets an effect in terms of another identical effect. This can be used to eliminate duplicate effects.eLike b1, but instead of removing the interpreted effect f#, reencodes it in some new effect g.fLike e, but encodes the f effect in two" new effects instead of just one.gLike e, but encodes the f effect in three" new effects instead of just one.hLike b, e, f, and g, but allows the result to have any number of additional effects instead of simply 0-3. The problem is that this completely breaks type inference, so you will have to explicitly pick gs using TypeApplications . Prefer b, e, f, or g where possible.ieRuns an effect by translating it into another effect. This is effectively a more restricted form of e4, since both produce a natural transformation from / (f ': effs) to / (g ': effs) for some effects f and g, but iZ does not permit using any of the other effects in the implementation of the interpreter.OIn practice, this difference in functionality is not particularly useful, and e- easily subsumes all of the functionality of i, but the way i: restricts the result leads to much better type inference. i f = e (6 . f) jLike bF, this function runs an effect without introducing another one. Like i{, this function runs an effect by translating it into another effect in isolation, without access to the other effects in effsX. Unlike either of those functions, however, this runs the effect in a final monad in effs, intended to be run with 9. j f = b (7 . f) k1A highly general way of handling an effect. Like b, but explicitly passes the  continuation, a function of type v -> / effs b=, to the handler function. Most handlers invoke this continuation to resume the computation with a particular value as the result, but some handlers may return a value without resumption, effectively aborting the computation to the point where the handler is invoked. This is useful for implementing things like  , for example. b f = k (e -> (f e )) l'Combines the interposition behavior of c0 with the continuation-passing capabilities of k. c f = l (e -> (f e )) ()/6789Abcdefghijkl/)(67A89bcdefghijkl /State effects, for state-carrying computations.D(c) 2016 Allele Dev; 2017 Ixperta Solutions s.r.o.; 2017 Alexis KingBSD3#Alexis King <lexi.lambda@gmail.com> experimental!GHC specific language extensions.None&'+-3;<=>?AQSTV]h mStrict m effects: one can either n values or o them.p0Retrieve the current value of the state of type s :: *.q3Set the current state to a specified value of type s :: *.r!Modify the current state of type s :: * using provided function (s -> s).s[Retrieve a specific component of the current state using the provided projection function.t Handler for m effects.uRun a m( effect, returning only the final state.v/Run a State effect, discarding the final state.weAn encapsulated State handler, for transactional semantics. The global state is updated only if the w finished successfully.GHC cannot infer the sL type parameter for this function, so it must be specified explicitly with TypeApplications5. Alternatively, it can be specified by supplying a  to x.xLike w, but s is specified by providing a  instead of requiring TypeApplications. mnopqrstuvwx mnopqrstvuwxmno 1Reader effects, for encapsulating an environment.D(c) 2016 Allele Dev; 2017 Ixperta Solutions s.r.o.; 2017 Alexis KingBSD3#Alexis King <lexi.lambda@gmail.com> experimental!GHC specific language extensions.None&'+-3;<=>?AQSTV]hy0Represents shared immutable environment of type (e :: *)3 which is made available to effectful computation.{#Request a value of the environment.|URequest a value of the environment, and apply as selector/projection function to it.} Handler for y effects.~4Locally rebind the value in the dynamic environment.7This function is like a relay; it is both an admin for y$ requests, and a requestor of them.|BThe selector/projection function to be applied to the environment.yz{|}~yz{|~}yz An Error effect and handler.D(c) 2016 Allele Dev; 2017 Ixperta Solutions s.r.o.; 2017 Alexis KingBSD3#Alexis King <lexi.lambda@gmail.com> experimental!GHC specific language extensions.None&'+-3;<=>?AQSTV]hExceptions of the type e :: * with no resumption.-Throws an error carrying information of type e :: *.KHandler for exception effects. If there are no exceptions thrown, returns 4. If exceptions are thrown and not handled, returns A, while interrupting the execution of any other effect handlers.EA catcher for Exceptions. Handlers are allowed to rethrow exceptions.'A catcher for Exceptions. Handlers are not allowed to rethrow exceptions.Safe&'+-3;<=>?AQSTV]h !"#$%&'()*+,-../00123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abccdefg h h i j k l m n o o p q r s tuUvwxyz{|}~         +freer-simple-1.1.0.0-D1LJP5BuOCr4roGI6mzTMwControl.Monad.Freer Data.FTCQueueData.OpenUnionData.OpenUnion.InternalControl.Monad.Freer.NonDetControl.Monad.Freer.InternalControl.Monad.Freer.WriterControl.Monad.Freer.TraceControl.Monad.Freer.FreshControl.Monad.Freer.CoroutineControl.Monad.Freer.StateControl.Monad.Freer.ReaderControl.Monad.Freer.ErrorEffStatesendMControl.Monad.BaseliftBaseReader Data.Function& catchErrorPaths_freer_simple1natural-transformation-0.4-6wBZb2D4z6vGOq59DPbie9Control.Natural~>ViewLTOne:|FTCQueue tsingleton|>snoc><appendtviewlWeakensweakens:++:Memberinjprj IfNotFoundFindElemelemNoPunPUnion unsafeInj unsafePrjdecompdecomp0extractweaken $fFindElemt: $fFindElemt:0$fIfNotFoundtrw$fIfNotFoundt:w$fIfNotFoundt:w0 $fMembertr$fIfNotFoundt[]w $fWeakens: $fWeakens[] LastMemberMembers$fLastMemberm:$fLastMemberm:0NonDetMZeroMPlusValEArrsArrqAppqCompsendrunrunM replaceRelayS replaceRelay replaceRelayN handleRelay handleRelayS interpose interposeSraise $fMonadIOEff$fMonadBasebEff $fMonadEff$fApplicativeEff $fFunctorEff$fMonadPlusEff$fAlternativeEffWriterTelltell runWriterTracetracerunTrace makeChoiceAmsplitFreshfreshrunFresh evalFreshStatusDoneContinueYieldyieldreplyCrunC interposeC$fFunctorYield interpretsubsume reinterpret reinterpret2 reinterpret3 reinterpretN translate interpretM interpretWith interposeWithGetPutgetputmodifygetsrunState execState evalStatetransactionStatetransactionState'Askaskasks runReaderlocalError throwErrorrunError handleErrorLeafNode integer-gmpGHC.Integer.TypeIntegerbaseGHC.BaseNothingghc-prim GHC.TypesWord Data.EitherRightLeftMaybeEitherStringBoolreturnpure.transformers-base-0.4.4-HMTAN97NeP1DRzglZsXc77IOInt>>= Data.ProxyProxyversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName