Source: haskell-hashtables
Section: haskell
Priority: extra
Maintainer: Debian Haskell Group
Uploaders: Iain Lane
Build-Depends: cdbs,
debhelper (>= 9),
ghc,
ghc-doc,
ghc-prof,
haskell-devscripts (>= 0.8.15),
libghc-hashable-dev (>= 1.1),
libghc-hashable-dev (<< 2),
libghc-hashable-prof,
libghc-hashable-doc,
libghc-primitive-dev (>= 0.4),
libghc-primitive-dev (<< 0.6),
libghc-primitive-prof,
libghc-primitive-doc,
libghc-vector-dev (>= 0.7),
libghc-vector-dev (<< 0.11),
libghc-vector-prof,
libghc-vector-doc
Standards-Version: 3.9.4
Homepage: http://hackage.haskell.org/package/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
Section: doc
Architecture: all
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}