bytestring-0.10.0.2: Fast, compact, strict and lazy byte strings with a list interface

# bytestring-0.10.0.2: Fast, compact, strict and lazy byte strings with a list interface

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 `ByteStrin`g 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.

`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

Modules

- Data
  - Data.ByteString
    - Data.ByteString.Char8
    - Data.ByteString.Lazy
      - Data.ByteString.Lazy.Builder
        - Data.ByteString.Lazy.Builder.ASCII
        - Data.ByteString.Lazy.Builder.Extras
      - Data.ByteString.Lazy.Char8
    - Data.ByteString.Unsafe