module Preliminaries
(
module Lens.Micro.Platform
, module Lens.Micro.Contra
, module Data.Conduit.Async
, module Data.Conduit.TQueue
, module Control.Monad.Par
, parFork
, parNew
, parNewFull
, parGet
, parPut
, parSpawn
, parParMap
, module Control.Monad.Parallel
, module Control.Parallel
, module Control.Parallel.Strategies
, thru
, module Control.Monad.Reader
, module Control.Monad.State.Lazy
, module Control.Monad.Writer.Lazy
, module ClassyPrelude.Conduit
, module Data.Biapplicative
, module Data.Bifoldable
, module Data.Bitraversable
, module Data.MonoTraversable.Instances
, module Data.Default
, type ($)
)
where
import Control.Monad.Reader (MonadReader, ask, asks, ReaderT (..), Reader, runReaderT, runReader)
import Control.Monad.State.Lazy (MonadState, get, put, modify, StateT(..), State, runStateT, runState)
import Control.Monad.Writer.Lazy (MonadWriter, tell, listen, listens, WriterT(..), Writer, runWriterT, runWriter)
import Control.Monad.Par as Par
import Control.Monad.Par.Class (ParFuture)
import Control.Monad.Par (Par, runPar, runParIO, IVar, parMapM, parMapReduceRange, InclusiveRange(..), parFor)
import Control.Monad.Parallel (MonadFork, forkExec)
import Control.Parallel
import Control.Parallel.Strategies as Strategies
import Control.Parallel.Strategies
( Strategy, withStrategy
, rseq, rdeepseq
, rpar, rparWith
, evalTraversable, parTraversable, parMap
, ($|), ($||), (.|), (.||), (-|), (-||)
, Eval, runEval
)
import ClassyPrelude.Conduit
import Data.Biapplicative (Biapplicative, bipure, (<<*>>))
import Data.Bifoldable (Bifoldable, bifoldr, bifold, bifoldMap, bitraverse_, bisequenceA_, bifor_)
import Data.Bitraversable (Bitraversable, bitraverse, bisequenceA, bifor)
import Data.Conduit.Async
import Data.Conduit.TQueue
import Data.Default
import Data.MonoTraversable.Instances ()
import Lens.Micro.Platform
import Lens.Micro.Contra
parFork :: Par () -> Par ()
parFork = Par.fork
parNew :: Par (IVar a)
parNew = Par.new
parNewFull :: NFData a => a -> Par (IVar a)
parNewFull = Par.newFull
parGet :: IVar a -> Par a
parGet = Par.get
parPut :: NFData a => IVar a -> a -> Par ()
parPut = Par.put
parSpawn :: NFData a => Par a -> Par (IVar a)
parSpawn = Par.spawn
parParMap :: (Traversable t, NFData b, ParFuture iv p) => (a -> b) -> t a -> p (t b)
parParMap = Par.parMap
thru :: a -> Strategy a -> a
x `thru` strat = x `Strategies.using` strat
type f $ x = f x