-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Concurrent Chans as read/write pairs. Also provides generic
Chan pair class.
--   
--   An implementation of concurrent channels identical to
--   Control.Concurrent.Chan, except that the channel is represented as a
--   pair, one of which allows only read operations, the other write
--   operations.
--   
--   This makes code easier to reason about (the types strictly delegate
--   read/write permission), suggests useful instances (e.g. <a>Functor</a>
--   and <a>Contravariant</a> are easily defined) on the chan pairs, and
--   simplifies the API.
--   
--   Furthermore this allows messages sent to channels with no readers to
--   be trivially garbage-collected, without relying on inlining
--   optimizations.
--   
--   We also provide a module that defines a class <a>SplitChan</a> which
--   defines the basic methods any pair of Chan types should provide,
--   allowing easy swapping of Chan implementations.
--   
--   To use standard Chans with these polymorphic functions, import as
--   follows:
--   
--   <pre>
--   import Control.Concurrent.Chan hiding (readChan,writeChan,writeList2Chan)
--   import Control.Concurrent.Chan.Class
--   </pre>
--   
--   When used alongside standard Chans, the Split module can be imported
--   qualified like:
--   
--   <pre>
--   import qualified Control.Concurrent.Chan.Split as S
--   </pre>
--   
--   Its interface is mostly backwards compatible with Chan. Note, we do
--   not implement the deprecated unGetChan and isEmptyChan functions.
--   
--   This module is used internally by the <a>simple-actors</a> package.
--   
--   <i>CHANGES</i>: 0.3.0 -&gt; 0.4.0
--   
--   <ul>
--   <li>In/OutChans now implemented from scratch (after Leon P Smith's
--   implementation)</li>
--   <li>no longer implement Functor/Contravariant instances; drop
--   contravariant dependency</li>
--   <li>implement Eq and Typeable instances</li>
--   </ul>
@package chan-split
@version 0.4.0

module Control.Concurrent.Chan.Class

-- | A class for chan types with a "write end" and a "read end". A minimal
--   complete instance defines <a>readChan</a> and one of <a>writeChan</a>
--   or <a>writeList2Chan</a>.
class SplitChan i o | i -> o, o -> i where writeList2Chan = mapM_ . writeChan writeChan c = writeList2Chan c . return
readChan :: SplitChan i o => o a -> IO a
writeList2Chan :: SplitChan i o => i a -> [a] -> IO ()
writeChan :: SplitChan i o => i a -> a -> IO ()

-- | A class for <a>SplitChan</a> types that can be instantiated without
--   programmer input. <i>e.g.</i> the standard haskell <tt>Chan</tt> is a
--   member of this class, however a bounded chan type that took an
--   <tt>Int</tt> to define the buffer size would not.
class SplitChan i o => NewSplitChan i o
newSplitChan :: NewSplitChan i o => IO (i a, o a)
instance NewSplitChan MVar MVar
instance SplitChan MVar MVar
instance NewSplitChan Chan Chan
instance SplitChan Chan Chan

module Control.Concurrent.Chan.Split

-- | The "write side" of a chan pair
data InChan i

-- | The "read side" of a chan pair
data OutChan i

-- | Return a lazy list representing the contents of the supplied OutChan,
--   much like System.IO.hGetContents.
getChanContents :: OutChan a -> IO [a]

-- | Duplicate an <a>OutChan</a>: the duplicate channel contains any unread
--   messages in the original (n.b. this differs from the behavior of
--   dupChan in Chan), and data written to the corresponding <a>InChan</a>
--   will appear in both, i.e. consuming a value from the copy will have no
--   affect on the values in the original OutChan.
--   
--   (Note that a duplicated channel is not equal to its original. So:
--   <tt>fmap (c /=) $ dupChan c</tt> returns <tt>True</tt> for all
--   <tt>c</tt>.)
dupChan :: OutChan a -> IO (OutChan a)
instance Typeable1 InChan
instance Typeable1 OutChan
instance Eq (InChan i)
instance Eq (OutChan i)
instance SplitChan InChan OutChan
instance NewSplitChan InChan OutChan