Builder is a monad to help compose BuilderStep. With next BuilderStep continuation, we can do interesting things like perform some action, or interleave the build process.

Notes on IsString instance: Builder ()'s IsString instance use stringModifiedUTF8, which is different from stringUTF8 in that it DOES NOT PROVIDE UTF8 GUARANTEES! :

• \NUL will be written as xC0 x80.
• \xD800 ~ \xDFFF will be encoded in three bytes as normal UTF-8 codepoints.

Shortcut to buildWith defaultInitSize.

Run Builder with doubling buffer strategy, which is suitable for building short bytes.

Shortcut to buildChunksWith defaultChunkSize.

Run Builder with inserting chunk strategy, which is suitable for building a list of bytes chunks and processing them in a streaming ways.

Note the building process is lazy, building happens when list chunks are consumed.

Build some bytes and validate if it's UTF8 bytes.

Build some bytes assuming it's UTF8 encoding.

Be carefully use this function because you could constrcut illegal Text values. Check ShowT for UTF8 encoding builders. This functions is intended to be used in debug only.

Write a Bytes.

Write a primitive type in host byte order.

Write a primitive type with little endianess.

Write a primitive type with big endianess.

Encode string with modified UTF-8 encoding, will be rewritten to a memcpy if possible.

Turn Char into Builder with Modified UTF8 encoding

\NUL is encoded as two bytes C0 80 , \xD800 ~ \xDFFF is encoded as a three bytes normal UTF-8 codepoint.

Turn String into Builder with UTF8 encoding

Illegal codepoints will be written as replacementChars.

This is different from writing string literals builders via OverloadedStrings, because string literals do not provide UTF8 guarantees.

This function will be rewritten into a memcpy if possible, (running a fast UTF-8 validation at runtime first).

Turn Char into Builder with UTF8 encoding

Illegal codepoints will be written as replacementChars.

Turn String into Builder with ASCII7 encoding

Codepoints beyond 'x7F' will be chopped.

Turn Char into Builder with ASCII7 encoding

Codepoints beyond 'x7F' will be chopped.

Turn String into Builder with ASCII8 encoding

Codepoints beyond 'xFF' will be chopped. Note, this encoding is NOT compatible with UTF8 encoding, i.e. bytes written by this builder may not be legal UTF8 encoding bytes.

Turn Char into Builder with ASCII8 encoding

Codepoints beyond 'xFF' will be chopped. Note, this encoding is NOT compatible with UTF8 encoding, i.e. bytes written by this builder may not be legal UTF8 encoding bytes.

Write UTF8 encoded Text using Builder.

Note, if you're trying to write string literals builders, please open OverloadedStrings and use Builders IsString instance, it will be rewritten into a memcpy.

Integral formatting options.

defaultIFormat = IFormat 0 NoPadding False

int = intWith defaultIFormat

Format a Bounded Integral type like Int or Word16 into decimal ASCII digits.

import Z.Data.Builder as B
import Z.Data.Text    as T

> T.validate . B.buildBytes $ B.intWith defaultIFormat  (12345 :: Int)
"12345"
> T.validate . B.buildBytes $ B.intWith defaultIFormat{width=10, padding=RightSpacePadding} (12345 :: Int)
"12345     "
> T.validate . B.buildBytes $ B.intWith defaultIFormat{width=10, padding=ZeroPadding} (12345 :: Int)
"0000012345"

Format a Integer into decimal ASCII digits.

Format a FiniteBits Integral type into hex nibbles.

import Z.Data.Builder as B
import Z.Data.Text    as T
import Data.Word
import Data.Int

> T.validate . B.buildBytes $ B.hex (125 :: Int8)
"7d"
> T.validate . B.buildBytes $ B.hex (-1 :: Int8)
"ff"
> T.validate . B.buildBytes $ B.hex (125 :: Word16)
"007d"

The UPPERCASED version of hex.

Control the rendering of floating point numbers.

Decimal encoding of an IEEE Double.

Using standard decimal notation for arguments whose absolute value lies between 0.1 and 9,999,999, and scientific notation otherwise.

Format double-precision float using drisu3 with dragon4 fallback.

Decimal encoding of an IEEE Float.

Using standard decimal notation for arguments whose absolute value lies between 0.1 and 9,999,999, and scientific notation otherwise.

Format single-precision float using drisu3 with dragon4 fallback.

A Builder which renders a scientific number to full precision, using standard decimal notation for arguments whose absolute value lies between 0.1 and 9,999,999, and scientific notation otherwise.

Like scientific but provides rendering options.

add (...) to original builder.

add {...} to original builder.

add [...] to original builder.

add <...> to original builder.

add "..." to original builder.

add '...' to original builder.

write an ASCII :

write an ASCII ,

Use separator to connect a vector of builders.

import Z.Data.Builder as B
import Z.Data.Text    as T
import Z.Data.Vector  as V

> T.validate . B.build $ B.intercalateVec "," B.int (V.pack [1,2,3,4] :: V.PrimVector Int)
"1,2,3,4"

Use separator to connect list of builders.

import Z.Data.Builder as B
import Z.Data.Text    as T
import Z.Data.Vector  as V

T.validate . B.build $ B.intercalateList "," B.int ([1,2,3,4] :: [Int])
"1,2,3,4"