Data.Binary.IO

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

Readers

data ReaderError

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

Defined in Data.Binary.IO

Methods

showsPrec :: Int -> ReaderError -> ShowS

show :: ReaderError -> String

showList :: [ReaderError] -> ShowS

Exception ReaderError

Defined in Data.Binary.IO

Methods

toException :: ReaderError -> SomeException

fromException :: SomeException -> Maybe ReaderError

displayException :: ReaderError -> String

data Reader

Since: 0.0.1

Instances

CanGet Reader

Defined in Data.Binary.IO

Methods

runGet :: Reader -> Get a -> IO a

newReader

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

newReaderWith

Arguments

:: IO ByteString

Chunk producer

-> IO Reader

This function works very similar to newReader except no Handle is involved.

Since: 0.1.1

Writers

data Writer

Since: 0.0.1

Instances

CanPut Writer

Defined in Data.Binary.IO

Methods

runPut :: Writer -> Put -> IO ()

newWriter

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

newWriterWith

Arguments

:: (ByteString -> IO ())

Chunk handler

-> Writer

Create a writer using a function that handles the output chunks.

Since: 0.1.1

Pipe

newPipe :: IO (Reader, Writer)

Create a connected pair of Reader and Writer.

Since: 0.2.0

Duplex

data Duplex

Pair of Reader and Writer

Since: 0.0.1

Constructors

Duplex

Fields

• duplexWriter :: !Writer
• duplexReader :: !Reader

Instances

CanPut Duplex

Defined in Data.Binary.IO

Methods

runPut :: Duplex -> Put -> IO ()

CanGet Duplex

Defined in Data.Binary.IO

Methods

runGet :: Duplex -> Get a -> IO a

newDuplex

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

newDuplexWith :: IO ByteString -> (ByteString -> IO ()) -> IO Duplex

Combines newReaderWith and newWriterWith.

Since: 0.1.1

Classes

class CanGet r where

r can execute Get operations

Since: 0.0.1

Methods

runGet

Arguments

:: r

Reader / source

-> Get a

Operation to execute

-> IO a

Instances

CanGet Duplex

Defined in Data.Binary.IO

Methods

runGet :: Duplex -> Get a -> IO a

CanGet Reader

Defined in Data.Binary.IO

Methods

runGet :: Reader -> Get a -> IO a

read

Arguments

:: (CanGet r, Binary a)

=> r

Read source

-> IO a

Read something from r.

Since: 0.0.1

class CanPut w where

w can execute Put operations

Since: 0.0.1

Methods

runPut

Arguments

:: w

Writer / target

-> Put

Operation to execute

-> IO ()

Instances

CanPut Handle

Defined in Data.Binary.IO

Methods

runPut :: Handle -> Put -> IO ()

CanPut Duplex

Defined in Data.Binary.IO

Methods

runPut :: Duplex -> Put -> IO ()

CanPut Writer

Defined in Data.Binary.IO

Methods

runPut :: Writer -> Put -> IO ()

write

Arguments

:: (CanPut w, Binary a)

=> w

Write target

-> a

Value to be written

-> IO ()

Write something to w.

Since: 0.0.1