Data.Bytes.Chunks

Chunks of bytes. This is useful as a target for a builder or as a way to read a large amount of whose size is unknown in advance. Structurally, this type is similar to Data.ByteString.Lazy.ByteString. However, the type in this module is strict in its spine. Additionally, none of the Handle functions perform lazy I/O.

Types

data Chunks

A cons-list of byte sequences.

Constructors

ChunksCons !Bytes !Chunks

ChunksNil

Instances

Eq Chunks

This uses concat to form an equivalence class.

Defined in Data.Bytes.Chunks

Methods

(==) :: Chunks -> Chunks -> Bool

(/=) :: Chunks -> Chunks -> Bool

Show Chunks

Defined in Data.Bytes.Chunks

Methods

showsPrec :: Int -> Chunks -> ShowS

show :: Chunks -> String

showList :: [Chunks] -> ShowS

Semigroup Chunks

Defined in Data.Bytes.Chunks

Methods

(<>) :: Chunks -> Chunks -> Chunks

sconcat :: NonEmpty Chunks -> Chunks

stimes :: Integral b => b -> Chunks -> Chunks

Monoid Chunks

Defined in Data.Bytes.Chunks

Methods

mempty :: Chunks

mappend :: Chunks -> Chunks -> Chunks

mconcat :: [Chunks] -> Chunks

Properties

length :: Chunks -> Int

The total number of bytes in all the chunks.

null :: Chunks -> Bool

Are there any bytes in the chunked byte sequences?

Manipulate

concat :: Chunks -> Bytes

Concatenate chunks into a single contiguous byte sequence.

concatPinned :: Chunks -> Bytes

Variant of concat that ensure that the resulting byte sequence is pinned memory.

concatU :: Chunks -> ByteArray

Variant of concat that returns an unsliced byte sequence.

concatPinnedU :: Chunks -> ByteArray

Variant of concatPinned that returns an unsliced pinned byte sequence.

concatByteString :: Chunks -> ByteString

Concatenate chunks into a strict bytestring.

reverse :: Chunks -> Chunks

Reverse chunks but not the bytes within each chunk.

reverseOnto :: Chunks -> Chunks -> Chunks

Variant of reverse that allows the caller to provide an initial list of chunks that the reversed chunks will be pushed onto.

Folds

foldl' :: (a -> Word8 -> a) -> a -> Chunks -> a

Left fold over all bytes in the chunks, strict in the accumulator.

Splitting

split :: Word8 -> Chunks -> [Bytes]

Break chunks of bytes into contiguous pieces separated by the byte argument. This is a good producer for list fusion. For this function to perform well, each chunk should contain multiple separators. Any piece that spans multiple chunks must be copied.

Hashing

fnv1a32 :: Chunks -> Word32

Hash byte sequence with 32-bit variant of FNV-1a.

fnv1a64 :: Chunks -> Word64

Hash byte sequence with 64-bit variant of FNV-1a.

Create

fromBytes :: Bytes -> Chunks

Create a list of chunks with a single chunk.

fromByteArray :: ByteArray -> Chunks

Variant of fromBytes where the single chunk is unsliced.

Copy to buffer

unsafeCopy

Arguments

:: MutableByteArray s

Destination

-> Int

Destination offset

-> Chunks

Source

-> ST s Int

Returns the next index into the destination after the payload

Copy the contents of the chunks into a mutable array. Precondition: The destination must have enough space to house the contents. This is not checked.

I/O with Handles

hGetContents :: Handle -> IO Chunks

Read a handle's entire contents strictly into chunks.

readFile :: FilePath -> IO Chunks

Read an entire file strictly into chunks. If reading from a regular file, this makes an effort read the file into a single chunk.

hPut :: Handle -> Chunks -> IO ()

Outputs Chunks to the specified Handle. This is implemented with hPut.

writeFile :: FilePath -> Chunks -> IO ()

Write Chunks to a file, replacing the previous contents of the file.