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


-- | Read and write values of types that implement Binary from and to Handles
--   
--   Read and write values of types that implement Binary from and to
--   Handles
--   
--   See module <a>Data.Binary.IO</a>.
@package binary-io
@version 0.0.1


-- | Read and write values of types that implement <a>Binary</a> from and
--   to <a>Handle</a>s
module Data.Binary.IO

-- | An error that can occur during reading
data ReaderError

-- | Error from the <a>Get</a> operation
ReaderGetError :: !ByteString -> !ByteOffset -> !ByteString -> !String -> ReaderError

-- | Unconsumed part of the byte stream
[readerErrorRemaining] :: ReaderError -> !ByteString

-- | Error location represented as an offset into the input
[readerErrorOffset] :: ReaderError -> !ByteOffset

-- | Input to the <a>Get</a> operation
[readerErrorInput] :: ReaderError -> !ByteString

-- | Error message
[readerErrorMessage] :: ReaderError -> !String

data Reader

-- | Create a new reader.
--   
--   Reading using the <a>Reader</a> may throw <a>ReaderError</a>.
--   
--   The internal position of the <a>Reader</a> is not advanced when it
--   throws an exception during reading. This has the consequence that if
--   you're trying to read with the same faulty <a>Get</a> operation
--   multiple times, you will always receive an exception. The same is true
--   for follow-up actions when using <a>readWith</a>.
--   
--   Other threads reading from the <a>Handle</a> will interfere with read
--   operations of the <a>Reader</a>. However, the <a>Reader</a> itself is
--   thread-safe and can be utilized concurrently.
--   
--   Once the <a>Handle</a> reaches EOF, it will be closed.
--   
--   The given <a>Handle</a> will be swiched to binary mode via
--   <a>hSetBinaryMode</a>.
newReader :: Handle -> IO Reader

data Writer

-- | Create a writer.
--   
--   Other threads writing to the same <a>Handle</a> do not interfere with
--   the resulting <a>Writer</a>. The <a>Writer</a> may be used
--   concurrently.
newWriter :: Handle -> Writer

-- | Pair of <a>Reader</a> and <a>Writer</a>
data Duplex

-- | Create a new duplex. The <a>Duplex</a> inherits all the properties of
--   <a>Reader</a> and <a>Writer</a> when created with <a>newReader</a> and
--   <a>newWriter</a>.
newDuplex :: Handle -> IO Duplex

-- | <tt>r</tt> can execute <a>Get</a> operations
class CanGet r
runGet :: CanGet r => r -> Get a -> (a -> IO b) -> IO b

-- | Read something from <tt>r</tt>.
read :: (CanGet r, Binary a) => r -> IO a

-- | Read something from <tt>r</tt> and perform an <a>IO</a> action with
--   it.
--   
--   If the given action throws an exception, the read is not considered
--   successful and will not advance the underlying read source.
--   
--   Keep in mind, long running actions on <tt>a</tt> will block other
--   threads when they try to read the from the same source <tt>r</tt>.
readWith :: (CanGet r, Binary a) => r -> (a -> IO b) -> IO b

-- | <tt>w</tt> can execute <a>Put</a> operations
class CanPut w
runPut :: CanPut w => w -> Put -> IO ()

-- | Write something to <tt>w</tt>.
write :: (CanPut w, Binary a) => w -> a -> IO ()
instance GHC.Exception.Type.Exception Data.Binary.IO.ReaderError
instance GHC.Show.Show Data.Binary.IO.ReaderError
instance Data.Binary.IO.CanPut GHC.IO.Handle.Types.Handle
instance Data.Binary.IO.CanPut Data.Binary.IO.Writer
instance Data.Binary.IO.CanPut Data.Binary.IO.Duplex
instance Data.Binary.IO.CanGet Data.Binary.IO.Reader
instance Data.Binary.IO.CanGet Data.Binary.IO.Duplex