úÎđ3åMĖ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ĄĸŖ¤ĨĻ§¨ŠĒĢŦ­Ž¯°ą˛ŗ´ĩļˇ¸šēģŧŊžŋĀÁÂÃÄÅÆĮČÉĘËNone 09:;<=AOTH Async callsÜExecutes the second operand even if the frist return empty. A normal imperative (monadic) sequence uses the operator (>>) which in the Transient monad does not execute the next operand if the previous one return empty.ŋForces the execution of the second operand even if the first stop. It does not execute the second operand as result of internal events occuring in the first operand. Return the first resultËForces the execution of the second operand even if the first stop. Return the first result. The second operand is executed also when internal events happens in the first operand and it returns something %Dynamic serializable data for logging?­Run a "non transient" computation within the underlying state monad, so it is guaranteed that the computation neither can stop neither can trigger additional events/threads@0Run the transient computation with a blank stateA+Run the transient computation with an stateBMGet the continuation context: closure, continuation, state, child threads etcCORun the closure and the continuation using the state data of the calling threadD=Run the closure and the continuation using his own state dataE3Warning: radiactive untyped stuff. handle with careFCompose a list of continuationsGRun the closure (the x. in 'x >>= f') of the current bind operation.HRun the continuation (the fC in 'x >>= f') of the current bind operation with the current stateK˙run a chain of continuations. It is up to the programmer to assure by construction that each continuation type-check with the next, that the parameter type match the input of the first continuation. Normally this makes sense if it stop the current flow with O after the invocationO’A sinonym of empty that can be used in a monadic expression. it stop the computation and execute the next alternative computation (composed with Ė)PĨWhen the first operand is an asynchronous operation, the second operand is executed once (one single time) when the first completes his first asyncronous operation.†This is useful for spawning asynchronous or distributed tasks that are singletons and that should start when the first one is set up.Rfor example a streaming where the event receivers are acivated before the senders.QBSet the current closure and continuation for the current statementRÍReset the closure and continuation. remove inner binds than the previous computations may have stacked in the list of continuations. resetEventCont :: Maybe a -> EventF -> StateIO (TransIO b -> TransIO b)VzSet the maximun number of threads for a procedure. It is useful to limit the parallelization of transient code that uses v t and qWƒDelete all the previous child threads generated by the expression taken as parameter and continue execution of the current thread.XXAdd a label to the current passing threads so it can be printed by debugging calls like Z[GReturn the state of the thread that initiated the transient computation\vReturn the state variable of the type desired with which a thread, identified by his number in the treee was initiated]FAdd n threads to the limit of threads. If there is no limit, it set it^2Assure that at least there are n threads available_OThe threads generated in the process passed as parameter will not be killed by `kill*` primitives.FSince there is no thread control, the application run slightly faster.`zThe threads will be killed when the parent thread dies. That is the default. This can be invoked to revert the effect of _a0kill all the child threads of the current threadb'Kill the current thread and the childsc*Kill the childs and the thread of an stated8Get the state data for the desired type if there is any.edgetData specialized for the Transient monad. if Nothing, the monadic computation does not continue.If there is no such data, e– silently stop the computation. That may or may not be the desired behaviour. To make sure that this does not get unnoticed, use this construction:  getSData <|> error "no data"/To have the same semantics and guarantees than Í, use a default value: &getInt= getSData <|> return (0 :: Int)The default value (0 in this case) has the same role than the initial value in a state monad. The difference is that you can define as many Í% as you need for all your data types.DTo distingish two data with the same types, use newtype definitions.f Synonym for eg˙-Set session data for this type. retrieved with getData or getSData Note that this is data in a state monad, that means that the update only affect downstream in the monad execution. it is not a global state neither a per user or per thread state it is a monadic state like the one of a state monad.hžModify state data. It accept a function that get the current state (if exist) as parameter. The state will be deleted or changed depending on function resultiSynonym for modifyDataj Synonym for gm9Executes the computation and reset the state if it fails.nFExecutes the computation and reset the state either if it fails or notoxGenerator of identifiers that are unique withing the current monadic sequence They are not unique in the whole program.q Variant of v8 that repeatedly executes the IO computation without endr Variant of v% that execute the IO computation oncesžin an alternative computation it executes an async operations synchronously. This means that the alternatives do not execute until the async operation finishes. Do not use in Applicatives.t!`spawn= freeThreads . waitEvents`uVExecutes an IO action each certain interval of time and return his value if it changesv˙$Return empty to the current thread and execute the IO action in a new thread. When the IO action returns, the transient computation continues with this value as the result The IO action may be re-executed or not depending on the result. So parallel can spawn any number of threads/results.+If the maximum number of threads, set with V has been reached v< perform the work sequentially, in the current thread. So vB means that 'it can be parallelized if there are thread available'uif there is a limitation of threads, when a thread finish, the counter of threads available is increased so another v can make use of it.The behaviour of v depend on ; If  , v( will excute again the IO action. With  ,   and  , v' will not repeat the IO action anymore.zDkill all the child threads associated with the continuation context{De-invert an event handler.–The first parameter is the setter of the event handler to be deinverted. Usually it is the primitive provided by a framework to set an event handlerZthe second parameter is the value to return to the event handler. Usually it is `return()`iit configures the event handler by calling the setter of the event handler with the current continuation|6continue the computation in another thread and return Î) to the computation in the curren thread.-Useful for executing alternative computationsfInstall a event receiver that wait for a string and trigger the continuation when this string arrives.€ĄValidates an input entered in the keyboard in non blocking mode. non blocking means that the user can enter also anything else to activate other option unlike A, wich watch continuously, input only wait for one valid response Non blocking Ī with a validator…Wait for the execution of ‰; and return the result or the exhaustion of thread activity†nKeep the main thread running, initiate the non blocking keyboard input and execute the transient computation.@It also read a slash-separated list of string that are read by  and €( as if they were entered by the keyboard 0 foo -p options/to/be/read/by/option/and/input‡ Same than †Û but do not initiate the asynchronous keyboard input. Useful for debugging or for creating background tasks, as well as to embed the Transient monad inside another computation. It returns either the value returned by ‰4. or Nothing, when there is no more threads running‰{Force the finalization of the main thread and thus, all the Transient block (and the application if there is no more code)Š:Alternative operator for maybe values. Used in infix mode‹2Assures that backtracking will not go further back7The second parameter will be executed when backtracking:Register an action that will be executed when backtracking‘Kbacktracking is stopped. the exection continues forward from this point on.”IExecute backtracking. It execute the registered actions in reverse order.QIf the backtracking flag is changed the flow proceed forward from that point on.SIf the backtrack stack is finished or undoCut executed, the backtracking will stop.—ČInitialize the event variable for finalization. all the following computations in different threads will share it it also isolate this event from other branches that may have his own finish variable˜<Set a computation to be called when the finish event happens™PSet a computation to be called when the finish event happens this only apply forš3Trigger the event, so this closes all the resources›+trigger finish when the stream of data endsœ€When a exception is produced anywhere after this statement, the handler is executed. | handlers are executed Last in first out.ž?stop the backtracking mechanism from executing further handlersŸ(Resume to normal execution at this point¯  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ĄĸŖ¤ĨĻ§¨ŠĒĢŦ­ŽĄ  "!#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¯<=>;:945678&'()*+,-./0123%Ž$?@ABCDEFGHIJK­ŦLMN#Ģ !"ĒŠ¨§OĻ ĨP¤QRSŖĸTUVWXYZ[\]^_`abcdefghijklmnopĄ qrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ …  !"#$%& '()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ĄĸŖ¤ĨĻ§¨ŠĒĢŦ­Ž111NoneTšfslurp a list of values and process them in parallel . To limit the number of processing threads, use VēFalternative definition with more parallelism, as the composition of n r sentencesģMgroup the output of a possible multithreaded process in groups of n elements.ŧ0group result for a time interval, measured with Đžčsearch with a timeout After the timeout, it stop unconditionally and return the current results. It also stops as soon as there are enough results specified in the first parameter. The results are returned by the original thread r timeout t proc=do r <- collect' 1 t proc case r of [] -> empty r:_ -> return r 4 timeout 10000 empty <|> liftIO (print "timeout")’That executes the alternative and will print "timeout". This would not be produced if collect would not return the results to the original threadsearchd is executed in different threads and his state is lost, so don't rely in state to pass informationšēģŧŊžšēģŧŊžšēŊžģŧšēģŧŊžNoneT- 9<=>OPVW^_`adefghijklmoqrtuv{€†‡‰œžŸ-<=>9†‡O€‰rqtvu{jgfedlkhimV^_`WaPœžŸ oNone0Ácreates an EVar.Evars are event vars. ÄC trigger the execution of all the continuations associated to the Ã1 of this variable (the code that is after them).It is like the publish-subscribe pattern but without inversion of control, since a readEVar can be inserted at any place in the Transient flow.˙wEVars are created upstream and can be used to communicate two sub-threads of the monad. Following the Transient philosophy they do not block his own thread if used with alternative operators, unlike the IORefs and TVars. And unlike STM vars, that are composable, they wait for their respective events, while TVars execute the whole expression when any variable is modified.TThe execution continues after the writeEVar when all subscribers have been executed./Now the continuations are executed in parallel.see Yhttps://www.fpcomplete.com/user/agocorona/publish-subscribe-variables-transient-effects-vÂ(delete al the subscriptions for an evar.Ðread the EVar. It only succeed when the EVar is being updated The continuation gets registered to be executed whenever the variable is updated.Ûif readEVar is re-executed in any kind of loop, since each continuation is different, this will register again. The effect is that the continuation will be executed multiple times To avoid multiple registrations, use ÂÄQupdate the EVar and execute all readEVar blocks with "last in-first out" priorityÅ write the EVar and drop all the à handlers.It is like a combination of Ä and ÂŋĀÁÂÃÄÅŋĀÁÂÃÄÅŋĀÁÂÃÄÅŋĀÁÂÃÄÅNone9;ATĮZsave the state of the thread that execute it and exit the transient block initiated with † or similar . †! will return the value passed by Į). If the process is executed again with Æ1 it will reexecute the thread from this point on.it is useful to insert it in finish$ blocks to gather error information,ČQSave the state of every thread at this point. If the process is re-executed with Æ2 it will reexecute the thread from this point on..ÉŦwrite the result of the computation in the log and return it. but if there is data in the internal log, it read the data from the log and do not execute the computation.˙!It accept nested step's. The effect is that if the outer step is executed completely the log of the inner steps are erased. If it is not the case, the inner steps are logged this reduce the log of large computations to the minimum. That is a feature not present in the package Workflow. ƒ r <- logged $ do logged this :: TransIO () logged that :: TransIO () logged thatOther liftIO $ print rwhen Ņ- is executed, the log is just the value of r. but at the  thatOther$ execution the log is: [Exec,(), ()] ŌÆĮČĶÔÕÉĘË#ÆĮČÉĘËÆČĮÉĘË# ŌÆĮČĶÔÕÉĘËNone0AT‹ŒŽ‘’“”–—˜™š›Ž–’Œ”‘‹š˜™—“›Ö       !"#$#%&'(()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ĄĸŖ¤ĨĻ§¨ŠĒĢŦ­Ž¯°ą˛ŗ´ĩļˇ¸šēģŧŊžŋĀĀÁÂÃÄÅÆĮČÉĘËĖÍÎĪĐŅĖÍŌĖĶÔÕÖ×ĖĶØŲÚÛÜŨ&transient-0.5.4-2VKpL5x8WHr4QrGQky1HjJTransient.InternalsTransient.IndeterminismTransient.EVarsTransient.LoggedTransient.BaseTransient.Backtrack FinishReason Backtrack backtracking backStackExit StreamDataSMoreSLastSDoneSErrorAdditionalOperators**><**atEnd'<***atEnd RemoteStatus WasRemote WasParallelNoRemoteLogLogElemWaitExecVar LogEntriesCurrentPointerRecoverIDynamicIDynsLoggableStateIOEffectsEventFmeffectseventxcompfcompmfData mfSequencethreadIdfreeThparentchildren maxThreadlabelth LifeCycleAliveParentListenerDead TransientIOEventIdSDataTransIO TransientrunTransnoTrans runTransient runTransStategetContrunContrunCont'getContinuationscompose runClosurerunContinuationsetContinuationwithContinuationrunContinuations restoreStack readWithErr readsPrec'stop<| setEventContresetEventConttailsafe waitQSemB signalQSemBthreads oneThread labelState printBlock showThreadstopState showState addThreads' addThreads freeThreads hookedThreads killChilds killBranch killBranch'getDatagetSDatagetStatesetData modifyData modifyStatesetStatedelDatadelStatetrysandboxgenId getPrevId waitEventsasyncsyncspawnsampleparallelloopfree hangThread killChildrenreactabduce getLineRefroptionoptioninputgetLine'reads1 inputLoop processLinestaykeepkeep'execCommandLineexit onNothingbackCutundoCutonBackonUndo registerBack registerUndoforwardretrynoFinishback backStateOfundo initFinishonFinish onFinish'finish checkFinalize onException onException' cutExceptionscontinuecatcht$fReadSomeException$fMonadIOTransIO$fMonadTransIO$fMonoidTransIO$fAdditionalOperatorsTransIO $fNumTransIO$fMonadPlusTransIO$fAlternativeTransIO$fReadIDynamic$fShowIDynamic $fLoggablea$fApplicativeTransIO$fFunctorTransIO$fMonadStateEventFTransIO $fEqLifeCycle$fShowLifeCycle $fReadLogElem $fShowLogElem $fShowLog$fEqRemoteStatus$fShowRemoteStatus$fShowStreamData$fReadStreamData$fShowFinishReasonchoosechoose'group groupByTimecollectcollect'EVarnewEVar cleanEVarreadEVar writeEVar lastWriteEVarrestoresuspend checkpointloggedreceivedparambaseGHC.Base<|> mtl-2.2.1-6qsR1PHUy5lL47Hpoa4jCMControl.Monad.State.Classgetempty System.IOgetLine time-1.6.0.1Data.Time.Clock.UTCDiff diffUTCTimeprintlogslogAllfromIDyntoIDyn