Source: haskell-hashtables
Maintainer: Debian Haskell Group <pkg-haskell-maintainers@lists.alioth.debian.org>
Uploaders:
 Iain Lane <laney@debian.org>,
Priority: optional
Section: haskell
Rules-Requires-Root: no
Build-Depends:
 cdbs,
 debhelper (>= 10),
 ghc (>= 8),
 ghc-prof,
 haskell-devscripts (>= 0.13),
 libghc-hashable-dev,
 libghc-hashable-prof,
 libghc-primitive-dev,
 libghc-primitive-prof,
 libghc-vector-dev (>= 0.7),
 libghc-vector-dev (<< 0.13),
 libghc-vector-prof,
Build-Depends-Indep:
 ghc-doc,
 libghc-hashable-doc,
 libghc-primitive-doc,
 libghc-vector-doc,
Standards-Version: 4.1.4
Homepage: http://github.com/gregorycollins/hashtables
Vcs-Browser: https://salsa.debian.org/haskell-team/DHG_packages/tree/master/p/haskell-hashtables
Vcs-Git: https://salsa.debian.org/haskell-team/DHG_packages.git [p/haskell-hashtables]

Package: libghc-hashtables-dev
Architecture: any
Depends:
 ${haskell:Depends},
 ${misc:Depends},
 ${shlibs:Depends},
Recommends:
 ${haskell:Recommends},
Suggests:
 ${haskell:Suggests},
Provides:
 ${haskell:Provides},
Description: mutable hash tables${haskell:ShortBlurb}
 This package provides a couple of different implementations of mutable hash
 tables in the ST monad, as well as a typeclass abstracting their common
 operations, and a set of wrappers to use the hash tables in the IO monad.
 .
 There are three hash table implementations:
 .
  * Data.HashTable.ST.Basic contains a basic open-addressing hash table using
    linear probing as the collision strategy. This should currently be the
    fastest available hash table implementation for lookups, although it has a
    higher memory overhead than others.
  * Data.HashTable.ST.Cuckoo contains an implementation of "cuckoo hashing".
    Cuckoo hashing has worst-case O(1) lookups and performs well even when the
    table is highly loaded.
  * Data.HashTable.ST.Linear contains a linear hash table, which trades some
    insert and lookup performance for higher space efficiency and much shorter
    delays when expanding the table.
 .
 ${haskell:Blurb}

Package: libghc-hashtables-prof
Architecture: any
Depends:
 ${haskell:Depends},
 ${misc:Depends},
 ${shlibs:Depends},
Recommends:
 ${haskell:Recommends},
Suggests:
 ${haskell:Suggests},
Provides:
 ${haskell:Provides},
Description: mutable hash tables -- profiling libraries${haskell:ShortBlurb}
 This package provides a couple of different implementations of mutable hash
 tables in the ST monad, as well as a typeclass abstracting their common
 operations, and a set of wrappers to use the hash tables in the IO monad.
 .
 There are three hash table implementations:
 .
  * Data.HashTable.ST.Basic contains a basic open-addressing hash table using
    linear probing as the collision strategy. This should currently be the
    fastest available hash table implementation for lookups, although it has a
    higher memory overhead than others.
  * Data.HashTable.ST.Cuckoo contains an implementation of "cuckoo hashing".
    Cuckoo hashing has worst-case O(1) lookups and performs well even when the
    table is highly loaded.
  * Data.HashTable.ST.Linear contains a linear hash table, which trades some
    insert and lookup performance for higher space efficiency and much shorter
    delays when expanding the table.
 .
 ${haskell:Blurb}

Package: libghc-hashtables-doc
Architecture: all
Section: doc
Depends:
 ${haskell:Depends},
 ${misc:Depends},
 ${shlibs:Depends},
Recommends:
 ${haskell:Recommends},
Suggests:
 ${haskell:Suggests},
Provides:
 ${haskell:Provides},
Description: mutable hash tables -- documentation${haskell:ShortBlurb}
 This package provides a couple of different implementations of mutable hash
 tables in the ST monad, as well as a typeclass abstracting their common
 operations, and a set of wrappers to use the hash tables in the IO monad.
 .
 There are three hash table implementations:
 .
  * Data.HashTable.ST.Basic contains a basic open-addressing hash table using
    linear probing as the collision strategy. This should currently be the
    fastest available hash table implementation for lookups, although it has a
    higher memory overhead than others.
  * Data.HashTable.ST.Cuckoo contains an implementation of "cuckoo hashing".
    Cuckoo hashing has worst-case O(1) lookups and performs well even when the
    table is highly loaded.
  * Data.HashTable.ST.Linear contains a linear hash table, which trades some
    insert and lookup performance for higher space efficiency and much shorter
    delays when expanding the table.
 .
 ${haskell:Blurb}