Composable specification of how to efficiently construct strict Text.

Provides instances of Semigroup and Monoid, which have complexity of O(1).

Execute the builder producing a strict text.

Convert builder to string.

Check whether the builder is empty.

Run the builder and pack the produced text into a new builder.

Useful to have around builders that you reuse, because a forced builder is much faster, since it's virtually a single call to memcopy.

Intercalate builders.

>>> intercalate ", " ["a", "b", "c"]
"a, b, c"

>>> intercalate ", " ["a"]
"a"

>>> intercalate ", " []
""

Intercalate projecting values to builder.

Strict text.

Lazy text.

Construct from a list of characters.

UTF-8 bytestring. You can use it for converting ASCII values as well.

Warning: It's your responsibility to ensure that the bytestring is properly encoded.

>>> unsafeUtf8ByteString "abc"
"abc"

>>> import Data.Text.Encoding (encodeUtf8)
>>> unsafeUtf8ByteString (encodeUtf8 "фывапролдж") == "фывапролдж"
True

Unicode character.

Safe Unicode codepoint with invalid values replaced by the � char (codepoint 0xfffd), which is the same as what Data.Text.pack does.

Signed decimal representation of an integer.

>>> decimal 123456
"123456"

>>> decimal (-123456)
"-123456"

>>> decimal 0
"0"

>>> decimal (-2 :: Int8)
"-2"

>>> decimal (-128 :: Int8)
"-128"

Fixed-length decimal without sign. Padded with zeros or trimmed depending on whether it's shorter or longer than specified.

>>> fixedLengthDecimal 5 123
"00123"

>>> fixedLengthDecimal 5 123456
"23456"

>>> fixedLengthDecimal 5 (-123456)
"23456"

>>> fixedLengthDecimal 7 (-123456)
"0123456"

>>> fixedLengthDecimal 0 123
""

>>> fixedLengthDecimal (-2) 123
""

Decimal representation of an integral value with thousands separated by the specified character.

>>> thousandSeparatedDecimal ',' 1234567890
"1,234,567,890"

>>> thousandSeparatedDecimal ' ' (-1234567890)
"-1 234 567 890"

Two's complement binary representation of a value.

Bits of a statically sized value padded from the left according to the size. If it's a negatable integer, the sign is reflected in the bits.

>>> binary @Int8 0
"00000000"

>>> binary @Int8 4
"00000100"

>>> binary @Int8 (-1)
"11111111"

>>> binary @Word8 255
"11111111"

>>> binary @Int16 4
"0000000000000100"

>>> binary @Int16 (-4)
"1111111111111100"

Same as binary, but with the "0b" prefix.

>>> prefixedBinary @Int8 0
"0b00000000"

Octal representation of an integer.

>>> octal @Int32 123456
"00000361100"

>>> octal @Int32 (-123456)
"77777416700"

Same as octal, but with the "0o" prefix.

>>> prefixedOctal @Int8 0
"0o000"

Integer in hexadecimal notation with a fixed number of digits determined by the size of the type.

>>> hexadecimal @Int8 0
"00"

>>> hexadecimal @Int8 4
"04"

>>> hexadecimal @Int8 (-128)
"80"

>>> hexadecimal @Int8 (-1)
"ff"

>>> hexadecimal @Word8 255
"ff"

>>> hexadecimal @Int32 123456
"0001e240"

>>> hexadecimal @Int32 (-123456)
"fffe1dc0"

Same as hexadecimal, but with the "0x" prefix.

>>> prefixedHexadecimal @Int8 0
"0x00"