queue-0.1.2: Abstraction typeclasses for queue-like things.

Safe HaskellSafe-Inferred

Data.Queue.Classes

Synopsis

Documentation

class Monad m => NewFifo q m where

Construct a new FIFO queue.

Methods

newFifo :: m q

Instances

class Monad m => DefaultFifo q m a | q -> a, m a -> q

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

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

Methods

enqueue :: q -> a -> m ()

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 ()

Instances

Monad IO => Enqueue (Chan a) IO a 
Monad IO => Enqueue (MVar a) IO a 
Monad IO => Enqueue (TMVar a) IO a 
Monad STM => Enqueue (TMVar a) STM a 
Monad IO => Enqueue (TChan a) IO a 
Monad STM => Enqueue (TChan a) STM a 
(Monad m, Enqueue q m a) => Enqueue (WQueue q) m a 

class Monad m => Dequeue q m a | q -> a where

Methods

dequeue :: q -> m (Maybe a)

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]

Instances

Monad IO => Dequeue (MVar a) IO a 
Monad IO => Dequeue (TMVar a) IO a 
Monad STM => Dequeue (TMVar a) STM a 
Monad IO => Dequeue (TChan a) IO a 
Monad STM => Dequeue (TChan a) STM a 
(Monad m, Dequeue q m a) => Dequeue (RQueue q) m a 

class Monad m => DequeueWhere q m a | q -> a where

Methods

dequeueWhere :: q -> (a -> Bool) -> m (Maybe a)

Pull an item matching the given predicate out of a queue.

class Monad m => PeekQueue q m a | q -> a where

Methods

peekQueue :: q -> m [a]

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]

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.

Instances

class Monad m => QueueSize q m where

Methods

queueSize :: q -> m Int

return the number of elements in the queue