!      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ (c) 2016 Michael WalkerMIT%Michael Walker <mike@barrucadu.co.uk> experimental.CPP, RankNTypes, TemplateHaskell, TypeFamiliesSafeDORTMonadSTM is an abstraction over STM.FThis class does not provide any way to run transactions, rather each  MonadConc has an associated MonadSTM1 from which it can atomically run a transaction..The mutable reference type. These behave like Ws, in that they always contain a value and updates are non-blocking and synchronised. Create a new TVar containing the given value. newTVar = newTVarN "" Create a new TVaru containing the given value, but it is given a name which may be used to present more useful debugging information.]If an empty name is given, a counter starting from 0 is used. If names conflict, successive TVarEs with the same name are given a numeric suffix, counting up from 1. newTVarN _ = newTVar%Return the current value stored in a TVar."Write the supplied value into the TVar.CRetry execution of this transaction because it has seen values in TVarjs that it shouldn't have. This will result in the thread running the transaction being blocked until any TVar&s referenced in it have been mutated. This is just . 4Check whether a condition is true and, if not, call retry. %Run the first transaction and, if it retrys, run the second instead. This is just . NThrow an exception. This aborts the transaction and propagates the exception. Handling exceptions from  .      (c) 2016 Michael WalkerMIT%Michael Walker <mike@barrucadu.co.uk> experimentalOCPP, FlexibleContexts, PolyKinds, RankNTypes, ScopedTypeVariables, TypeFamiliesNone +:DORTB MonadConc is an abstraction over GHC's typical concurrency abstraction. It captures the interface of concurrency monads in terms of how they can operate on shared state and in the presence of exceptions.Every  MonadConc has an associated /, transactions of which can be run atomically.The associated  for this class.!The mutable reference type, like Vs. This may contain one value at a time, attempting to read or take from an "empty" MVarA will block until it is full, and attempting to put to a "full" MVar will block until it is empty.tThe mutable non-blocking reference type. These may suffer from relaxed memory effects if functions outside the set newCRef, readCRef, atomicModifyCRef, and atomicWriteCRef are used./When performing compare-and-swap operations on CRefs, a Ticket> is a proof that a thread observed a specific previous value.An abstract handle to a thread.JFork a computation to happen concurrently. Communication may happen over MVars. #fork ma = forkWithUnmask (const ma)Like , but the child thread is passed a function that can be used to unmask asynchronous exceptions. This function should not be used within a F or G. #forkWithUnmask = forkWithUnmaskN ""Like a, but the thread is given a name which may be used to present more useful debugging information.If an empty name is given, the ThreadIdt is used. If names conflict, successive threads with the same name are given a numeric suffix, counting up from 1. "forkWithUnmaskN _ = forkWithUnmaskPFork a computation to happen on a specific processor. The specified int is the capability number, typically capabilities correspond to physical processors or cores but this is implementation dependent. The int is interpreted modulo to the total number of capabilities as returned by ". +forkOn c ma = forkOnWithUnmask c (const ma) Like <, but the child thread is pinned to the given CPU, as with . 'forkOnWithUnmask = forkOnWithUnmaskN ""!Like <, but the child thread is pinned to the given CPU, as with . &forkOnWithUnmaskN _ = forkOnWithUnmask">Get the number of Haskell threads that can run simultaneously.#>Set the number of Haskell threads that can run simultaneously.$Get the ThreadId of the current thread.%IAllows a context-switch to any other currently runnable thread (if any).&jYields the current thread, and optionally suspends the current thread for a given number of microseconds.If suspended, there is no guarantee that the thread will be rescheduled promptly when the delay has expired, but the thread will never continue to run earlier than specified. threadDelay _ = yield'Create a new empty MVar. newEmptyMVar = newEmptyMVarN ""(Create a new empty MVarY, but it is given a name which may be used to present more useful debugging information.]If an empty name is given, a counter starting from 0 is used. If names conflict, successive MVarEs with the same name are given a numeric suffix, counting up from 1. newEmptyMVarN _ = newEmptyMVar)Put a value into a MVar. If there is already a value there, this will block until that value has been taken, at which point the value will be stored.*Attempt to put a value in a MVar non-blockingly, returning  (and filling the MVar3) if there was nothing there, otherwise returning .+&Block until a value is present in the MVarV, and then return it. This does not "remove" the value, multiple reads are possible.,Attempt to read a value from a MVar non-blockingly, returning a  (and emptying the MVar4) if there is something there, otherwise returning  . As with +$, this does not "remove" the value.-Take a value from a MVar. This "empties" the MVarS, allowing a new value to be put in. This will block if there is no value in the MVar! already, until one has been put..Attempt to take a value from a MVar non-blockingly, returning a  (and emptying the MVar5) if there was something there, otherwise returning ./Create a new reference. newCRef = newCRefN ""0oCreate a new reference, but it is given a name which may be used to present more useful debugging information.]If an empty name is given, a counter starting from 0 is used. If names conflict, successive CRefEs with the same name are given a numeric suffix, counting up from 1. newCRefN _ = newCRef1-Read the current value stored in a reference. .readCRef cref = readForCAS cref >>= peekTicket2WAtomically modify the value stored in a reference. This imposes a full memory barrier.3Write a new value into an CRef], without imposing a memory barrier. This means that relaxed memory effects can be observed.4WReplace the value stored in a reference, with the barrier-to-reordering property that 2 has. 8atomicWriteCRef r a = atomicModifyCRef r $ const (a, ())5;Read the current value stored in a reference, returning a Ticket0, for use in future compare-and-swap operations.6(Extract the actual Haskell value from a Ticket.The proxy m is to determine the m in the Ticket type.7?Perform a machine-level compare-and-swap (CAS) operation on a CRef). Returns an indication of success and a Ticket$ for the most current value in the CRef.+This is strict in the "new" value argument.8A replacement for 2 using a compare-and-swap.+This is strict in the "new" value argument.9 A variant of 8 which doesn't return a result. <modifyCRefCAS_ cref f = modifyCRefCAS cref (\a -> (f a, ())):&Perform an STM transaction atomically.;#Read the current value stored in a TVar1. This may be implemented differently for speed. $readTVarConc = atomically . readTVar<Throw an exception to the target thread. This blocks until the exception is delivered, and it is just as if the target thread had raised it with D&. This can interrupt a blocked action.=GCreate a concurrent computation for the provided action, and return a MVar' which can be used to query the result.>Fork a thread and call the supplied function when the thread is about to terminate, with an exception or a returned value. The function is called with asynchronous exceptions masked.WThis function is useful for informing the parent when a child terminates, for example.? Raise the z exception in the target thread. Note that if the thread is prepared to catch this exception, it won't actually kill it.@Like a, but the thread is given a name which may be used to present more useful debugging information.If no name is given, the ThreadIdt is used. If names conflict, successive threads with the same name are given a numeric suffix, counting up from 1.ALike a, but the thread is given a name which may be used to present more useful debugging information.If no name is given, the ThreadIdt is used. If names conflict, successive threads with the same name are given a numeric suffix, counting up from 1.B+Provided for compatibility, always returns .C+Provided for compatibility, always returns .DThrow an exception. This will "bubble up" looking for an exception handler capable of dealing with it and, if one is not found, the thread is killed.ETCatch an exception. This is only required to be able to catch exceptions raised by D^, unlike the more general Control.Exception.catch function. If you need to be able to catch all errors, you will have to use .F5Executes a computation with asynchronous exceptions maskedW. That is, any thread which attempts to raise an exception in the current thread with <C will be blocked until asynchronous exceptions are unmasked again.The argument passed to mask is a function that takes as its argument another function, which can be used to restore the prevailing masking state within the context of the masked computation. This function should not be used within an G.GLike F{, but the masked computation is not interruptible. THIS SHOULD BE USED WITH GREAT CARE, because if a thread executing in G blocks for any reason, then the thread (and possibly the program, if this is the main thread) will be unresponsive and unkillable. This function should only be necessary if you need to mask exceptions around an interruptible operation, and you can guarantee that the interruptible operation will only block for a short period of time. The supplied unmasking function should not be used within a F.H Create a new MVar containing a value.I Create a new MVarl containing a value, but it is given a name which may be used to present more useful debugging information.WIf no name is given, a counter starting from 0 is used. If names conflict, successive MVarEs with the same name are given a numeric suffix, counting up from 1.J(Extract the actual Haskell value from a Ticket.0This doesn't do do any monadic computation, the m. appears in the result type to determine the m in the Ticket type.KCompare-and-swap a value in a CRef8, returning an indication of success and the new value.9Label the current thread, if the given label is nonempty.LWGiven a function to remove the transformer-specific state, lift a function invocation.MCGiven a function to remove the transformer-specific state, lift a fork(on)WithUnmask invocation.NUNew threads inherit the states of their parent, but do not communicate results back.OUNew threads inherit the states of their parent, but do not communicate results back.PTNew threads inherit the state of their parent, but do not communicate results back.QTNew threads inherit the state of their parent, but do not communicate results back.R[New threads inherit the writer state of their parent, but do not communicate results back.S[New threads inherit the writer state of their parent, but do not communicate results back.TU[New threads inherit the reader state of their parent, but do not communicate results back.VB !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUV:5<'-+).*, "#$%:&/1324(;!06789=>?@ABCDEFGHIJKLM: !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIKJLM& !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUV(c) 2016 Michael WalkerMIT%Michael Walker <mike@barrucadu.co.uk>stableportableNoneWMutate the contents of a . This is non-strict.XMutate the contents of a  strictly.YSwap the contents of a , returning the old value.ZSet the value of returned  to TrueD after a given number of microseconds. The caveats associated with & also apply.WXYZ ;WXYZ ;WXYZWXYZ(c) 2016 Michael WalkerMIT%Michael Walker <mike@barrucadu.co.uk>stableportableSafe [[< is an abstract type representing an unbounded FIFO channel.\$Build and returns a new instance of []Write a value to a [.^Read the next value from the [._ A version of ^+ which does not retry. Instead it returns Nothing if no value is available.`Get the next value from the TQueue8 without removing it, retrying if the channel is empty.a A version of `+ which does not retry. Instead it returns Nothing if no value is available.bIPut a data item back onto a channel, where it will be the next item read.cReturns  if the supplied [ is empty. [\]^_`abc [\]^_`abc [\^_`a]bc [\]^_`abc(c) 2016 Michael WalkerMIT%Michael Walker <mike@barrucadu.co.uk>stableportableSafe dA TMVar is like an MVar or a mVara, but using transactional memory. As transactions are atomic, this makes dealing with multiple TMVar!s easier than wrangling multiple mVars.e Create a d containing the given value.f Create a d2 containing the given value, with the given name.(Name conflicts are handled as usual for (s. The name is prefixed with "ctmvar-".gCreate a new empty d.hCreate a new empty d with the given name.(Name conflicts are handled as usual for (s. The name is prefixed with "ctmvar-".iTake the contents of a d, or  if it is empty.j Write to a d, or  if it is full.k Read from a d without emptying, or  if it is empty.lTry to take the contents of a d , returning  if it is empty.mTry to write to a d , returning  if it is full.nTry to read from a d without emptying, returning  if it is empty.o Check if a d is empty or not.pSwap the contents of a d! returning the old contents, or  if it is empty.defghijklmnop defghijklmnop defghijklmnop defghijklmnop(c) 2016 Michael WalkerMIT%Michael Walker <mike@barrucadu.co.uk>stableportableSafe qq= is an abstract type representing an unbounded FIFO channel.r#Build and return a new instance of qsCreate a write-only q. More precisely, u will x even after items have been written to the channel. The only way to read a broadcast channel is to duplicate it with y.tWrite a value to a q.uRead the next value from the q.v A version of u+ which does not retry. Instead it returns Nothing if no value is available.wGet the next value from the q8 without removing it, retrying if the channel is empty.x A version of w+ which does not retry. Instead it returns Nothing if no value is available.y Duplicate a q: the duplicate channel begins empty, but data written to either channel from then on will be available from both. Hence this creates a kind of broadcast channel, where data written by anyone is seen by everyone else.zJPut a data item back onto a channel, where it will be the next item read.{Returns  if the supplied q is empty.|Clone a q : similar to yY, but the cloned channel starts with the same content available as the original channel.qrstuvwxyz{| qrstuvwxyz{| qrsy|uvwxtz{qrstuvwxyz{|(c) 2016 Michael WalkerMIT%Michael Walker <mike@barrucadu.co.uk>stableportableSafe }}: is an abstract type representing a bounded FIFO channel.~$Build and returns a new instance of }Write a value to a }; retries if the queue is full.Read the next value from the }. A version of + which does not retry. Instead it returns Nothing if no value is available.Get the next value from the TBQueue8 without removing it, retrying if the channel is empty. A version of + which does not retry. Instead it returns Nothing if no value is available.hPut a data item back onto a channel, where it will be the next item read. Retries if the queue is full.Returns  if the supplied } is empty.Returns  if the supplied } is full. }~-maximum number of elements the queue can hold }~ }~ }~(c) 2016 Michael WalkerMIT%Michael Walker <mike@barrucadu.co.uk>stable(FlexibleInstances, MultiParamTypeClassesNone9;<=TArray0 is a transactional array, supporting the usual  interface for mutable arrays.It is currently implemented as Array ix (TVar stm e)z, but it may be replaced by a more efficient implementation in the future (the interface will remain the same, however).Like  replicateM= but uses an accumulator to prevent stack overflows. Unlike  replicateM the returned list is in reversed order. This doesn't matter though since this function is only used to create arrays with identical elements.(c) 2016 Michael WalkerMIT%Michael Walker <mike@barrucadu.co.uk> experimental non-portableNone= ;WXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ (c) 2016 Michael WalkerMIT%Michael Walker <mike@barrucadu.co.uk>stableportableNoneSwap the contents of a MVarf, and return the value taken. This function is atomic only if there are no other producers fro this MVar. Check if a MVar is empty.CThe boolean value returned is just a snapshot of the state of the MVar], it may have been emptied (or filled) by the time you actually access it. Generally prefer *, ., and ,.Operate on the contents of a MVar{, replacing the contents after finishing. This operation is exception-safe: it will replace the original contents of the MVara if an exception is raised. However, it is only atomic if there are no other producers for this MVar.Like  , but the IOP action in the second argument is executed with asynchronous exceptions masked.:An exception-safe wrapper for modifying the contents of a MVar. Like , , will replace the original contents of the MVary if an exception is raised during the operation. This function is only atomic if there are no other producers for this MVar.A slight variation on & that allows a value to be returned (b+) in addition to the modified value of the MVar.Like  , but the IOP action in the second argument is executed with asynchronous exceptions masked.Like  , but the IOP action in the second argument is executed with asynchronous exceptions masked.*.+)-('HI'(HI-)+.* (c) 2016 Michael WalkerMIT%Michael Walker <mike@barrucadu.co.uk>stableportableNone is a quantity semaphore in which the resource is aqcuired and released in units of one. It provides guaranteed FIFO ordering for satisfying blocked  calls. The pattern ,bracket_ (waitQSemN n) (signalQSemN n) (...),is safe; it never loses any of the resource. Build a new M with a supplied initial quantity. The initial quantity must be at least 0.3Wait for the specified quantity to become available7Signal that a given quantity is now available from the .3Fix the queue and signal as many threads as we can. (c) 2016 Michael WalkerMIT%Michael Walker <mike@barrucadu.co.uk>stableportableNoneQSem is a quantity semaphore in which the resource is acquired and released in units of one. It provides guaranteed FIFO ordering for satisfying blocked  calls. The pattern "bracket_ qaitQSem signalSSem (...)/is safe; it never loses a unit of the resource. Build a new L with a supplied initial quantity. The initial quantity must be at least 0.$Wait for a unit to become available.Signal that a unit of the  is available. (c) 2016 Michael WalkerMIT%Michael Walker <mike@barrucadu.co.uk>stableportableNone= is an abstract type representing an unbounded FIFO channel.$Build and returns a new instance of .Write a value to a .Read the next value from the . Duplicate a : the duplicate channel begins empty, but data written to either channel from then on will be available from both. Hence this creates a kind of broadcast channel, where data written by anyone is seen by everyone else.#Write an entire list of items to a .  (c) 2016 Michael WalkerMIT%Michael Walker <mike@barrucadu.co.uk>stableportableNoneMutate the contents of a CRef.Be warned that H does not apply the function strictly. This means if the program calls  many times, but seldomly uses the value, thunks will pile up in memory resulting in a space leak. This is a common mistake made when using a CRefQ as a counter. For example, the following will likely produce a stack overflow: Qref <- newCRef 0 replicateM_ 1000000 $ modifyCRef ref (+1) readCRef ref >>= printTo avoid this problem, use  instead.Strict version of Strict version of 2,. This forces both the value stored in the CRef as well as the value returned.4231//1324NoneOT@A value of type Concurrently m a is a  MonadConc, operation that can be composed with other  Concurrently values, using the  Applicative and  Alternative instances.Calling runConcurrently on a value of type Concurrently m a will execute the  MonadConcL operations it contains concurrently, before delivering the result of type a. For example (page1, page2, page3) <- runConcurrently $ (,,) <$> Concurrently (getURL "url1") <*> Concurrently (getURL "url2") <*> Concurrently (getURL "url3")"An asynchronous action spawned by  or . Asynchronous actions are executed in a separate thread, and operations are provided for waiting for asynchronous actions to complete and obtaining their results (see e.g. ).'Note that, unlike the "async" package,  here does not have an  instance. This is because  s do not necessarily have one.2Spawn an asynchronous action in a separate thread.Like <, but using a named thread for better debugging information.Like  but using  internally.Like ; but using a named thread for better debugging information.Like  but using  internally.Like ; but using a named thread for better debugging information.Like  but using   internally.Like ; but using a named thread for better debugging information.-Fork a thread with the given forking functionYFork a thread with the given forking function and give it an action to unmask exceptionsASpawn an asynchronous action in a separate thread, and pass its AsyncU handle to the supplied function. When the function returns or throws an exception,  is called on the Async. JwithAsync action inner = bracket (async action) uninterruptiblCancel innerThis is a useful variant of  that ensures an Async( is never left running unintentionally.Since  may block,  may also block; see  for details.Like  but uses  internally.Like  bit uses  internally.Like  bit uses   internally. Helper for  and ]: fork a thread with the given forking function and kill it when the inner action completes. Helper for  and : fork a thread with the given forking function, give it an action to unmask exceptions, and kill it when the inner action completed. Helper for  and <: run the inner action and kill the async thread when done.Wait for an asynchronous action to complete, and return its value. If the asynchronous value threw an exception, then the exception is re-thrown by . wait = atomically . waitSTM A version of  that can be used inside a MonadSTM transaction.Check whether an E has completed yet. If it has not completed yet, then the result is Nothing, otherwise the result is Just e where e is Left x if the Async raised an exception x, or Right a if it returned a value a. poll = atomically . pollSTM A version of  that can be used inside a MonadSTM transaction.@Wait for an asynchronous action to complete, and return either Left e# if the action raised an exception e, or Right a if it returned a value a. A version of  that can be used inside a MonadSTM transaction..Cancel an asynchronous action by throwing the  ThreadKilled' exception to it, and waiting for the ' thread to quit. Has no effect if the  has already completed. @cancel a = throwTo (asyncThreadId a) ThreadKilled <* waitCatch a Note that ) will not terminate until the thread the , refers to has terminated. This means that Y will block for as long as said thread blocks when receiving an asynchronous exception.An asynchronous ( can of course be obtained by wrapping  itself in .Cancel an asynchronous action.This is a variant of  but it is not interruptible.HCancel an asynchronous action by throwing the supplied exception to it. ,cancelWith a e = throwTo (asyncThreadId a) e*The notes about the synchronous nature of  also apply to .Wait for any of the supplied ds to complete. If the first to complete throws an exception, then that exception is re-thrown by . If multiple Zs complete or have completed, then the value returned corresponds to the first completed  in the list. A version of  that can be used inside a MonadSTM transaction.gWait for any of the supplied asynchronous operations to complete. The value returned is a pair of the ; that completed, and the result that would be returned by  on that . If multiple Zs complete or have completed, then the value returned corresponds to the first completed  in the list. A version of  that can be used inside a MonadSTM transaction.Like S, but also cancels the other asynchronous operations as soon as one has completed.Like S, but also cancels the other asynchronous operations as soon as one has completed.Wait for the first of two Asyncs to finish. If the AsyncO that finished first raised an exception, then the exception is re-thrown by . A version of  that can be used inside a MonadSTM transaction.Wait for the first of two Async s to finish. A version of  that can be used inside a MonadSTM transaction.Like  , but also s both Asyncs before returning.Like  , but also s both Asyncs before returning.Like , but the result is ignored. A version of  that can be used inside a MonadSTM transaction.Waits for both Async|s to finish, but if either of them throws an exception before they have both finished, then the exception is re-thrown by . A version of  that can be used inside a MonadSTM transaction.Link the given Async* to the current thread, such that if the AsyncN raises an exception, that exception will be re-thrown in the current thread. Link two Asynccs together, such that if either raises an exception, the same exception is re-thrown in the other Async.Fork a thread that runs the supplied action, and if it raises an exception, re-runs the action. The thread terminates only when the action runs to completion without raising an exception.Run two  MonadConcQ actions concurrently, and return the first to finish. The loser of the race is led. Urace left right = withAsync left $ \a -> withAsync right $ \b -> waitEither a bLike , but the result is ignored. Wrace_ left right = withAsync left $ \a -> withAsync right $ \b -> waitEither_ a bRun two  MonadConc} actions concurrently, and return both results. If either action throws an exception at any time, then the other action is (led, and the exception is re-thrown by . [concurrently left right = withAsync left $ \a -> withAsync right $ \b -> waitBoth a b is  but ignores the return values.Maps a  MonadConc-performing function over any  Traversable data type, performing all the  MonadConcn actions concurrently, and returning the original data structure with the arguments replaced by the results. For example, mapConcurrently works with lists: 8pages <- mapConcurrently getURL ["url1", "url2", "url3"] is  with its arguments flipped Fpages <- forConcurrently ["url1", "url2", "url3"] $ \url -> getURL url is - with the return value discarded, just like . is - with the return value discarded, just like .2Perform the action in the given number of threads. is # with the return values discarded. Only defined for base >= 4.9.0.0G67B(c) 2016 Michael WalkerMIT%Michael Walker <mike@barrucadu.co.uk> experimental non-portableNone 5<'-+).*, "#$%:&/1324(;!06789=>?@ABCDEFGHIJKLMWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~    nw           *concurrency-1.2.1.2-2VLrtqApQx32VwaT0uE4i9Control.Monad.Conc.ClassControl.Monad.STM.Class"Control.Concurrent.Classy.STM.TVar$Control.Concurrent.Classy.STM.TQueue#Control.Concurrent.Classy.STM.TMVar#Control.Concurrent.Classy.STM.TChan%Control.Concurrent.Classy.STM.TBQueue$Control.Concurrent.Classy.STM.TArrayControl.Concurrent.Classy.MVarControl.Concurrent.Classy.QSemNControl.Concurrent.Classy.QSemControl.Concurrent.Classy.ChanControl.Concurrent.Classy.CRefControl.Concurrent.Classy.AsyncControl.Concurrent.Classy.STMControl.Concurrent.Classy'exceptions-0.8.3-74UMKX8an841ULC0nHtYN7Control.Monad.CatchuninterruptibleMask_mask_MonadSTMTVarnewTVarnewTVarNreadTVar writeTVarretrycheckorElsethrowSTMcatchSTM$fMonadSTMRWST$fMonadSTMRWST0$fMonadSTMStateT$fMonadSTMStateT0$fMonadSTMWriterT$fMonadSTMWriterT0$fMonadSTMIdentityT$fMonadSTMReaderT $fMonadSTMSTM MonadConcSTMMVarCRefTicketThreadIdforkforkWithUnmaskforkWithUnmaskNforkOnforkOnWithUnmaskforkOnWithUnmaskNgetNumCapabilitiessetNumCapabilities myThreadIdyield threadDelay newEmptyMVar newEmptyMVarNputMVar tryPutMVarreadMVar tryReadMVartakeMVar tryTakeMVarnewCRefnewCRefNreadCRefatomicModifyCRef writeCRefatomicWriteCRef readForCAS peekTicket'casCRef modifyCRefCASmodifyCRefCAS_ atomically readTVarConcthrowTospawn forkFinally killThreadforkNforkOnNrtsSupportsBoundThreadsisCurrentThreadBoundthrowcatchmaskuninterruptibleMasknewMVarnewMVarN peekTicketcasliftedF liftedFork$fMonadConcRWST$fMonadConcRWST0$fMonadConcStateT$fMonadConcStateT0$fMonadConcWriterT$fMonadConcWriterT0$fMonadConcIdentityT$fMonadConcReaderT $fMonadConcIO modifyTVar modifyTVar'swapTVar registerDelayTQueue newTQueue writeTQueue readTQueue tryReadTQueue peekTQueue tryPeekTQueue unGetTQueue isEmptyTQueueTMVarnewTMVar newTMVarN newEmptyTMVarnewEmptyTMVarN takeTMVarputTMVar readTMVar tryTakeTMVar tryPutTMVar tryReadTMVar isEmptyTMVar swapTMVarTChannewTChannewBroadcastTChan writeTChan readTChan tryReadTChan peekTChan tryPeekTChandupTChan unGetTChan isEmptyTChan cloneTChanTBQueue newTBQueue writeTBQueue readTBQueuetryReadTBQueue peekTBQueuetryPeekTBQueue unGetTBQueueisEmptyTBQueue isFullTBQueueTArray$fMArrayTArrayestmswapMVar isEmptyMVarwithMVarwithMVarMasked modifyMVar_ modifyMVarmodifyMVarMasked_modifyMVarMaskedQSemNnewQSemN waitQSemN signalQSemNQSemnewQSemwaitQSem signalQSemChannewChan writeChanreadChandupChanwriteList2Chan modifyCRef modifyCRef'atomicModifyCRef' ConcurrentlyrunConcurrentlyAsync asyncThreadIdasyncasyncNasyncOnasyncOnNasyncWithUnmaskasyncWithUnmaskNasyncOnWithUnmaskasyncOnWithUnmaskN withAsync withAsyncOnwithAsyncWithUnmaskwithAsyncOnWithUnmaskwaitwaitSTMpollpollSTM waitCatch waitCatchSTMcanceluninterruptibleCancel cancelWithwaitAny waitAnySTM waitAnyCatchwaitAnyCatchSTM waitAnyCancelwaitAnyCatchCancel waitEither waitEitherSTMwaitEitherCatchwaitEitherCatchSTMwaitEitherCancelwaitEitherCatchCancel waitEither_waitEitherSTM_waitBoth waitBothSTMlinklink2racerace_ concurrently concurrently_mapConcurrentlyforConcurrentlymapConcurrently_forConcurrently_replicateConcurrentlyreplicateConcurrently_$fMonoidConcurrently$fSemigroupConcurrently$fAlternativeConcurrently$fApplicativeConcurrently$fFunctorConcurrently$fFunctorAsync $fEqAsyncbaseGHC.Basemzeromplusghc-prim GHC.TypesTrueFalseJustNothingGHC.IO.Exception ThreadKilledIOlabelMeTListTNilTConsTVarList array-0.5.1.1Data.Array.BaseMArrayrepsignalChItemStream GHC.ClassesOrd asyncUsingasyncUnmaskUsingwithAsyncUsingwithAsyncUnmaskUsing withAsyncDo forkRepeat Data.FoldablemapM_forM_ _asyncWaitcatchAll concurrently'