module Control.Concurrent.RCU.Class
( MonadNew(..)
, MonadReading(..)
, MonadWriting(..)
, MonadRCU(..)
, copySRef
) where
import Control.Applicative
import Control.Monad
import Control.Monad.Trans.Class
import Control.Monad.Trans.Except
import Control.Monad.Trans.Identity
import Control.Monad.Trans.Maybe
import Control.Monad.Trans.Reader
import Prelude hiding (read, Read)
import qualified Control.Monad.Trans.RWS.Lazy as Lazy
import qualified Control.Monad.Trans.RWS.Strict as Strict
import qualified Control.Monad.Trans.State.Lazy as Lazy
import qualified Control.Monad.Trans.State.Strict as Strict
import qualified Control.Monad.Trans.Writer.Lazy as Lazy
import qualified Control.Monad.Trans.Writer.Strict as Strict
class Monad m => MonadNew s m | m -> s where
newSRef :: a -> m (s a)
default newSRef :: (m ~ t n, MonadTrans t, MonadNew s n) => a -> m (s a)
newSRef a = lift (newSRef a)
instance MonadNew s m => MonadNew s (ReaderT e m)
instance (MonadNew s m, Monoid w) => MonadNew s (Strict.WriterT w m)
instance (MonadNew s m, Monoid w) => MonadNew s (Lazy.WriterT w m)
instance MonadNew s' m => MonadNew s' (Strict.StateT s m)
instance MonadNew s' m => MonadNew s' (Lazy.StateT s m)
instance (MonadNew s' m, Monoid w) => MonadNew s' (Strict.RWST r w s m)
instance (MonadNew s' m, Monoid w) => MonadNew s' (Lazy.RWST r w s m)
instance MonadNew s m => MonadNew s (ExceptT e m)
instance MonadNew s m => MonadNew s (MaybeT m)
instance MonadNew s m => MonadNew s (IdentityT m)
class MonadNew s m => MonadReading s m | m -> s where
readSRef :: s a -> m a
default readSRef :: (m ~ t n, MonadTrans t, MonadReading s n) => s a -> m a
readSRef r = lift (readSRef r)
copySRef :: MonadReading s m => s a -> m (s a)
copySRef r = do
a <- readSRef r
newSRef a
instance MonadReading s m => MonadReading s (ReaderT e m)
instance (MonadReading s m, Monoid w) => MonadReading s (Strict.WriterT w m)
instance (MonadReading s m, Monoid w) => MonadReading s (Lazy.WriterT w m)
instance MonadReading s' m => MonadReading s' (Strict.StateT s m)
instance MonadReading s' m => MonadReading s' (Lazy.StateT s m)
instance (MonadReading s' m, Monoid w) => MonadReading s' (Strict.RWST r w s m)
instance (MonadReading s' m, Monoid w) => MonadReading s' (Lazy.RWST r w s m)
instance MonadReading s m => MonadReading s (ExceptT e m)
instance MonadReading s m => MonadReading s (MaybeT m)
instance MonadReading s m => MonadReading s (IdentityT m)
class MonadReading s m => MonadWriting s m | m -> s where
writeSRef :: s a -> a -> m ()
default writeSRef :: (m ~ t n, MonadTrans t, MonadWriting s n) => s a -> a -> m ()
writeSRef r a = lift (writeSRef r a)
synchronize :: m ()
default synchronize :: (m ~ t n, MonadTrans t, MonadWriting s n) => m ()
synchronize = lift synchronize
instance MonadWriting s m => MonadWriting s (ReaderT e m)
instance (MonadWriting s m, Monoid w) => MonadWriting s (Strict.WriterT w m)
instance (MonadWriting s m, Monoid w) => MonadWriting s (Lazy.WriterT w m)
instance MonadWriting s' m => MonadWriting s' (Strict.StateT s m)
instance MonadWriting s' m => MonadWriting s' (Lazy.StateT s m)
instance (MonadWriting s' m, Monoid w) => MonadWriting s' (Strict.RWST r w s m)
instance (MonadWriting s' m, Monoid w) => MonadWriting s' (Lazy.RWST r w s m)
instance MonadWriting s m => MonadWriting s (IdentityT m)
instance MonadWriting s m => MonadWriting s (ExceptT e m)
instance MonadWriting s m => MonadWriting s (MaybeT m)
class
( MonadReading s (Reading m)
, MonadWriting s (Writing m)
, MonadNew s m
) => MonadRCU s m | m -> s where
type Reading m :: * -> *
type Writing m :: * -> *
type Thread m :: * -> *
forking :: m a -> m (Thread m a)
joining :: Thread m a -> m a
reading :: Reading m a -> m a
writing :: Writing m a -> m a
instance MonadRCU s m => MonadRCU s (ReaderT e m) where
type Reading (ReaderT e m) = ReaderT e (Reading m)
type Writing (ReaderT e m) = ReaderT e (Writing m)
type Thread (ReaderT e m) = Thread m
forking (ReaderT f) = ReaderT $ \a -> forking (f a)
joining = lift . joining
reading (ReaderT f) = ReaderT $ \a -> reading (f a)
writing (ReaderT f) = ReaderT $ \a -> writing (f a)
instance MonadRCU s m => MonadRCU s (IdentityT m) where
type Reading (IdentityT m) = Reading m
type Writing (IdentityT m) = Writing m
type Thread (IdentityT m) = Thread m
forking (IdentityT m) = IdentityT (forking m)
joining = lift . joining
reading m = IdentityT (reading m)
writing m = IdentityT (writing m)
instance MonadRCU s m => MonadRCU s (ExceptT e m) where
type Reading (ExceptT e m) = ExceptT e (Reading m)
type Writing (ExceptT e m) = ExceptT e (Writing m)
type Thread (ExceptT e m) = ExceptT e (Thread m)
forking (ExceptT m) = lift $ ExceptT <$> forking m
joining (ExceptT m) = ExceptT $ joining m
reading (ExceptT m) = ExceptT $ reading m
writing (ExceptT m) = ExceptT $ writing m
instance MonadRCU s m => MonadRCU s (MaybeT m) where
type Reading (MaybeT m) = MaybeT (Reading m)
type Writing (MaybeT m) = MaybeT (Writing m)
type Thread (MaybeT m) = MaybeT (Thread m)
forking (MaybeT m) = lift $ MaybeT <$> forking m
joining (MaybeT m) = MaybeT $ joining m
reading (MaybeT m) = MaybeT $ reading m
writing (MaybeT m) = MaybeT $ writing m
instance (MonadRCU s m, Monoid e) => MonadRCU s (Strict.WriterT e m) where
type Reading (Strict.WriterT e m) = Strict.WriterT e (Reading m)
type Writing (Strict.WriterT e m) = Strict.WriterT e (Writing m)
type Thread (Strict.WriterT e m) = Strict.WriterT e (Thread m)
forking (Strict.WriterT m) = lift $ Strict.WriterT <$> forking m
joining (Strict.WriterT m) = Strict.WriterT $ joining m
reading (Strict.WriterT m) = Strict.WriterT $ reading m
writing (Strict.WriterT m) = Strict.WriterT $ writing m
instance (MonadRCU s m, Monoid e) => MonadRCU s (Lazy.WriterT e m) where
type Reading (Lazy.WriterT e m) = Lazy.WriterT e (Reading m)
type Writing (Lazy.WriterT e m) = Lazy.WriterT e (Writing m)
type Thread (Lazy.WriterT e m) = Lazy.WriterT e (Thread m)
forking (Lazy.WriterT m) = lift $ Lazy.WriterT <$> forking m
joining (Lazy.WriterT m) = Lazy.WriterT $ joining m
reading (Lazy.WriterT m) = Lazy.WriterT $ reading m
writing (Lazy.WriterT m) = Lazy.WriterT $ writing m