name:                 bitvec
version:              1.1.5.0
visibility:           public
id:                   bitvec-1.1.5.0-HV06nno3uP5GZGclsQUjoN
key:                  bitvec-1.1.5.0-HV06nno3uP5GZGclsQUjoN
license:              BSD-3-Clause
copyright:            2019-2022 Andrew Lelechenko, 2012-2016 James Cook
maintainer:           Andrew Lelechenko <andrew.lelechenko@gmail.com>
author:
    Andrew Lelechenko <andrew.lelechenko@gmail.com>,
    James Cook <mokus@deepbondi.net>

homepage:             https://github.com/Bodigrim/bitvec
synopsis:             Space-efficient bit vectors
description:
    A newtype over 'Bool' with a better 'Vector' instance: 8x less memory, up to 3500x faster.

    The <https://hackage.haskell.org/package/vector vector>
    package represents unboxed arrays of 'Bool's
    spending 1 byte (8 bits) per boolean.
    This library provides a newtype wrapper 'Bit' and a custom instance
    of an unboxed 'Vector', which packs bits densely,
    achieving an __8x smaller memory footprint.__
    The performance stays mostly the same;
    the most significant degradation happens for random writes
    (up to 10% slower).
    On the other hand, for certain bulk bit operations
    'Vector' 'Bit' is up to 3500x faster than 'Vector' 'Bool'.

    === Thread safety

    * "Data.Bit" is faster, but writes and flips are not thread-safe.
    This is because naive updates are not atomic:
    they read the whole word from memory,
    then modify a bit, then write the whole word back.
    Concurrently modifying non-intersecting slices of the same underlying array
    may also lead to unexpected results, since they can share a word in memory.
    * "Data.Bit.ThreadSafe" is slower (usually 10-20%),
    but writes and flips are thread-safe.
    Additionally, concurrently modifying non-intersecting slices of the same underlying array
    works as expected. However, operations that affect multiple elements are not
    guaranteed to be atomic.

    === Similar packages

    * <https://hackage.haskell.org/package/bv bv> and
    <https://hackage.haskell.org/package/bv-little bv-little>
    do not offer mutable vectors.

    * <https://hackage.haskell.org/package/array array>
    is memory-efficient for 'Bool', but lacks
    a handy 'Vector' interface and is not thread-safe.

category:             Data, Bit Vectors
abi:                  cb87db6010fce864227eaf41d39a25e7
exposed:              True
exposed-modules:      Data.Bit Data.Bit.ThreadSafe
hidden-modules:
    Data.Bit.F2Poly Data.Bit.F2PolyTS Data.Bit.Immutable
    Data.Bit.ImmutableTS Data.Bit.Internal Data.Bit.InternalTS
    Data.Bit.Mutable Data.Bit.MutableTS Data.Bit.PdepPext
    Data.Bit.Utils Data.Bit.SIMD

import-dirs:
    /usr/pkg/lib/x86_64-netbsd-ghc-9.8.2/bitvec-1.1.5.0-HV06nno3uP5GZGclsQUjoN

library-dirs:
    /usr/pkg/lib/x86_64-netbsd-ghc-9.8.2/bitvec-1.1.5.0-HV06nno3uP5GZGclsQUjoN

library-dirs-static:
    /usr/pkg/lib/x86_64-netbsd-ghc-9.8.2/bitvec-1.1.5.0-HV06nno3uP5GZGclsQUjoN

dynamic-library-dirs: /usr/pkg/lib/x86_64-netbsd-ghc-9.8.2
data-dir:             /usr/pkg/share/x86_64-netbsd-ghc-9.8.2/bitvec-1.1.5.0
hs-libraries:         HSbitvec-1.1.5.0-HV06nno3uP5GZGclsQUjoN
depends:
    base-4.19.1.0-inplace bytestring-0.12.1.0-inplace
    deepseq-1.5.0.0-inplace ghc-bignum-1.3-inplace
    primitive-0.9.0.0-3Z6MZnSLD38BpiHT3vTCWH
    vector-0.13.1.0-K9L0R0MUB9huYC6wi7vj

haddock-interfaces:
    /usr/pkg/share/doc/x86_64-netbsd-ghc-9.8.2/bitvec-1.1.5.0/html/bitvec.haddock

haddock-html:
    /usr/pkg/share/doc/x86_64-netbsd-ghc-9.8.2/bitvec-1.1.5.0/html
