An unmaterialized sequence of bytes that may be pasted into a mutable byte array.

Convert a bounded builder to an unbounded one. If the size is a constant, use Arithmetic.Nat.constant as the first argument to let GHC conjure up this value for you.

Run a builder.

Run a builder. The resulting chunks are consed onto the beginning of an existing sequence of chunks.

Variant of runOnto that conses the additional chunks in reverse order.

Run a builder against lots of elements. This fills the same underlying buffer over and over again. Do not let the argument to the callback escape from the callback (i.e. do not write it to an IORef). Also, do not unsafeFreezeByteArray any of the mutable byte arrays in the callback. The intent is that the callback will write the buffer out.

Variant of putMany that prefixes each pushed array of chunks with the number of bytes that the chunks in each batch required. (This excludes the bytes required to encode the length itself.) This is useful for chunked HTTP encoding.

Create a builder from a sliced byte sequence. The variants copy and insert provide more control over whether or not the byte sequence is copied or aliased. This function is preferred when the user does not know the size of the byte sequence.

Create a builder from a byte sequence. This always results in a call to memcpy. This is beneficial when the byte sequence is known to be small (less than 256 bytes).

Create a builder from two byte sequences. This always results in two calls to memcpy. This is beneficial when the byte sequences are known to be small (less than 256 bytes).

Create a builder from a byte sequence. This never calls memcpy. Instead, it pushes a chunk that references the argument byte sequence. This wastes the remaining space in the active chunk, so it may adversely affect performance if used carelessly. See flush for a way to mitigate this problem. This functions is most beneficial when the byte sequence is known to be large (more than 8192 bytes).

Create a builder from an unsliced byte sequence. Implemented with bytes.

Create a builder from a short bytestring. Implemented with bytes.

Create a builder from text. The text will be UTF-8 encoded.

Create a builder from text. The text will be UTF-8 encoded, and JSON special characters will be escaped. Additionally, the result is surrounded by double quotes. For example:

• foo ==> "foo" (no escape sequences)
• \_"_/ ==> "\\_\"_/" (escapes backslashes and quotes)
• hello<ESC>world ==> "hello\u001Bworld" (where <ESC> is code point 0x1B)

Create a builder from a NUL-terminated CString. This ignores any textual encoding, copying bytes until NUL is reached.

Create a builder from a C string with explicit length. The builder must be executed before the C string is freed.

Create a builder from a cons-list of Char. These are be UTF-8 encoded.

Encodes an unsigned 64-bit integer as decimal. This encoding never starts with a zero unless the argument was zero.

Encodes an unsigned 16-bit integer as decimal. This encoding never starts with a zero unless the argument was zero.

Encodes an unsigned 16-bit integer as decimal. This encoding never starts with a zero unless the argument was zero.

Encodes an unsigned 8-bit integer as decimal. This encoding never starts with a zero unless the argument was zero.

Encodes an unsigned machine-sized integer as decimal. This encoding never starts with a zero unless the argument was zero.

Encodes an unsigned arbitrary-precision integer as decimal. This encoding never starts with a zero unless the argument was zero.

Encodes a signed 64-bit integer as decimal. This encoding never starts with a zero unless the argument was zero. Negative numbers are preceded by a minus sign. Positive numbers are not preceded by anything.

Encodes a signed 32-bit integer as decimal. This encoding never starts with a zero unless the argument was zero. Negative numbers are preceded by a minus sign. Positive numbers are not preceded by anything.

Encodes a signed 16-bit integer as decimal. This encoding never starts with a zero unless the argument was zero. Negative numbers are preceded by a minus sign. Positive numbers are not preceded by anything.

Encodes a signed 8-bit integer as decimal. This encoding never starts with a zero unless the argument was zero. Negative numbers are preceded by a minus sign. Positive numbers are not preceded by anything.

Encodes a signed machine-sized integer as decimal. This encoding never starts with a zero unless the argument was zero. Negative numbers are preceded by a minus sign. Positive numbers are not preceded by anything.

Encode a signed arbitrary-precision integer as decimal. This encoding never starts with a zero unless the argument was zero. Negative numbers are preceded by a minus sign. Positive numbers are not preceded by anything.

Encode a 64-bit unsigned integer as hexadecimal, zero-padding the encoding to 16 digits. This uses uppercase for the alphabetical digits. For example, this encodes the number 1022 as 00000000000003FE.

Encode a 32-bit unsigned integer as hexadecimal, zero-padding the encoding to 8 digits. This uses uppercase for the alphabetical digits. For example, this encodes the number 1022 as 000003FE.

Encode a 16-bit unsigned integer as hexadecimal, zero-padding the encoding to 4 digits. This uses uppercase for the alphabetical digits. For example, this encodes the number 1022 as 03FE.

Encode a 16-bit unsigned integer as hexadecimal, zero-padding the encoding to 4 digits. This uses lowercase for the alphabetical digits. For example, this encodes the number 1022 as 03fe.

Encode a 16-bit unsigned integer as hexadecimal without leading zeroes. This uses lowercase for the alphabetical digits. For example, this encodes the number 1022 as 3fe.

Encode a 16-bit unsigned integer as hexadecimal without leading zeroes. This uses uppercase for the alphabetical digits. For example, this encodes the number 1022 as 3FE.

Encode a 8-bit unsigned integer as hexadecimal, zero-padding the encoding to 2 digits. This uses uppercase for the alphabetical digits. For example, this encodes the number 11 as 0B.

Encode a 16-bit unsigned integer as hexadecimal without leading zeroes. This uses lowercase for the alphabetical digits. For example, this encodes the number 1022 as 3FE.

Encode an ASCII char. Precondition: Input must be an ASCII character. This is not checked.

Encode two ASCII characters. Precondition: Must be an ASCII characters. This is not checked.

Encode three ASCII characters. Precondition: Must be an ASCII characters. This is not checked.

Encode four ASCII characters. Precondition: Must be an ASCII characters. This is not checked.

Encode five ASCII characters. Precondition: Must be an ASCII characters. This is not checked.

Encode five ASCII characters. Precondition: Must be an ASCII characters. This is not checked.

Encode a UTF-8 char. This only uses as much space as is required.

Requires exactly 1 byte.

Requires exactly 32 bytes. Dump the octets of a 256-bit word in a big-endian fashion.

Requires exactly 16 bytes. Dump the octets of a 128-bit word in a big-endian fashion.

Requires exactly 8 bytes. Dump the octets of a 64-bit word in a big-endian fashion.

Requires exactly 4 bytes. Dump the octets of a 32-bit word in a big-endian fashion.

Requires exactly 2 bytes. Dump the octets of a 16-bit word in a big-endian fashion.

Requires exactly 8 bytes. Dump the octets of a 64-bit signed integer in a big-endian fashion.

Requires exactly 4 bytes. Dump the octets of a 32-bit signed integer in a big-endian fashion.

Requires exactly 2 bytes. Dump the octets of a 16-bit signed integer in a big-endian fashion.

Requires exactly 32 bytes. Dump the octets of a 256-bit word in a little-endian fashion.

Requires exactly 16 bytes. Dump the octets of a 128-bit word in a little-endian fashion.

Requires exactly 8 bytes. Dump the octets of a 64-bit word in a little-endian fashion.

Requires exactly 4 bytes. Dump the octets of a 32-bit word in a little-endian fashion.

Requires exactly 2 bytes. Dump the octets of a 16-bit word in a little-endian fashion.

Requires exactly 8 bytes. Dump the octets of a 64-bit signed integer in a little-endian fashion.

Requires exactly 4 bytes. Dump the octets of a 32-bit signed integer in a little-endian fashion.

Requires exactly 2 bytes. Dump the octets of a 16-bit signed integer in a little-endian fashion.

Encode a signed machine-sized integer with LEB-128. This uses zig-zag encoding.

Encode a machine-sized word with LEB-128.

Encode a 64-bit word with LEB-128.

Create a builder from a slice of an array of Word8. There is the same as bytes but is provided as a convenience for users working with different types.

Prefix a builder with the number of bytes that it requires.

Variant of consLength32BE the encodes the length in a little-endian fashion.

Prefix a builder with its size in bytes. This size is presented as a big-endian 32-bit word. The need to prefix a builder with its length shows up a numbers of wire protocols including those of PostgreSQL and Apache Kafka. Note the equivalence:

forall (n :: Int) (x :: Builder).
  let sz = sizeofByteArray (run n (consLength32BE x))
  consLength32BE x === word32BE (fromIntegral sz) <> x

However, using consLength32BE is much more efficient here since it only materializes the ByteArray once.

Prefix a builder with its size in bytes. This size is presented as a big-endian 64-bit word. See consLength32BE.

Encode a double-floating-point number, using decimal notation or scientific notation depending on the magnitude. This has undefined behavior when representing +inf, -inf, and NaN. It will not crash, but the generated numbers will be nonsense.

Push the buffer currently being filled onto the chunk list, allocating a new active buffer of the requested size. This is helpful when a small builder is sandwhiched between two large zero-copy builders:

insert bigA <> flush 1 <> word8 0x42 <> insert bigB

Without flush 1, word8 0x42 would see the zero-byte active buffer that insert returned, decide that it needed more space, and allocate a 4080-byte buffer to which only a single byte would be written.