module Control.Monad.Queue.QueueT where
import Data.Queue
import Control.Monad.State.Lazy
import Control.Monad.Queue.Class
import Control.Monad.RWS.Class
import Control.Monad.Fix
import Control.Monad.Trans(MonadIO, MonadTrans(..))
import Control.Monad.ST.Class(MonadST)
import Control.Monad(Monad)
import Control.Monad.Trans.Operations
import Data.Maybe
newtype QueueT q m a = QueueT {runQT :: StateT q m a} deriving (MonadReader r, MonadWriter w, MonadIO, MonadST s, MonadFix, Monad, MonadTrans)
newtype QueueM q a = QueueM {runQM :: State q a} deriving (MonadFix, Monad)
type PQueueT e = QueueT (PQueue e)
type PQueueM e = QueueM (PQueue e)
type FibQueueT e = QueueT (FQueue e)
type FibQueueM e = QueueM (FQueue e)
runQueueT :: (Monad m, Queuelike q e) => QueueT q m a -> m a
runQueueT m = evalStateT (runQT m) empty
runQueueTOn :: (Monad m, Queuelike q e) => QueueT q m a -> [e] -> m a
runQueueTOn m xs = evalStateT (runQT m) (fromList xs)
runQueueM :: Queuelike q e => QueueM q a -> a
runQueueM m = evalState (runQM m) empty
runQueueMOn :: Queuelike q e => QueueM q a -> [e] -> a
runQueueMOn m xs = evalState (runQM m) (fromList xs)
instance MonadState s m => MonadState s (QueueT q m) where
get = lift get
put = lift . put
instance (Monad m, Queuelike q e) => MonadQueue e (QueueT q m) where
queueInsert x = QueueT $ modify (insert x)
queueExtract = QueueT $ statefully (\ q -> maybe (Nothing, q) (\ (x, q') -> (Just x, q')) (extract q))
queueEmpty = QueueT $ gets isEmpty
queueDelete = QueueT $ modify (\ q -> fromMaybe empty (delete q))
queuePeek = QueueT $ gets peek
queueSize = QueueT $ gets size
instance Queuelike q e => MonadQueue e (QueueM q) where
queueInsert x = QueueM $ modify (insert x)
queueExtract = QueueM $ statefully (\ q -> maybe (Nothing, q) (\ (x, q') -> (Just x, q')) (extract q))
queueEmpty = QueueM $ gets isEmpty
queueDelete = QueueM $ modify (\ q -> fromMaybe empty (delete q))
queuePeek = QueueM $ gets peek
queueSize = QueueM $ gets size