Data.Bytes.Chunks

A cons-list of byte sequences.

The total number of bytes in all the chunks.

Are there any bytes in the chunked byte sequences?

Add a byte sequence to the beginning.

Concatenate chunks into a single contiguous byte sequence.

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

Variant of concat that returns an unsliced byte sequence.

Variant of concatPinned that returns an unsliced pinned byte sequence.

Concatenate chunks into a strict bytestring.

Reverse chunks but not the bytes within each chunk.

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

Repeat the byte sequence over and over. Returns empty chunks when given a negative repetition count.

Repeat the byte over and over. This builds a single byte array that is at most 64KiB and shares that across every ChunksCons cell.

An as example, creating a 2GiB chunks this way would use 64KiB for the byte array, and there would be the additional overhead of the 2^15 ChunksCons data constructors. On a 64-bit platform, ChunksCons takes 40 bytes, so the total memory consumption would be 2^16 + 40 * 2^15, which is roughly 1.37MB. The same reasoning shows that it takes about 83.95MB to represent a 128GiB chunks.

The size of the shared payload is an implementation detail. Do not rely on this function producing 64KiB chunks. The implementation might one day change to something smarter that minimizes the memory footprint for very large chunks.

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

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.

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

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

Create a list of chunks with a single chunk.

Variant of fromBytes where the single chunk is unsliced.

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.

Read a handle's entire contents strictly into 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.

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

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