Safe Haskell	Safe
Language	Haskell2010

Data.Binary.IO

Contents

Readers
Writers
Duplex
Classes

Description

Read and write values of types that implement Binary from and to Handles

Synopsis

data ReaderError = ReaderGetError {
- readerErrorRemaining :: !ByteString
- readerErrorOffset :: !ByteOffset
- readerErrorInput :: !ByteString
- readerErrorMessage :: !String
}
data Reader
newReader :: Handle -> IO Reader
data Writer
newWriter :: Handle -> Writer
data Duplex
newDuplex :: Handle -> IO Duplex
class CanGet r where
- runGet :: r -> Get a -> IO a
read :: (CanGet r, Binary a) => r -> IO a
class CanPut w where
- runPut :: w -> Put -> IO ()
write :: (CanPut w, Binary a) => w -> a -> IO ()

Readers

data ReaderError Source #

An error that can occur during reading

Since: 0.0.1

Constructors

ReaderGetError	Error from the `Get` operation
Fields readerErrorRemaining :: !ByteString Unconsumed part of the byte stream Since: 0.0.1 readerErrorOffset :: !ByteOffset Error location represented as an offset into the input Since: 0.0.1 readerErrorInput :: !ByteString Input to the `Get` operation Since: 0.0.1 readerErrorMessage :: !String Error message Since: 0.0.1

Instances

Show ReaderError Source #
Instance details Defined in Data.Binary.IO Methods showsPrec :: Int -> ReaderError -> ShowS # show :: ReaderError -> String # showList :: [ReaderError] -> ShowS #
Exception ReaderError Source #
Instance details Defined in Data.Binary.IO Methods toException :: ReaderError -> SomeException # fromException :: SomeException -> Maybe ReaderError # displayException :: ReaderError -> String #

data Reader Source #

Since: 0.0.1

Instances

CanGet Reader Source #
Instance details Defined in Data.Binary.IO Methods runGet :: Reader -> Get a -> IO a Source #

newReader Source #

Arguments

:: Handle	Handle that will be read from
-> IO Reader

Create a new reader.

Reading using the Reader may throw ReaderError.

The internal position of the Reader 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 Get operation multiple times, you will always receive an exception.

Other threads reading from the Handle will interfere with read operations of the Reader. However, the Reader itself is thread-safe and can be utilized concurrently.

Once the Handle reaches EOF, it will be closed.

The given Handle will be swiched to binary mode via hSetBinaryMode.

Since: 0.0.1

Writers

data Writer Source #

Since: 0.0.1

Instances

CanPut Writer Source #
Instance details Defined in Data.Binary.IO Methods runPut :: Writer -> Put -> IO () Source #

newWriter Source #

Arguments

:: Handle	Handle that will be written to
-> Writer

Create a writer.

Other threads writing to the same Handle do not interfere with the resulting Writer. The Writer may be used concurrently.

Since: 0.0.1

Duplex

data Duplex Source #

Pair of Reader and Writer

Since: 0.0.1

Instances

CanPut Duplex Source #
Instance details Defined in Data.Binary.IO Methods runPut :: Duplex -> Put -> IO () Source #
CanGet Duplex Source #
Instance details Defined in Data.Binary.IO Methods runGet :: Duplex -> Get a -> IO a Source #

newDuplex Source #

Arguments

:: Handle	Handle that will be read from and written to
-> IO Duplex

Create a new duplex. The Duplex inherits all the properties of Reader and Writer when created with newReader and newWriter.

Since: 0.0.1

Classes

class CanGet r where Source #

r can execute Get operations

Since: 0.0.1

Methods

runGet Source #

Arguments

:: r	Reader / source
-> Get a	Operation to execute
-> IO a

Instances

CanGet Duplex Source #
Instance details Defined in Data.Binary.IO Methods runGet :: Duplex -> Get a -> IO a Source #
CanGet Reader Source #
Instance details Defined in Data.Binary.IO Methods runGet :: Reader -> Get a -> IO a Source #

read Source #

Arguments

:: (CanGet r, Binary a)
=> r	Read source
-> IO a

Read something from r.

Since: 0.0.1

class CanPut w where Source #

w can execute Put operations

Since: 0.0.1

Methods

runPut Source #

Arguments

:: w	Writer / target
-> Put	Operation to execute
-> IO ()

Instances

CanPut Handle Source #
Instance details Defined in Data.Binary.IO Methods runPut :: Handle -> Put -> IO () Source #
CanPut Duplex Source #
Instance details Defined in Data.Binary.IO Methods runPut :: Duplex -> Put -> IO () Source #
CanPut Writer Source #
Instance details Defined in Data.Binary.IO Methods runPut :: Writer -> Put -> IO () Source #

write Source #

Arguments

:: (CanPut w, Binary a)
=> w	Write target
-> a	Value to be written
-> IO ()

Write something to w.

Since: 0.0.1