A cons-list of byte sequences.
Modulebyteslice-0.2.15.0Haskell2010
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.
Synopsis
- data Chunks
- value length
- value null
- value cons
- value concat
- value concatPinned
- value concatU
- value concatPinnedU
- value concatByteString
- value reverse
- value reverseOnto
- value replicate
- value replicateByte
- value foldl'
- value split
- value fnv1a32
- value fnv1a64
- value fromBytes
- value fromByteArray
- value unsafeCopy
- value hGetContents
- value readFile
- value hPut
- value writeFile
- Packagebyteslice-0.2.15.0
- Exports24
- LanguageHaskell2010
- LicenceBSD-3-Clause
- SourceChunks.hs
Types
Properties
The total number of bytes in all the chunks.
Are there any bytes in the chunked byte sequences?
Manipulate
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.
Folds
Left fold over all bytes in the chunks, strict in the accumulator.
Splitting
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
Hash byte sequence with 32-bit variant of FNV-1a.
Hash byte sequence with 64-bit variant of FNV-1a.
Create
Create a list of chunks with a single chunk.
Variant of fromBytes where the single chunk is unsliced.
Copy to buffer
value
unsafeCopy :: MutableByteArray sDestination
-> IntDestination offset
-> ChunksSource
-> ST s IntReturns 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
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.
Write Chunks to a file, replacing the previous contents of the file.