{-# LANGUAGE Safe #-}
{-# LANGUAGE Rank2Types #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE DefaultSignatures #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE FunctionalDependencies #-}
{-# OPTIONS_HADDOCK not-home #-}
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
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
a = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (forall (s :: * -> *) (m :: * -> *) a. MonadNew s m => a -> m (s a)
newSRef a
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 s a
r = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (forall (s :: * -> *) (m :: * -> *) a.
MonadReading s m =>
s a -> m a
readSRef s a
r)
{-# INLINE readSRef #-}
copySRef :: MonadReading s m => s a -> m (s a)
copySRef :: forall (s :: * -> *) (m :: * -> *) a.
MonadReading s m =>
s a -> m (s a)
copySRef s a
r = do
a
a <- forall (s :: * -> *) (m :: * -> *) a.
MonadReading s m =>
s a -> m a
readSRef s a
r
forall (s :: * -> *) (m :: * -> *) a. MonadNew s m => a -> m (s a)
newSRef a
a
{-# INLINE copySRef #-}
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 s a
r a
a = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (forall (s :: * -> *) (m :: * -> *) a.
MonadWriting s m =>
s a -> a -> m ()
writeSRef s a
r a
a)
synchronize :: m ()
default synchronize :: (m ~ t n, MonadTrans t, MonadWriting s n) => m ()
synchronize = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall (s :: * -> *) (m :: * -> *). MonadWriting s m => m ()
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 :: forall a. ReaderT e m a -> ReaderT e m (Thread (ReaderT e m) a)
forking (ReaderT e -> m a
f) = forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT forall a b. (a -> b) -> a -> b
$ \e
a -> forall (s :: * -> *) (m :: * -> *) a.
MonadRCU s m =>
m a -> m (Thread m a)
forking (e -> m a
f e
a)
joining :: forall a. Thread (ReaderT e m) a -> ReaderT e m a
joining = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (s :: * -> *) (m :: * -> *) a.
MonadRCU s m =>
Thread m a -> m a
joining
reading :: forall a. Reading (ReaderT e m) a -> ReaderT e m a
reading (ReaderT e -> Reading m a
f) = forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT forall a b. (a -> b) -> a -> b
$ \e
a -> forall (s :: * -> *) (m :: * -> *) a.
MonadRCU s m =>
Reading m a -> m a
reading (e -> Reading m a
f e
a)
writing :: forall a. Writing (ReaderT e m) a -> ReaderT e m a
writing (ReaderT e -> Writing m a
f) = forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT forall a b. (a -> b) -> a -> b
$ \e
a -> forall (s :: * -> *) (m :: * -> *) a.
MonadRCU s m =>
Writing m a -> m a
writing (e -> Writing m a
f e
a)
{-# INLINE forking #-}
{-# INLINE joining #-}
{-# INLINE reading #-}
{-# INLINE writing #-}
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 :: forall a. IdentityT m a -> IdentityT m (Thread (IdentityT m) a)
forking (IdentityT m a
m) = forall {k} (f :: k -> *) (a :: k). f a -> IdentityT f a
IdentityT (forall (s :: * -> *) (m :: * -> *) a.
MonadRCU s m =>
m a -> m (Thread m a)
forking m a
m)
joining :: forall a. Thread (IdentityT m) a -> IdentityT m a
joining = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (s :: * -> *) (m :: * -> *) a.
MonadRCU s m =>
Thread m a -> m a
joining
reading :: forall a. Reading (IdentityT m) a -> IdentityT m a
reading Reading (IdentityT m) a
m = forall {k} (f :: k -> *) (a :: k). f a -> IdentityT f a
IdentityT (forall (s :: * -> *) (m :: * -> *) a.
MonadRCU s m =>
Reading m a -> m a
reading Reading (IdentityT m) a
m)
writing :: forall a. Writing (IdentityT m) a -> IdentityT m a
writing Writing (IdentityT m) a
m = forall {k} (f :: k -> *) (a :: k). f a -> IdentityT f a
IdentityT (forall (s :: * -> *) (m :: * -> *) a.
MonadRCU s m =>
Writing m a -> m a
writing Writing (IdentityT m) a
m)
{-# INLINE forking #-}
{-# INLINE joining #-}
{-# INLINE reading #-}
{-# INLINE writing #-}
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 :: forall a. ExceptT e m a -> ExceptT e m (Thread (ExceptT e m) a)
forking (ExceptT m (Either e a)
m) = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ forall e (m :: * -> *) a. m (Either e a) -> ExceptT e m a
ExceptT forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (s :: * -> *) (m :: * -> *) a.
MonadRCU s m =>
m a -> m (Thread m a)
forking m (Either e a)
m
joining :: forall a. Thread (ExceptT e m) a -> ExceptT e m a
joining (ExceptT Thread m (Either e a)
m) = forall e (m :: * -> *) a. m (Either e a) -> ExceptT e m a
ExceptT forall a b. (a -> b) -> a -> b
$ forall (s :: * -> *) (m :: * -> *) a.
MonadRCU s m =>
Thread m a -> m a
joining Thread m (Either e a)
m
reading :: forall a. Reading (ExceptT e m) a -> ExceptT e m a
reading (ExceptT Reading m (Either e a)
m) = forall e (m :: * -> *) a. m (Either e a) -> ExceptT e m a
ExceptT forall a b. (a -> b) -> a -> b
$ forall (s :: * -> *) (m :: * -> *) a.
MonadRCU s m =>
Reading m a -> m a
reading Reading m (Either e a)
m
writing :: forall a. Writing (ExceptT e m) a -> ExceptT e m a
writing (ExceptT Writing m (Either e a)
m) = forall e (m :: * -> *) a. m (Either e a) -> ExceptT e m a
ExceptT forall a b. (a -> b) -> a -> b
$ forall (s :: * -> *) (m :: * -> *) a.
MonadRCU s m =>
Writing m a -> m a
writing Writing m (Either e a)
m
{-# INLINE forking #-}
{-# INLINE joining #-}
{-# INLINE reading #-}
{-# INLINE writing #-}
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 :: forall a. MaybeT m a -> MaybeT m (Thread (MaybeT m) a)
forking (MaybeT m (Maybe a)
m) = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a
MaybeT forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (s :: * -> *) (m :: * -> *) a.
MonadRCU s m =>
m a -> m (Thread m a)
forking m (Maybe a)
m
joining :: forall a. Thread (MaybeT m) a -> MaybeT m a
joining (MaybeT Thread m (Maybe a)
m) = forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a
MaybeT forall a b. (a -> b) -> a -> b
$ forall (s :: * -> *) (m :: * -> *) a.
MonadRCU s m =>
Thread m a -> m a
joining Thread m (Maybe a)
m
reading :: forall a. Reading (MaybeT m) a -> MaybeT m a
reading (MaybeT Reading m (Maybe a)
m) = forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a
MaybeT forall a b. (a -> b) -> a -> b
$ forall (s :: * -> *) (m :: * -> *) a.
MonadRCU s m =>
Reading m a -> m a
reading Reading m (Maybe a)
m
writing :: forall a. Writing (MaybeT m) a -> MaybeT m a
writing (MaybeT Writing m (Maybe a)
m) = forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a
MaybeT forall a b. (a -> b) -> a -> b
$ forall (s :: * -> *) (m :: * -> *) a.
MonadRCU s m =>
Writing m a -> m a
writing Writing m (Maybe a)
m
{-# INLINE forking #-}
{-# INLINE joining #-}
{-# INLINE reading #-}
{-# INLINE writing #-}
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 :: forall a. WriterT e m a -> WriterT e m (Thread (WriterT e m) a)
forking (Strict.WriterT m (a, e)
m) = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ forall w (m :: * -> *) a. m (a, w) -> WriterT w m a
Strict.WriterT forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (s :: * -> *) (m :: * -> *) a.
MonadRCU s m =>
m a -> m (Thread m a)
forking m (a, e)
m
joining :: forall a. Thread (WriterT e m) a -> WriterT e m a
joining (Strict.WriterT Thread m (a, e)
m) = forall w (m :: * -> *) a. m (a, w) -> WriterT w m a
Strict.WriterT forall a b. (a -> b) -> a -> b
$ forall (s :: * -> *) (m :: * -> *) a.
MonadRCU s m =>
Thread m a -> m a
joining Thread m (a, e)
m
reading :: forall a. Reading (WriterT e m) a -> WriterT e m a
reading (Strict.WriterT Reading m (a, e)
m) = forall w (m :: * -> *) a. m (a, w) -> WriterT w m a
Strict.WriterT forall a b. (a -> b) -> a -> b
$ forall (s :: * -> *) (m :: * -> *) a.
MonadRCU s m =>
Reading m a -> m a
reading Reading m (a, e)
m
writing :: forall a. Writing (WriterT e m) a -> WriterT e m a
writing (Strict.WriterT Writing m (a, e)
m) = forall w (m :: * -> *) a. m (a, w) -> WriterT w m a
Strict.WriterT forall a b. (a -> b) -> a -> b
$ forall (s :: * -> *) (m :: * -> *) a.
MonadRCU s m =>
Writing m a -> m a
writing Writing m (a, e)
m
{-# INLINE forking #-}
{-# INLINE joining #-}
{-# INLINE reading #-}
{-# INLINE writing #-}
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 :: forall a. WriterT e m a -> WriterT e m (Thread (WriterT e m) a)
forking (Lazy.WriterT m (a, e)
m) = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ forall w (m :: * -> *) a. m (a, w) -> WriterT w m a
Lazy.WriterT forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (s :: * -> *) (m :: * -> *) a.
MonadRCU s m =>
m a -> m (Thread m a)
forking m (a, e)
m
joining :: forall a. Thread (WriterT e m) a -> WriterT e m a
joining (Lazy.WriterT Thread m (a, e)
m) = forall w (m :: * -> *) a. m (a, w) -> WriterT w m a
Lazy.WriterT forall a b. (a -> b) -> a -> b
$ forall (s :: * -> *) (m :: * -> *) a.
MonadRCU s m =>
Thread m a -> m a
joining Thread m (a, e)
m
reading :: forall a. Reading (WriterT e m) a -> WriterT e m a
reading (Lazy.WriterT Reading m (a, e)
m) = forall w (m :: * -> *) a. m (a, w) -> WriterT w m a
Lazy.WriterT forall a b. (a -> b) -> a -> b
$ forall (s :: * -> *) (m :: * -> *) a.
MonadRCU s m =>
Reading m a -> m a
reading Reading m (a, e)
m
writing :: forall a. Writing (WriterT e m) a -> WriterT e m a
writing (Lazy.WriterT Writing m (a, e)
m) = forall w (m :: * -> *) a. m (a, w) -> WriterT w m a
Lazy.WriterT forall a b. (a -> b) -> a -> b
$ forall (s :: * -> *) (m :: * -> *) a.
MonadRCU s m =>
Writing m a -> m a
writing Writing m (a, e)
m
{-# INLINE forking #-}
{-# INLINE joining #-}
{-# INLINE reading #-}
{-# INLINE writing #-}