| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Control.Concurrent.Chan.Unagi.Unboxed
- newChan :: UnagiPrim a => IO (InChan a, OutChan a)
- data InChan a
- data OutChan a
- class (Prim a, Eq a) => UnagiPrim a where
- atomicUnicorn :: Maybe a
- readChan :: UnagiPrim a => OutChan a -> IO a
- readChanOnException :: UnagiPrim a => OutChan a -> (IO a -> IO ()) -> IO a
- tryReadChan :: UnagiPrim a => OutChan a -> IO (Element a, IO a)
- newtype Element a = Element {}
- getChanContents :: UnagiPrim a => OutChan a -> IO [a]
- writeChan :: UnagiPrim a => InChan a -> a -> IO ()
- writeList2Chan :: UnagiPrim a => InChan a -> [a] -> IO ()
- dupChan :: InChan a -> IO (OutChan a)
Creating channels
newChan :: UnagiPrim a => IO (InChan a, OutChan a) Source
Create a new channel, returning its write and read ends.
The write end of a channel created with newChan.
The read end of a channel created with newChan.
class (Prim a, Eq a) => UnagiPrim a where Source
Our class of types supporting primitive array operations. Instance method definitions are architecture-dependent.
Minimal complete definition
Nothing
Methods
atomicUnicorn :: Maybe a Source
When the read and write operations of the underlying Prim instances
on aligned memory are atomic, this may be set to Just x where x is
some rare (i.e. unlikely to occur frequently in your data) magic value;
this might help speed up some UnagiPrim operations.
Where those Prim instance operations are not atomic, this *must* be
set to Nothing.
Channel operations
Reading
readChan :: UnagiPrim a => OutChan a -> IO a Source
Read an element from the chan, blocking if the chan is empty.
Note re. exceptions: When an async exception is raised during a readChan
the message that the read would have returned is likely to be lost, even when
the read is known to be blocked on an empty queue. If you need to handle
this scenario, you can use readChanOnException.
readChanOnException :: UnagiPrim a => OutChan a -> (IO a -> IO ()) -> IO a Source
Like readChan but allows recovery of the queue element which would have
been read, in the case that an async exception is raised during the read. To
be precise exceptions are raised, and the handler run, only when
readChanOnException is blocking.
The second argument is a handler that takes a blocking IO action returning
the element, and performs some recovery action. When the handler is called,
the passed IO a is the only way to access the element.
tryReadChan :: UnagiPrim a => OutChan a -> IO (Element a, IO a) Source
Returns immediately with:
- an
ElementatryRead. - a blocking
IOaction that returns the element when it becomes available.
If you're using this function exclusively you might find the implementation in Control.Concurrent.Chan.Unagi.NoBlocking.Unboxed is faster.
Note re. exceptions: When an async exception is raised during a tryReadChan
the message that the read would have returned is likely to be lost, just as
it would be when raised directly after this function returns.
An IO action that returns a particular enqueued element when and if it
becomes available.
Each Element corresponds to a particular enqueued element, i.e. a returned
Element always offers the only means to access one particular enqueued
item. The value returned by tryRead moves monotonically from Nothing
to Just a when and if an element becomes available, and is idempotent at
that point.
getChanContents :: UnagiPrim a => OutChan a -> IO [a] Source
Return a lazy list representing the contents of the supplied OutChan, much like System.IO.hGetContents.
Writing
writeList2Chan :: UnagiPrim a => InChan a -> [a] -> IO () Source
Write an entire list of items to a chan type. Writes here from multiple threads may be interleaved, and infinite lists are supported.