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.

Pad a builder from the left side to the specified length with the specified character.

>>> padFromLeft 5 '0' "123"
"00123"

>>> padFromLeft 5 '0' "123456"
"123456"

Pad a builder from the right side to the specified length with the specified character.

>>> padFromRight 5 ' ' "123"
"123  "

>>> padFromRight 5 ' ' "123456"
"123456"

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.

Hexadecimal readable representation of binary data.

>>> byteStringHexEncoding "Hello"
"4865 6c6c 6f"

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"

Double with a fixed number of decimal places.

>>> doubleFixedPoint 4 0.123456
"0.1235"

>>> doubleFixedPoint 2 2.1
"2.10"

>>> doubleFixedPoint (-2) 2.1
"2"

>>> doubleFixedPoint 2 (-2.1)
"-2.10"

>>> doubleFixedPoint 2 0
"0.00"

Double multiplied by 100 with a fixed number of decimal places applied and followed by a percent-sign.

>>> doubleFixedPointPercent 3 0.123456
"12.346%"

>>> doubleFixedPointPercent 0 2
"200%"

>>> doubleFixedPointPercent 0 (-2)
"-200%"

UTC time in ISO8601 format.

>>> utcTimeIso8601Timestamp (read "2021-11-24 12:11:02 UTC")
"2021-11-24T12:11:02Z"

Time interval in seconds. Directly applicable to DiffTime and NominalDiffTime.

The format is the following:

DD:HH:MM:SS

>>> realFracDdHhMmSsInterval @Double 59
"00:00:00:59"

>>> realFracDdHhMmSsInterval @Double 90
"00:00:01:30"

>>> realFracDdHhMmSsInterval @Double 86401
"01:00:00:01"

>>> realFracDdHhMmSsInterval @Double (356 * 86400)
"356:00:00:00"

DiffTime in a compact decimal format based on picoseconds.

Amount of picoseconds represented in a compact decimal format using suffixes.

E.g., the following is 1_230_000_000 picoseconds or 1.23 milliseconds or 1230 microseconds:

1230us

Data size in decimal notation over amount of bytes.

>>> approximateDataSize 999
"999B"

>>> approximateDataSize 9999
"9.9kB"

>>> approximateDataSize (-9999)
"-9.9kB"

>>> approximateDataSize 1234567890
"1.2GB"

>>> approximateDataSize 10000000000000000000000000000000023
"10,000,000,000YB"

Evidence that there exists an unambiguous way to convert a type to and from TextBuilder.

The laws are:

• from . to = id

• to . from = id

This class does not provide implicit rendering, such as from integer to its decimal representation. There are multiple ways of representing an integer as text (e.g., hexadecimal, binary). The non-ambiguity is further enforced by the presence of the inverse conversion. In the integer case there is no way to read it from a textual form without a possibility of failing (e.g., when the input string cannot be parsed as an integer).