stm-chans-3.0.0.2: Additional types of channels for STM.

Portabilitynon-portable (GHC STM, DeriveDataTypeable)
Stabilityprovisional
Maintainerwren@community.haskell.org
Safe HaskellTrustworthy

Control.Concurrent.STM.TBMQueue

Contents

Description

A version of Control.Concurrent.STM.TQueue where the queue is bounded in length and closeable. This combines the abilities of Control.Concurrent.STM.TBQueue and Control.Concurrent.STM.TMQueue.

Since: 2.0.0

Synopsis

The TBMQueue type

data TBMQueue a Source

TBMQueue is an abstract type representing a bounded closeable FIFO queue.

Instances

Creating TBMQueues

newTBMQueue :: Int -> STM (TBMQueue a)Source

Build and returns a new instance of TBMQueue with the given capacity. N.B., we do not verify the capacity is positive, but if it is non-positive then writeTBMQueue will always retry and isFullTBMQueue will always be true.

newTBMQueueIO :: Int -> IO (TBMQueue a)Source

IO version of newTBMQueue. This is useful for creating top-level TBMQueues using unsafePerformIO, because using atomically inside unsafePerformIO isn't possible.

Reading from TBMQueues

readTBMQueue :: TBMQueue a -> STM (Maybe a)Source

Read the next value from the TBMQueue, retrying if the queue is empty (and not closed). We return Nothing immediately if the queue is closed and empty.

tryReadTBMQueue :: TBMQueue a -> STM (Maybe (Maybe a))Source

A version of readTBMQueue which does not retry. Instead it returns Just Nothing if the queue is open but no value is available; it still returns Nothing if the queue is closed and empty.

peekTBMQueue :: TBMQueue a -> STM (Maybe a)Source

Get the next value from the TBMQueue without removing it, retrying if the queue is empty.

tryPeekTBMQueue :: TBMQueue a -> STM (Maybe (Maybe a))Source

A version of peekTBMQueue which does not retry. Instead it returns Just Nothing if the queue is open but no value is available; it still returns Nothing if the queue is closed and empty.

Writing to TBMQueues

writeTBMQueue :: TBMQueue a -> a -> STM ()Source

Write a value to a TBMQueue, retrying if the queue is full. If the queue is closed then the value is silently discarded. Use isClosedTBMQueue to determine if the queue is closed before writing, as needed.

tryWriteTBMQueue :: TBMQueue a -> a -> STM (Maybe Bool)Source

A version of writeTBMQueue which does not retry. Returns Just True if the value was successfully written, Just False if it could not be written (but the queue was open), and Nothing if it was discarded (i.e., the queue was closed).

unGetTBMQueue :: TBMQueue a -> a -> STM ()Source

Put a data item back onto a queue, where it will be the next item read. If the queue is closed then the value is silently discarded; you can use peekTBMQueue to circumvent this in certain circumstances. N.B., this could allow the queue to temporarily become longer than the specified limit, which is necessary to ensure that the item is indeed the next one read.

Closing TBMQueues

closeTBMQueue :: TBMQueue a -> STM ()Source

Closes the TBMQueue, preventing any further writes.

Predicates

isClosedTBMQueue :: TBMQueue a -> STM BoolSource

Returns True if the supplied TBMQueue has been closed.

isEmptyTBMQueue :: TBMQueue a -> STM BoolSource

Returns True if the supplied TBMQueue is empty (i.e., has no elements). N.B., a TBMQueue can be both `empty' and `full' at the same time, if the initial limit was non-positive.

isFullTBMQueue :: TBMQueue a -> STM BoolSource

Returns True if the supplied TBMQueue is full (i.e., is over its limit). N.B., a TBMQueue can be both `empty' and `full' at the same time, if the initial limit was non-positive. N.B., a TBMQueue may still be full after reading, if unGetTBMQueue was used to go over the initial limit.

This is equivalent to: liftM (<= 0) estimateFreeSlotsTBMQueue

Other functionality

estimateFreeSlotsTBMQueue :: TBMQueue a -> STM IntSource

Estimate the number of free slots. If the result is positive, then it's a minimum bound; if it's non-positive then it's exact. It will only be negative if the initial limit was negative or if unGetTBMQueue was used to go over the initial limit.

This function always contends with writers, but only contends with readers when it has to; compare against freeSlotsTBMQueue.

freeSlotsTBMQueue :: TBMQueue a -> STM IntSource

Return the exact number of free slots. The result can be negative if the initial limit was negative or if unGetTBMQueue was used to go over the initial limit.

This function always contends with both readers and writers; compare against estimateFreeSlotsTBMQueue.