bytestring.cabal

Name:                bytestring
Version:             0.10.10.1
Synopsis:            Fast, compact, strict and lazy byte strings with a list interface
Description:
    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 can be converted to or from a 'ByteString', but supports very few
    other operations. It is suitable for keeping many short strings in memory.
    .
    '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

License:             BSD3
License-file:        LICENSE
Category:            Data
Copyright:           Copyright (c) Don Stewart          2005-2009,
                               (c) Duncan Coutts        2006-2015,
                               (c) David Roundy         2003-2005,
                               (c) Jasper Van der Jeugt 2010,
                               (c) Simon Meier          2010-2013.

Author:              Don Stewart,
                     Duncan Coutts
Maintainer:          Duncan Coutts <duncan@community.haskell.org>
Homepage:            https://github.com/haskell/bytestring
Bug-reports:         https://github.com/haskell/bytestring/issues
Tested-With:         GHC==8.10.1, GHC==8.8.3, GHC==8.6.5, GHC==8.4.4, GHC==8.2.2,
                     GHC==8.0.2, GHC==7.10.3, GHC==7.8.4, GHC==7.6.3, GHC==7.4.2,
                     GHC==7.2.2, GHC==7.0.4
Build-Type:          Simple
Cabal-Version:       >= 1.10
extra-source-files:  README.md Changelog.md

source-repository head
  type:     git
  location: https://github.com/haskell/bytestring

flag integer-simple
  description: Use the simple integer library instead of GMP
  default: False

library
  build-depends:     base >= 4.2 && < 5, ghc-prim, deepseq

  exposed-modules:   Data.ByteString
                     Data.ByteString.Char8
                     Data.ByteString.Unsafe
                     Data.ByteString.Internal
                     Data.ByteString.Lazy
                     Data.ByteString.Lazy.Char8
                     Data.ByteString.Lazy.Internal
                     Data.ByteString.Short
                     Data.ByteString.Short.Internal

                     Data.ByteString.Builder
                     Data.ByteString.Builder.Extra
                     Data.ByteString.Builder.Prim

                     -- perhaps only exposed temporarily
                     Data.ByteString.Builder.Internal
                     Data.ByteString.Builder.Prim.Internal

                     -- sigh, we decided to rename shortly after making
                     -- an initial release, so these are here for compat
                     Data.ByteString.Lazy.Builder
                     Data.ByteString.Lazy.Builder.Extras
                     Data.ByteString.Lazy.Builder.ASCII
  other-modules:
                     Data.ByteString.Builder.ASCII
                     Data.ByteString.Builder.Prim.Binary
                     Data.ByteString.Builder.Prim.ASCII
                     Data.ByteString.Builder.Prim.Internal.Floating
                     Data.ByteString.Builder.Prim.Internal.UncheckedShifts
                     Data.ByteString.Builder.Prim.Internal.Base16

  default-language:  Haskell98
  other-extensions:  CPP,
                     ForeignFunctionInterface,
                     BangPatterns
                     UnliftedFFITypes,
                     MagicHash,
                     UnboxedTuples,
                     DeriveDataTypeable
                     ScopedTypeVariables
                     RankNTypes
                     NamedFieldPuns
--  if impl(ghc >= 7.2)
--    other-extensions: Trustworthy, Unsafe
  -- older ghc had issues with language pragmas guarded by cpp
  if impl(ghc < 7)
    default-extensions: CPP, MagicHash, UnboxedTuples,
                        DeriveDataTypeable, BangPatterns,
                        NamedFieldPuns

  ghc-options:      -Wall -fwarn-tabs
                    -O2
                    -fmax-simplifier-iterations=10
                    -fdicts-cheap
                    -fspec-constr-count=6

  c-sources:         cbits/fpstring.c
                     cbits/itoa.c
  include-dirs:      include
  includes:          fpstring.h
  install-includes:  fpstring.h

   -- flags for the decimal integer serialization code
  if impl(ghc >= 8.11)
    build-depends: ghc-bignum >= 1.0

  if impl(ghc >= 6.11) && impl(ghc < 8.11)
    if !flag(integer-simple)
      cpp-options: -DINTEGER_GMP
      build-depends: integer-gmp >= 0.2

  if impl(ghc >= 6.9) && impl(ghc < 6.11)
    cpp-options: -DINTEGER_GMP
    build-depends: integer >= 0.1 && < 0.2