Data.Queue
- class Monad m => NewFifo q m where
- newFifo :: m q
- class Monad m => DefaultFifo q m a | q -> a, m a -> q
- class Monad m => Enqueue q m a | q -> a where
- enqueue :: q -> a -> m ()
- enqueueBatch :: q -> [a] -> m ()
- class Monad m => Dequeue q m a | q -> a where
- dequeue :: q -> m (Maybe a)
- dequeueBatch :: q -> m [a]
- class Monad m => DequeueWhere q m a | q -> a where
- dequeueWhere :: q -> (a -> Bool) -> m (Maybe a)
- class Monad m => PeekQueue q m a | q -> a where
- peekQueue :: q -> m [a]
- peekQueueTaking :: Int -> q -> m [a]
- class Monad m => QueueSize q m where
- module Data.Queue.Instances
- data RQueue q
- mkRQueue :: q -> RQueue q
- data WQueue q
- mkWQueue :: q -> WQueue q
Documentation
class Monad m => DefaultFifo q m a | q -> a, m a -> qSource
A type class carrying an altered set of functional dependencies used to constrain queues when the type of the queue never escapes far enough for a more deliberate choice to be made.
Instances
| DefaultFifo (TChan a) IO a | |
| DefaultFifo (TChan a) STM a |
class Monad m => Enqueue q m a | q -> a whereSource
Methods
enqueue :: q -> a -> m ()Source
Put an item into a queue. May block while trying to do so.
No constraint is placed on the behavior of the queue except that
every item put in really ought to come out sometime before
dequeue returns a Nothing.
enqueueBatch :: q -> [a] -> m ()Source
class Monad m => Dequeue q m a | q -> a whereSource
Methods
dequeue :: q -> m (Maybe a)Source
Pull an item out of a queue. Should not block. No ordering
constraints are implied other than that any item that went into
the queue really ought to come out before dequeue returns
Nothing.
dequeueBatch :: q -> m [a]Source
class Monad m => DequeueWhere q m a | q -> a whereSource
Methods
dequeueWhere :: q -> (a -> Bool) -> m (Maybe a)Source
Pull an item matching the given predicate out of a queue.
class Monad m => PeekQueue q m a | q -> a whereSource
Methods
return the whole contents of the queue (if possible) without altering the queue's contents. Obviously in cases where this can't be done lazily this can be a very expensive operation.
peekQueueTaking :: Int -> q -> m [a]Source
peek a specified number of items off the queue. The default implementation is hideously wasteful in cases where peekQueue is not able to get the contents lazily.
module Data.Queue.Instances
RQueue : read-only newtype wrapper for arbitrary queues
WQueue : write-only newtype wrapper for arbitrary queues