Writes bytes in reverse order, updating the current state.

It is the responsibility of the execution context and buffer management primitives to ensure that the current buffer remains reachable during builder execution, though completed buffers may be copied to new storage at any time. Aside from those primitives, BuildR implementations may ignore that issue.

When combining BuildRs with <> we expect the best performance when associating to the left. For example foldl (<>) mempty, though unless your foldl iteration starts from the right there may still be issues. Consider using vectorBuildR instead of foldMap.

Eta-expands a function that produces a BuildR, so that its input is not evaluated until the builder state is presented.

This odd combinator seems to help performance at times, though it may change behavior on nonterminating values of type a.

Ensures that the current buffer has at least the given number of bytes before executing the given builder.

Executes the right builder, measuring how many bytes it writes, then provides that figure to the left builder.

Convert a strict ByteString to a BuildR

byteString (x <> y) = byteString x <> byteString y

byteString mempty = mempty

>>> byteString "ABC"
Proto3.Wire.Reverse.lazyByteString "ABC"

Convert a lazy ByteString to a BuildR

Warning: evaluating the length will force the lazy ByteString's chunks, and they will remain allocated until you finish using the builder.

lazyByteString (x <> y) = lazyByteString x <> lazyByteString y

lazyByteString mempty = mempty

lazyByteString . toLazyByteString = id

toLazyByteString . lazyByteString = id

>>> lazyByteString "ABC"
Proto3.Wire.Reverse.lazyByteString "ABC"

Convert a ShortByteString to a BuildR

shortByteString (x <> y) = shortByteString x <> shortByteString y

shortByteString mempty = mempty

>>> shortByteString "ABC"
Proto3.Wire.Reverse.lazyByteString "ABC"

Convert a Word8 to a BuildR

>>> Data.ByteString.Lazy.unpack (toLazyByteString (word8 42))
[42]

Convert a Int8 to a BuildR

>>> Data.ByteString.Lazy.unpack (toLazyByteString (int8 (-5)))
[251]

Convert a Word16 to a BuildR by storing the bytes in big-endian order

In other words, the most significant byte is stored first and the least significant byte is stored last

>>> Data.ByteString.Lazy.unpack (toLazyByteString (word16BE 42))
[0,42]

Convert a Word16 to a BuildR by storing the bytes in little-endian order

In other words, the least significant byte is stored first and the most significant byte is stored last

>>> Data.ByteString.Lazy.unpack (toLazyByteString (word16LE 42))
[42,0]

Convert an Int16 to a BuildR by storing the bytes in big-endian order

In other words, the most significant byte is stored first and the least significant byte is stored last

>>> Data.ByteString.Lazy.unpack (toLazyByteString (int16BE (-5)))
[255,251]

Convert an Int16 to a BuildR by storing the bytes in little-endian order

In other words, the least significant byte is stored first and the most significant byte is stored last

>>> Data.ByteString.Lazy.unpack (toLazyByteString (int16LE (-5)))
[251,255]

Convert a Word32 to a BuildR by storing the bytes in big-endian order

In other words, the most significant byte is stored first and the least significant byte is stored last

>>> Data.ByteString.Lazy.unpack (toLazyByteString (word32BE 42))
[0,0,0,42]

Convert a Word32 to a BuildR by storing the bytes in little-endian order

In other words, the least significant byte is stored first and the most significant byte is stored last

>>> Data.ByteString.Lazy.unpack (toLazyByteString (word32LE 42))
[42,0,0,0]

Convert an Int32 to a BuildR by storing the bytes in big-endian order

In other words, the most significant byte is stored first and the least significant byte is stored last

>>> Data.ByteString.Lazy.unpack (toLazyByteString (int32BE (-5)))
[255,255,255,251]

Convert an Int32 to a BuildR by storing the bytes in little-endian order

In other words, the least significant byte is stored first and the most significant byte is stored last

>>> Data.ByteString.Lazy.unpack (toLazyByteString (int32LE (-5)))
[251,255,255,255]

Convert a Word64 to a BuildR by storing the bytes in big-endian order

In other words, the most significant byte is stored first and the least significant byte is stored last

>>> Data.ByteString.Lazy.unpack (toLazyByteString (word64BE 42))
[0,0,0,0,0,0,0,42]

Convert a Word64 to a BuildR by storing the bytes in little-endian order

In other words, the least significant byte is stored first and the most significant byte is stored last

>>> Data.ByteString.Lazy.unpack (toLazyByteString (word64LE 42))
[42,0,0,0,0,0,0,0]

Convert an Int64 to a BuildR by storing the bytes in big-endian order

In other words, the most significant byte is stored first and the least significant byte is stored last

>>> Data.ByteString.Lazy.unpack (toLazyByteString (int64BE (-5)))
[255,255,255,255,255,255,255,251]

Convert an Int64 to a BuildR by storing the bytes in little-endian order

In other words, the least significant byte is stored first and the most significant byte is stored last

>>> Data.ByteString.Lazy.unpack (toLazyByteString (int64LE (-5)))
[251,255,255,255,255,255,255,255]

Convert a Float to a BuildR by storing the bytes in IEEE-754 format in big-endian order

In other words, the most significant byte is stored first and the least significant byte is stored last

>>> Data.ByteString.Lazy.unpack (toLazyByteString (floatBE 4.2))
[64,134,102,102]

Convert a Float to a BuildR by storing the bytes in IEEE-754 format in little-endian order

In other words, the least significant byte is stored first and the most significant byte is stored last

>>> Data.ByteString.Lazy.unpack (toLazyByteString (floatLE 4.2))
[102,102,134,64]

Convert a Double to a BuildR by storing the bytes in IEEE-754 format in big-endian order

In other words, the most significant byte is stored first and the least significant byte is stored last

>>> Data.ByteString.Lazy.unpack (toLazyByteString (doubleBE 4.2))
[64,16,204,204,204,204,204,205]

Convert a Double to a BuildR by storing the bytes in IEEE-754 format in little-endian order

In other words, the least significant byte is stored first and the most significant byte is stored last

>>> Data.ByteString.Lazy.unpack (toLazyByteString (doubleLE 4.2))
[205,204,204,204,204,204,16,64]

Convert an ASCII Char to a BuildR

Careful: If you provide a Unicode character that is not part of the ASCII alphabet this will only encode the lowest 7 bits

>>> char7 ';'
Proto3.Wire.Reverse.lazyByteString ";"
>>> char7 'λ' -- Example of truncation
Proto3.Wire.Reverse.lazyByteString ";"

Convert an ASCII String to a BuildR

Careful: If you provide a Unicode String that has non-ASCII characters then this will only encode the lowest 7 bits of each character

string7 (x <> y) = string7 x <> string7 y

string7 mempty = mempty

>>> string7 "ABC"
Proto3.Wire.Reverse.lazyByteString "ABC"
>>> string7 "←↑→↓" -- Example of truncation
Proto3.Wire.Reverse.lazyByteString "\DLE\DC1\DC2\DC3"

Convert an ISO/IEC 8859-1 Char to a BuildR

Careful: If you provide a Unicode character that is not part of the ISO/IEC 8859-1 alphabet then this will only encode the lowest 8 bits

>>> char8 ';'
Proto3.Wire.Reverse.lazyByteString ";"
>>> char8 'λ' -- Example of truncation
Proto3.Wire.Reverse.lazyByteString "\187"

Convert an ISO/IEC 8859-1 String to a BuildR

Careful: If you provide a Unicode String that has non-ISO/IEC 8859-1 characters then this will only encode the lowest 8 bits of each character

string8 (x <> y) = string8 x <> string8 y

string8 mempty = mempty

>>> string8 "ABC"
Proto3.Wire.Reverse.lazyByteString "ABC"
>>> string8 "←↑→↓" -- Example of truncation
Proto3.Wire.Reverse.lazyByteString "\144\145\146\147"

Convert a Unicode Char to a BuildR using a UTF-8 encoding

>>> charUtf8 'A'
Proto3.Wire.Reverse.lazyByteString "A"
>>> charUtf8 'λ'
Proto3.Wire.Reverse.lazyByteString "\206\187"
>>> charUtf8 (Data.Char.chr 0x7FF)
Proto3.Wire.Reverse.lazyByteString "\223\191"
>>> charUtf8 (Data.Char.chr 0x800)
Proto3.Wire.Reverse.lazyByteString "\224\160\128"
>>> charUtf8 (Data.Char.chr 0xFFFF)
Proto3.Wire.Reverse.lazyByteString "\239\191\191"
>>> charUtf8 (Data.Char.chr 0x10000)
Proto3.Wire.Reverse.lazyByteString "\240\144\128\128"
>>> charUtf8 (Data.Char.chr 0x10FFFF)
Proto3.Wire.Reverse.lazyByteString "\244\143\191\191"

Convert a Unicode String to a BuildR using a UTF-8 encoding

stringUtf8 (x <> y) = stringUtf8 x <> stringUtf8 y

stringUtf8 mempty = mempty

>>> stringUtf8 "ABC"
Proto3.Wire.Reverse.lazyByteString "ABC"
>>> stringUtf8 "←↑→↓"
Proto3.Wire.Reverse.lazyByteString "\226\134\144\226\134\145\226\134\146\226\134\147"
>>> Data.ByteString.Lazy.hPutStr System.IO.stdout (toLazyByteString (stringUtf8 "←↑→↓\n"))
←↑→↓

Convert a Unicode strict Text to a BuildR using a UTF-8 encoding

textUtf8 (x <> y) = textUtf8 x <> textUtf8 y

textUtf8 mempty = mempty

>>> textUtf8 "ABC"
Proto3.Wire.Reverse.lazyByteString "ABC"
>>> textUtf8 "←↑→↓"
Proto3.Wire.Reverse.lazyByteString "\226\134\144\226\134\145\226\134\146\226\134\147"

Convert a Unicode lazy Text to a BuildR using a UTF-8 encoding

lazyTextUtf8 (x <> y) = lazyTextUtf8 x <> lazyTextUtf8 y

lazyTextUtf8 mempty = mempty

>>> lazyTextUtf8 "ABC"
Proto3.Wire.Reverse.lazyByteString "ABC"
>>> lazyTextUtf8 "←↑→↓"
Proto3.Wire.Reverse.lazyByteString "\226\134\144\226\134\145\226\134\146\226\134\147"

Convert a ShortText to a BuildR using a UTF-8 encoding.

shortTextUtf8 (x <> y) = shortTextUtf8 x <> shortTextUtf8 y

shortTextUtf8 mempty = mempty

>>> shortTextUtf8 "ABC"
Proto3.Wire.Reverse.lazyByteString "ABC"
>>> shortTextUtf8 "←↑→↓"
Proto3.Wire.Reverse.lazyByteString "\226\134\144\226\134\145\226\134\146\226\134\147"

Convert a Word to a BuildR using this variable-length encoding:

1. Convert the given value to a base 128 representation without unnecessary digits (that is, omit zero digits unless they are less significant than nonzero digits).
2. Present those base-128 digits in order of increasing significance (that is, in little-endian order).
3. Add 128 to every digit except the most significant digit, yielding a sequence of octets terminated by one that is <= 127.

This encoding is used in the wire format of Protocol Buffers version 3.

>>> Data.ByteString.Lazy.unpack (toLazyByteString (wordBase128LEVar 42))
[42]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (wordBase128LEVar 5376))
[128,42]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (wordBase128LEVar (Data.Bits.shiftL 1 7 - 1)))
[127]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (wordBase128LEVar (Data.Bits.shiftL 1 7)))
[128,1]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (wordBase128LEVar (Data.Bits.shiftL 1 14 - 1)))
[255,127]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (wordBase128LEVar (Data.Bits.shiftL 1 14)))
[128,128,1]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (wordBase128LEVar (Data.Bits.shiftL 1 21 - 1)))
[255,255,127]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (wordBase128LEVar (Data.Bits.shiftL 1 21)))
[128,128,128,1]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (wordBase128LEVar (Data.Bits.shiftL 1 28 - 1)))
[255,255,255,127]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (wordBase128LEVar (Data.Bits.shiftL 1 28)))
[128,128,128,128,1]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (wordBase128LEVar (Data.Bits.shiftL 1 32 - 1)))
[255,255,255,255,15]

Like wordBase128LEVar but inlined, which may bloat your code. On the other hand, inlining an application to a constant may shrink your code.

>>> Data.ByteString.Lazy.unpack (toLazyByteString (wordBase128LEVar_inline 42))
[42]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (wordBase128LEVar_inline 5376))
[128,42]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (wordBase128LEVar_inline (Data.Bits.shiftL 1 7 - 1)))
[127]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (wordBase128LEVar_inline (Data.Bits.shiftL 1 7)))
[128,1]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (wordBase128LEVar_inline (Data.Bits.shiftL 1 14 - 1)))
[255,127]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (wordBase128LEVar_inline (Data.Bits.shiftL 1 14)))
[128,128,1]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (wordBase128LEVar_inline (Data.Bits.shiftL 1 21 - 1)))
[255,255,127]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (wordBase128LEVar_inline (Data.Bits.shiftL 1 21)))
[128,128,128,1]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (wordBase128LEVar_inline (Data.Bits.shiftL 1 28 - 1)))
[255,255,255,127]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (wordBase128LEVar_inline (Data.Bits.shiftL 1 28)))
[128,128,128,128,1]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (wordBase128LEVar_inline (Data.Bits.shiftL 1 32 - 1)))
[255,255,255,255,15]

Convert a Word32 to a BuildR using this variable-length encoding:

1. Convert the given value to a base 128 representation without unnecessary digits (that is, omit zero digits unless they are less significant than nonzero digits).
2. Present those base-128 digits in order of increasing significance (that is, in little-endian order).
3. Add 128 to every digit except the most significant digit, yielding a sequence of octets terminated by one that is <= 127.

This encoding is used in the wire format of Protocol Buffers version 3.

>>> Data.ByteString.Lazy.unpack (toLazyByteString (word32Base128LEVar 42))
[42]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word32Base128LEVar 5376))
[128,42]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word32Base128LEVar (Data.Bits.shiftL 1 7 - 1)))
[127]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word32Base128LEVar (Data.Bits.shiftL 1 7)))
[128,1]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word32Base128LEVar (Data.Bits.shiftL 1 14 - 1)))
[255,127]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word32Base128LEVar (Data.Bits.shiftL 1 14)))
[128,128,1]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word32Base128LEVar (Data.Bits.shiftL 1 21 - 1)))
[255,255,127]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word32Base128LEVar (Data.Bits.shiftL 1 21)))
[128,128,128,1]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word32Base128LEVar (Data.Bits.shiftL 1 28 - 1)))
[255,255,255,127]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word32Base128LEVar (Data.Bits.shiftL 1 28)))
[128,128,128,128,1]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word32Base128LEVar (Data.Bits.shiftL 1 32 - 1)))
[255,255,255,255,15]

Like word32Base128LEVar but inlined, which may bloat your code. On the other hand, inlining an application to a constant may shrink your code.

Currently word32Base128LEVar is fully inline, so this makes no difference, but in future we might make different default space/speed tradeoffs.

>>> Data.ByteString.Lazy.unpack (toLazyByteString (word32Base128LEVar_inline 42))
[42]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word32Base128LEVar_inline 5376))
[128,42]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word32Base128LEVar_inline (Data.Bits.shiftL 1 7 - 1)))
[127]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word32Base128LEVar_inline (Data.Bits.shiftL 1 7)))
[128,1]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word32Base128LEVar_inline (Data.Bits.shiftL 1 14 - 1)))
[255,127]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word32Base128LEVar_inline (Data.Bits.shiftL 1 14)))
[128,128,1]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word32Base128LEVar_inline (Data.Bits.shiftL 1 21 - 1)))
[255,255,127]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word32Base128LEVar_inline (Data.Bits.shiftL 1 21)))
[128,128,128,1]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word32Base128LEVar_inline (Data.Bits.shiftL 1 28 - 1)))
[255,255,255,127]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word32Base128LEVar_inline (Data.Bits.shiftL 1 28)))
[128,128,128,128,1]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word32Base128LEVar_inline (Data.Bits.shiftL 1 32 - 1)))
[255,255,255,255,15]

Like word32Base128LEVar but for 64-bit inputs.

Inlines when the value fits within 32 bits, but see also word64Base128LEVar_inline, which always inlines.

>>> Data.ByteString.Lazy.unpack (toLazyByteString (word64Base128LEVar 42))
[42]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word64Base128LEVar 5376))
[128,42]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word64Base128LEVar (Data.Bits.shiftL 1 7 - 1)))
[127]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word64Base128LEVar (Data.Bits.shiftL 1 7)))
[128,1]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word64Base128LEVar (Data.Bits.shiftL 1 14 - 1)))
[255,127]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word64Base128LEVar (Data.Bits.shiftL 1 14)))
[128,128,1]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word64Base128LEVar (Data.Bits.shiftL 1 21 - 1)))
[255,255,127]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word64Base128LEVar (Data.Bits.shiftL 1 21)))
[128,128,128,1]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word64Base128LEVar (Data.Bits.shiftL 1 28 - 1)))
[255,255,255,127]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word64Base128LEVar (Data.Bits.shiftL 1 28)))
[128,128,128,128,1]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word64Base128LEVar (Data.Bits.shiftL 1 32 - 1)))
[255,255,255,255,15]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word64Base128LEVar (Data.Bits.shiftL 1 32)))
[128,128,128,128,16]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word64Base128LEVar (Data.Bits.shiftL 1 56 - 1)))
[255,255,255,255,255,255,255,127]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word64Base128LEVar (Data.Bits.shiftL 1 56)))
[128,128,128,128,128,128,128,128,1]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word64Base128LEVar (Data.Bits.shiftL 1 60 - 1)))
[255,255,255,255,255,255,255,255,15]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word64Base128LEVar (Data.Bits.shiftL 1 60)))
[128,128,128,128,128,128,128,128,16]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word64Base128LEVar (Data.Bits.shiftL 1 63 - 1)))
[255,255,255,255,255,255,255,255,127]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word64Base128LEVar (Data.Bits.shiftL 1 63)))
[128,128,128,128,128,128,128,128,128,1]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word64Base128LEVar (- (1 :: Data.Word.Word64))))
[255,255,255,255,255,255,255,255,255,1]

Like word64Base128LEVar but inlined, which may bloat your code. On the other hand, inlining an application to a constant may shrink your code.

>>> Data.ByteString.Lazy.unpack (toLazyByteString (word64Base128LEVar_inline 42))
[42]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word64Base128LEVar_inline 5376))
[128,42]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word64Base128LEVar_inline (Data.Bits.shiftL 1 7 - 1)))
[127]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word64Base128LEVar_inline (Data.Bits.shiftL 1 7)))
[128,1]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word64Base128LEVar_inline (Data.Bits.shiftL 1 14 - 1)))
[255,127]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word64Base128LEVar_inline (Data.Bits.shiftL 1 14)))
[128,128,1]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word64Base128LEVar_inline (Data.Bits.shiftL 1 21 - 1)))
[255,255,127]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word64Base128LEVar_inline (Data.Bits.shiftL 1 21)))
[128,128,128,1]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word64Base128LEVar_inline (Data.Bits.shiftL 1 28 - 1)))
[255,255,255,127]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word64Base128LEVar_inline (Data.Bits.shiftL 1 28)))
[128,128,128,128,1]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word64Base128LEVar_inline (Data.Bits.shiftL 1 32 - 1)))
[255,255,255,255,15]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word64Base128LEVar_inline (Data.Bits.shiftL 1 32)))
[128,128,128,128,16]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word64Base128LEVar_inline (Data.Bits.shiftL 1 56 - 1)))
[255,255,255,255,255,255,255,127]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word64Base128LEVar_inline (Data.Bits.shiftL 1 56)))
[128,128,128,128,128,128,128,128,1]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word64Base128LEVar_inline (Data.Bits.shiftL 1 60 - 1)))
[255,255,255,255,255,255,255,255,15]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word64Base128LEVar_inline (Data.Bits.shiftL 1 60)))
[128,128,128,128,128,128,128,128,16]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word64Base128LEVar_inline (Data.Bits.shiftL 1 63 - 1)))
[255,255,255,255,255,255,255,255,127]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word64Base128LEVar_inline (Data.Bits.shiftL 1 63)))
[128,128,128,128,128,128,128,128,128,1]
>>> Data.ByteString.Lazy.unpack (toLazyByteString (word64Base128LEVar_inline (- (1 :: Data.Word.Word64))))
[255,255,255,255,255,255,255,255,255,1]

Essentially foldMap, but iterates right to left for efficiency.

Like toLazyByteString but also returns the total length of the lazy ByteString, which is computed as a side effect of encoding.

Create a lazy ByteString from a BuildR

toLazyByteString (x <> y) = toLazyByteString x <> toLazyByteString y

toLazyByteString mempty = mempty

>>> toLazyByteString (stringUtf8 "ABC")
"ABC"

Like foldl but iterates right-to-left, which is often useful when creating reverse builders.

Exported for testing purposes only.