Data.Bytes

A slice of a ByteArray.

The empty byte sequence.

The empty pinned byte sequence.

The empty pinned byte sequence.

Is the byte sequence empty?

The length of a slice of bytes.

Extract the head and tail of the Bytes, returning Nothing if it is empty.

Extract the init and last of the Bytes, returning Nothing if it is empty.

O(n) Returns true if any byte in the sequence satisfies the predicate.

O(n) Returns true if all bytes in the sequence satisfy the predicate.

Take bytes while the predicate is true.

Drop bytes while the predicate is true.

O(n) takeWhileEnd p b returns the longest suffix of elements that satisfy predicate p.

O(n) dropWhileEnd p b returns the prefix remaining after dropping characters that satisfy the predicate p from the end of t.

Map over bytes in a sequence. The result has the same length as the argument.

Variant of map that returns unsliced byte sequence.

Left fold over bytes, non-strict in the accumulator.

Left fold over bytes, strict in the accumulator.

Right fold over bytes, non-strict in the accumulator.

Right fold over bytes, strict in the accumulator.

Left fold over bytes, strict in the accumulator. The reduction function is applied to each element along with its index.

Left monadic fold over bytes, non-strict in the accumulator.

Right monadic fold over bytes, non-strict in the accumulator.

Is the byte a member of the byte sequence?

O(n) The intercalate function takes a separator Bytes and a list of Bytes and concatenates the list elements by interspersing the separator between each element.

Specialization of intercalate where the separator is a single byte and there are exactly two byte sequences that are being concatenated.

Replace every non-overlapping occurrence of needle in haystack with replacement.

Find locations of non-overlapping instances of needle within haystack.

Count the number of times the byte appears in the sequence.

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

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

Take the first n bytes from the argument. Precondition: n ≤ len

Drop the first n bytes from the argument. Precondition: n ≤ len

Index into the byte sequence at the given position. This index must be less than the length.

Access the first byte. The given Bytes must be non-empty.

Copy the byte sequence into a mutable buffer. The buffer must have enough space to accomodate the byte sequence, but this this is not checked.

Yields a pinned byte sequence whose contents are identical to those of the original byte sequence. If the ByteArray backing the argument was already pinned, this simply aliases the argument and does not perform any copying.

Yields a pointer to the beginning of the byte sequence. It is only safe to call this on a Bytes backed by a pinned ByteArray.

Touch the byte array backing the byte sequence. This sometimes needed after calling contents so that the ByteArray does not get garbage collected.

Convert the sliced Bytes to an unsliced ByteArray. This reuses the array backing the sliced Bytes if the slicing metadata implies that all of the bytes are used. Otherwise, it makes a copy.

Variant of toByteArray that unconditionally makes a copy of the array backing the sliced Bytes even if the original array could be reused. Prefer toByteArray.

Convert the sliced Bytes to an unsliced ByteArray. This reuses the array backing the sliced Bytes if the slicing metadata implies that all of the bytes are used and they are already pinned. Otherwise, it makes a copy.

Variant of toPinnedByteArray that unconditionally makes a copy of the array backing the sliced Bytes even if the original array could be reused. Prefer toPinnedByteArray.

Convert a String consisting of only characters in the ASCII block to a byte sequence. Any character with a codepoint above U+007F is replaced by U+0000.

Convert a String consisting of only characters representable by ISO-8859-1. These are encoded with ISO-8859-1. Any character with a codepoint above U+00FF is replaced by an unspecified byte.

Create a slice of Bytes that spans the entire argument array.

Create a slice of Bytes that spans the entire PrimArray of 8-bit words.

Interpret a byte sequence as text encoded by ISO-8859-1.

Copy a primitive string literal into managed memory.

O(n) when unpinned, O(1) when pinned. Create a ByteString from a byte sequence. This only copies the byte sequence if it is not pinned.

Convert a pinned Bytes to a ByteString O(1) Precondition: bytes are pinned. Behavior is undefined otherwise.

O(n) Copy a ByteString to a byte sequence.

O(n) Copy a lazy bytestring to a byte sequence.

O(1) Create Bytes from a ShortByteString.

O(1) Create Bytes from a ShortText. This encodes the text as UTF-8. It is a no-op.

Convert the sliced Bytes to an unsliced ShortByteString. This reuses the array backing the sliced Bytes if the slicing metadata implies that all of the bytes are used. Otherwise, it makes a copy.

Variant of toShortByteString that unconditionally makes a copy of the array backing the sliced Bytes even if the original array could be reused. Prefer toShortByteString.

O(n) Interpreting the bytes an ASCII-encoded characters, convert the string to lowercase. This adds 0x20 to bytes in the range [0x41,0x5A] and leaves all other bytes alone. Unconditionally copies the bytes.

Read Bytes directly from the specified Handle. The resulting Bytes are pinned. This is implemented with hGetBuf.

Read an entire file strictly into a Bytes.

Outputs Bytes to the specified Handle. This is implemented with hPutBuf.

Convert Bytes to BytesN, exposing the length in a type-safe way in the callback.