module System.Console.Haskeline.Monads(
MonadTrans(..),
MonadIO(..),
ReaderT,
runReaderT,
runReaderT',
mapReaderT,
asks,
StateT,
runStateT,
evalStateT',
mapStateT,
gets,
modify,
update,
MonadReader(..),
MonadState(..),
MaybeT(MaybeT),
runMaybeT,
orElse
) where
import Control.Monad (liftM)
import Control.Monad.Catch ()
import Control.Monad.IO.Class (MonadIO(..))
import Control.Monad.Trans.Class (MonadTrans(..))
import Control.Monad.Trans.Maybe (MaybeT(MaybeT),runMaybeT)
import Control.Monad.Trans.Reader hiding (ask,asks)
import qualified Control.Monad.Trans.Reader as Reader
import Control.Monad.Trans.State.Strict hiding (get, put, gets, modify)
import qualified Control.Monad.Trans.State.Strict as State
import Data.IORef
class Monad m => MonadReader r m where
ask :: m r
instance Monad m => MonadReader r (ReaderT r m) where
ask :: ReaderT r m r
ask = forall (m :: * -> *) r. Monad m => ReaderT r m r
Reader.ask
instance Monad m => MonadReader s (StateT s m) where
ask :: StateT s m s
ask = forall s (m :: * -> *). MonadState s m => m s
get
instance {-# OVERLAPPABLE #-} (MonadReader r m, MonadTrans t, Monad (t m))
=> MonadReader r (t m) where
ask :: t m r
ask = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall r (m :: * -> *). MonadReader r m => m r
ask
asks :: MonadReader r m => (r -> a) -> m a
asks :: forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks r -> a
f = forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM r -> a
f forall r (m :: * -> *). MonadReader r m => m r
ask
class Monad m => MonadState s m where
get :: m s
put :: s -> m ()
gets :: MonadState s m => (s -> a) -> m a
gets :: forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets s -> a
f = forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM s -> a
f forall s (m :: * -> *). MonadState s m => m s
get
modify :: MonadState s m => (s -> s) -> m ()
modify :: forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify s -> s
f = forall s (m :: * -> *). MonadState s m => m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall s (m :: * -> *). MonadState s m => s -> m ()
put forall b c a. (b -> c) -> (a -> b) -> a -> c
. s -> s
f
update :: MonadState s m => (s -> (a,s)) -> m a
update :: forall s (m :: * -> *) a. MonadState s m => (s -> (a, s)) -> m a
update s -> (a, s)
f = do
s
s <- forall s (m :: * -> *). MonadState s m => m s
get
let (a
x,s
s') = s -> (a, s)
f s
s
forall s (m :: * -> *). MonadState s m => s -> m ()
put s
s'
forall (m :: * -> *) a. Monad m => a -> m a
return a
x
runReaderT' :: r -> ReaderT r m a -> m a
runReaderT' :: forall r (m :: * -> *) a. r -> ReaderT r m a -> m a
runReaderT' = forall a b c. (a -> b -> c) -> b -> a -> c
flip forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT
instance Monad m => MonadState s (StateT s m) where
get :: StateT s m s
get = forall (m :: * -> *) s. Monad m => StateT s m s
State.get
put :: s -> StateT s m ()
put s
x = forall (m :: * -> *) s. Monad m => s -> StateT s m ()
State.put forall a b. (a -> b) -> a -> b
$! s
x
instance {-# OVERLAPPABLE #-} (MonadState s m, MonadTrans t, Monad (t m))
=> MonadState s (t m) where
get :: t m s
get = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall s (m :: * -> *). MonadState s m => m s
get
put :: s -> t m ()
put = 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 :: * -> *). MonadState s m => s -> m ()
put
instance MonadIO m => MonadState s (ReaderT (IORef s) m) where
get :: ReaderT (IORef s) m s
get = forall r (m :: * -> *). MonadReader r m => m r
ask forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. IORef a -> IO a
readIORef
put :: s -> ReaderT (IORef s) m ()
put s
s = forall r (m :: * -> *). MonadReader r m => m r
ask forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b c. (a -> b -> c) -> b -> a -> c
flip forall a. IORef a -> a -> IO ()
writeIORef s
s
evalStateT' :: Monad m => s -> StateT s m a -> m a
evalStateT' :: forall (m :: * -> *) s a. Monad m => s -> StateT s m a -> m a
evalStateT' s
s StateT s m a
f = forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM forall a b. (a, b) -> a
fst forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) a. StateT s m a -> s -> m (a, s)
runStateT StateT s m a
f s
s
orElse :: Monad m => MaybeT m a -> m a -> m a
orElse :: forall (m :: * -> *) a. Monad m => MaybeT m a -> m a -> m a
orElse (MaybeT m (Maybe a)
f) m a
g = m (Maybe a)
f forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall b a. b -> (a -> b) -> Maybe a -> b
maybe m a
g forall (m :: * -> *) a. Monad m => a -> m a
return