Data.Binary.Builder · binary-0.8.9.3

The Builder type

2 declarations

newtypenewtype Builder

Builders denote sequences of bytes. They are Monoids where mempty is the zero-length sequence and mappend is concatenation, which runs in O(1).

Instances6IsList, Show, IsString, Semigroup, Monoid, Item

IsList BuilderDefined in bytestring-0.12.2.0 · Data.ByteString.Builder.Internal
For long or infinite lists use fromList because it uses LazyByteString otherwise use fromListN which uses StrictByteString.
Show BuilderDefined in bytestring-0.12.2.0 · Data.ByteString.Builder · orphan
IsString BuilderDefined in bytestring-0.12.2.0 · Data.ByteString.Builder · orphan
Semigroup BuilderDefined in bytestring-0.12.2.0 · Data.ByteString.Builder.Internal
Monoid BuilderDefined in bytestring-0.12.2.0 · Data.ByteString.Builder.Internal
type Item Builder = Word8Defined in bytestring-0.12.2.0 · Data.ByteString.Builder.Internal

valuetoLazyByteString :: Builder -> LazyByteString

#

Execute a Builder and return the generated chunks as a LazyByteString. The work is performed lazy, i.e., only when a chunk of the LazyByteString is forced.

Constructing Builders

6 declarations

valueempty :: Builder

#

O(1). The empty Builder, satisfying

```
toLazyByteString empty = empty
```

valuesingleton :: Word8 -> Builder

#

O(1). A Builder taking a single byte, satisfying

toLazyByteString (singleton b) = singleton b

valueappend :: Builder -> Builder -> Builder

#

O(1). The concatenation of two Builders, an associative operation with identity empty, satisfying

toLazyByteString (append x y) = append (toLazyByteString x) (toLazyByteString y)

valuefromByteString :: ByteString -> Builder

#

O(1). A Builder taking a ByteString, satisfying

toLazyByteString (fromByteString bs) = fromChunks [bs]

valuefromLazyByteString :: ByteString -> Builder

#

O(1). A Builder taking a lazy ByteString, satisfying

toLazyByteString (fromLazyByteString bs) = bs

valuefromShortByteString :: ShortByteString -> Builder

#

O(n). A builder taking ShortByteString and copy it to a Builder, satisfying

@toLazyByteString (fromShortByteString bs) = fromChunks [fromShort bs]

Flushing the buffer state

1 declaration

valueflush :: Builder

#

Flush the current buffer. This introduces a chunk boundary.

Derived Builders

0 declarations

Big-endian writes

valueputWord16be :: Word16 -> Builder

#

Write a Word16 in big endian format

valueputWord32be :: Word32 -> Builder

#

Write a Word32 in big endian format

valueputWord64be :: Word64 -> Builder

#

Write a Word64 in big endian format

valueputInt16be :: Int16 -> Builder

#

Write a Int16 in big endian format

valueputInt32be :: Int32 -> Builder

#

Write a Int32 in big endian format

valueputInt64be :: Int64 -> Builder

#

Write a Int64 in big endian format

Little-endian writes

valueputWord16le :: Word16 -> Builder

#

Write a Word16 in little endian format

valueputWord32le :: Word32 -> Builder

#

Write a Word32 in little endian format

valueputWord64le :: Word64 -> Builder

#

Write a Word64 in little endian format

valueputInt16le :: Int16 -> Builder

#

Write a Int16 in little endian format

valueputInt32le :: Int32 -> Builder

#

Write a Int32 in little endian format

valueputInt64le :: Int64 -> Builder

#

Write a Int64 in little endian format

Host-endian, unaligned writes

valueputWordhost :: Word -> Builder

#

O(1). A Builder taking a single native machine word. The word is written in host order, host endian form, for the machine you're on. On a 64 bit machine the Word is an 8 byte value, on a 32 bit machine, 4 bytes. Values written this way are not portable to different endian or word sized machines, without conversion.

valueputWord16host :: Word16 -> Builder

#

Write a Word16 in native host order and host endianness. 2 bytes will be written, unaligned.

valueputWord32host :: Word32 -> Builder

#

Write a Word32 in native host order and host endianness. 4 bytes will be written, unaligned.

valueputWord64host :: Word64 -> Builder

#

Write a Word64 in native host order. On a 32 bit machine we write two host order Word32s, in big endian form. 8 bytes will be written, unaligned.

valueputInthost :: Int -> Builder

#

O(1). A Builder taking a single native machine word. The word is written in host order, host endian form, for the machine you're on. On a 64 bit machine the Int is an 8 byte value, on a 32 bit machine, 4 bytes. Values written this way are not portable to different endian or word sized machines, without conversion.

valueputInt16host :: Int16 -> Builder

#

Write a Int16 in native host order and host endianness. 2 bytes will be written, unaligned.

valueputInt32host :: Int32 -> Builder

#

Write a Int32 in native host order and host endianness. 4 bytes will be written, unaligned.

valueputInt64host :: Int64 -> Builder

#

Write a Int64 in native host order. On a 32 bit machine we write two host order Int32s, in big endian form. 8 bytes will be written, unaligned.

Unicode

valueputCharUtf8 :: Char -> Builder

#

Write a character using UTF-8 encoding.

valueputStringUtf8 :: String -> Builder

#

Write a String using UTF-8 encoding.