úÎ!9˜7˜     Safem  Safe . pooled-io/Execute all actions parallelly but run at most numCapabilities threads at once. Stop when all actions are finished. If a thread throws an exception this terminates only the throwing thread. pooled-iolExecute all actions parallelly without a bound an the number of threads. Stop when all actions are finished. pooled-io[If a thread ends with an exception, then terminate all threads and forward that exception. runException Nothing* chooses to use all capabilities, whereas runException (Just n) chooses n capabilities.None!… pooled-iof runs an IO action in parallel while respecting a maximum number of threads. Evaluating the result of 3 waits for the termination of the according thread.;Unfortunately, this means that sometimes threads are bored: Efoo a b = do c <- fork $ f a d <- fork $ g c e <- fork $ h bHere the execution of g cA reserves a thread but starts with waiting for the evaluation of c*. It would be certainly better to execute h b… first. You may relax this problem by moving dependent actions away from another as much as possible. It would be optimal to have an  OutOfOrder0 monad, but this is more difficult to implement.ÏAlthough we fork all actions in order, the fork itself might re-order the actions. Thus the actions must not rely on a particular order other than the order imposed by data dependencies. We enforce with the !R constraint that the computation is actually completed when the thread terminates.{Currently the monad does not handle exceptions. It's certainly best to use a package with explicit exception handling like explicit-exceptionT in order to tunnel exception information from the forked action to the main thread. Although ' has almost the same type signature as " we do not define instance MonadIO InOrder.TB since this definition would not satisfy the laws required by the MonadIO class. pooled-io with a maximum of numCapabilites threads. pooled-io runLimited n- runs several actions in a pool with at most n threads.Safe*o  pooled-io¸This runs an action parallelly to the starting thread. Since it is an Applicative Functor and not a Monad, there are no data dependencies between the actions and thus all actions in a  ! can be run parallelly. Only the #C actions are parallelised but not the combining function passed to liftA23 et.al. That is, the main work must be done in the #2 actions in order to benefit from parallelisation.  pooled-io with a maximum of numCapabilites threads. pooled-io runLimited n- runs several actions in a pool with at most n threads.   Safe7d pooled-io4Run the sequencing thread. You will usually fork it. pooled-ioxThis is primarily intended for output functions. You should make sure that the emitted data is evaluated before calling a. Otherwise the sequencing thread will evaluate it and thus not much parallelization will happen.Example: 4async seqIn . writeFile "foobar.txt" $!! show result pooled-ioÿ·This is primarily intended for input functions. You should also call it at the end of a thread in order to make sure that all your asynchronous actions are completed. It will actually also wait for the actions that were requested by other threads. However, I think this should not hurt since after completion of the current thread another one will be started and it will certainly begin with an input action, which has to be queued anyway.$           !"#$(pooled-io-0.0.2.2-4WLplHC51mSJywtjGBxLnm'Control.Concurrent.PooledIO.Independent#Control.Concurrent.PooledIO.InOrder!Control.Concurrent.PooledIO.Final$Control.Concurrent.PooledIO.Sequence!Control.Concurrent.PooledIO.Monadrun runLimited runUnlimited runExceptionTfork$fMonadT$fApplicativeT $fFunctorTOutInnewasyncsync forkFinallyforkTryapplyStrictRight takeMVarTryrunTrychooseNumCapabilitieswithNumCapabilitiesdeepseq-1.4.3.0Control.DeepSeqNFDatabaseControl.Monad.IO.ClassliftIOghc-prim GHC.TypesIO