- 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.

DefaultFifo (TChan a) IO a | |

DefaultFifo (TChan a) STM a |

class Monad m => Enqueue q m a | q -> a whereSource

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

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

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

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