An efficient compact, immutable byte string type (both strict and lazy)
suitable for binary or 8-bit character data.

The 'ByteString' type represents sequences of bytes or 8-bit characters.
It is suitable for high performance use, both in terms of large data
quantities, or high speed requirements. The 'ByteString' functions follow
the same style as Haskell\'s ordinary lists, so it is easy to convert code
from using 'String' to 'ByteString'.

Two 'ByteString' variants are provided:

* Strict 'ByteString's keep the string as a single large array. This
makes them convenient for passing data between C and Haskell.

* Lazy 'ByteString's use a lazy list of strict chunks which makes it
suitable for I\/O streaming tasks.

The @Char8@ modules provide a character-based view of the same
underlying 'ByteString' types. This makes it convenient to handle mixed
binary and 8-bit character content (which is common in many file formats
and network protocols).

The 'Builder' module provides an efficient way to build up 'ByteString's
in an ad-hoc way by repeated concatenation. This is ideal for fast
serialisation or pretty printing.

There is also a 'ShortByteString' type which has a lower memory overhead
and can be converted to or from a 'ByteString'. It is suitable for keeping
many short strings in memory, especially long-term, without incurring any
possible heap fragmentation costs.

'ByteString's are not designed for Unicode. For Unicode strings you should
use the 'Text' type from the @text@ package.

These modules are intended to be imported qualified, to avoid name clashes
with "Prelude" functions, e.g.

> import qualified Data.ByteString as BS