This file is indexed.

/var/lib/ghc/package.conf.d/hashtables-1.0.1.8.conf is in libghc-hashtables-dev 1.0.1.8-2build2.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
name: hashtables
version: 1.0.1.8
id: hashtables-1.0.1.8-14f0bacd79c664cb88f0b4a6cc06dc8d

license: BSD3
copyright: (c) 2011-2012, Google, Inc.
maintainer: greg@gregorycollins.net
stability:
homepage: http://github.com/gregorycollins/hashtables
package-url:
synopsis: Mutable hash tables in the ST monad
description: 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.
             .
             /QUICK START/: documentation for the hash table operations is provided in the
             "Data.HashTable.Class" module, and the IO wrappers (which most users will
             probably prefer) are located in the "Data.HashTable.IO" module.
             .
             This package currently contains three hash table implementations:
             .
             1. "Data.HashTable.ST.Basic" contains a basic open-addressing hash table
             using linear probing as the collision strategy. On a pure speed basis it
             should currently be the fastest available Haskell hash table
             implementation for lookups, although it has a higher memory overhead
             than the other tables and can suffer from long delays when the table is
             resized because all of the elements in the table need to be rehashed.
             .
             2. "Data.HashTable.ST.Cuckoo" contains an implementation of \"cuckoo
             hashing\" as introduced by Pagh and Rodler in 2001 (see
             <http://en.wikipedia.org/wiki/Cuckoo_hashing>). Cuckoo hashing has
             worst-case /O(1)/ lookups and can reach a high \"load factor\", in which
             the table can perform acceptably well even when more than 90% full.
             Randomized testing shows this implementation of cuckoo hashing to be
             slightly faster on insert and slightly slower on lookup than
             "Data.Hashtable.ST.Basic", while being more space efficient by about a
             half-word per key-value mapping. Cuckoo hashing, like the basic hash
             table implementation using linear probing, can suffer from long delays
             when the table is resized.
             .
             3. "Data.HashTable.ST.Linear" contains a linear hash table (see
             <http://en.wikipedia.org/wiki/Linear_hashing>), which trades some insert
             and lookup performance for higher space efficiency and much shorter
             delays when expanding the table. In most cases, benchmarks show this
             table to be currently slightly faster than @Data.HashTable@ from the
             Haskell base library.
             .
             It is recommended to create a concrete type alias in your code when using this
             package, i.e.:
             .
             > import qualified Data.HashTable.IO as H
             >
             > type HashTable k v = H.BasicHashTable k v
             >
             > foo :: IO (HashTable Int Int)
             > foo = do
             >     ht <- H.new
             >     H.insert ht 1 1
             >     return ht
             .
             Firstly, this makes it easy to switch to a different hash table implementation,
             and secondly, using a concrete type rather than leaving your functions abstract
             in the HashTable class should allow GHC to optimize away the typeclass
             dictionaries.
             .
             This package accepts a couple of different cabal flags:
             .
             * @unsafe-tricks@, default /ON/. If this flag is enabled, we use some
             unsafe GHC-specific tricks to save indirections (namely @unsafeCoerce#@
             and @reallyUnsafePtrEquality#@. These techniques rely on assumptions
             about the behaviour of the GHC runtime system and, although they've been
             tested and should be safe under normal conditions, are slightly
             dangerous. Caveat emptor. In particular, these techniques are
             incompatible with HPC code coverage reports.
             .
             * @sse41@, default /OFF/. If this flag is enabled, we use some SSE 4.1
             instructions (see <http://en.wikipedia.org/wiki/SSE4>, first available on
             Intel Core 2 processors) to speed up cache-line searches for cuckoo
             hashing.
             .
             * @bounds-checking@, default /OFF/. If this flag is enabled, array accesses
             are bounds-checked.
             .
             * @debug@, default /OFF/. If turned on, we'll rudely spew debug output to
             stdout.
             .
             * @portable@, default /OFF/. If this flag is enabled, we use only pure
             Haskell code and try not to use unportable GHC extensions. Turning this
             flag on forces @unsafe-tricks@ and @sse41@ /OFF/.
             .
             This package has been tested with GHC 7.0.3, on:
             .
             * a MacBook Pro running Snow Leopard with an Intel Core i5 processor,
             running GHC 7.0.3 in 64-bit mode.
             .
             * an Arch Linux desktop with an AMD Phenom II X4 940 quad-core processor.
             .
             * a MacBook Pro running Snow Leopard with an Intel Core 2 Duo processor,
             running GHC 6.12.3 in 32-bit mode.
             .
             Please send bug reports to
             <https://github.com/gregorycollins/hashtables/issues>.
category: Data
author: Gregory Collins
exposed: True
exposed-modules: Data.HashTable.Class Data.HashTable.IO
                 Data.HashTable.ST.Basic Data.HashTable.ST.Cuckoo
                 Data.HashTable.ST.Linear
hidden-modules: Data.HashTable.Internal.Array
                Data.HashTable.Internal.IntArray Data.HashTable.Internal.CacheLine
                Data.HashTable.Internal.CheapPseudoRandomBitStream
                Data.HashTable.Internal.UnsafeTricks Data.HashTable.Internal.Utils
                Data.HashTable.Internal.Linear.Bucket
trusted: False
import-dirs: /usr/lib/haskell-packages/ghc/lib/hashtables-1.0.1.8/ghc-7.6.3
library-dirs: /usr/lib/haskell-packages/ghc/lib/hashtables-1.0.1.8/ghc-7.6.3
hs-libraries: HShashtables-1.0.1.8
extra-libraries:
extra-ghci-libraries:
include-dirs:
includes:
depends: base-4.6.0.1-8aa5d403c45ea59dcd2c39f123e27d57
         ghc-prim-0.3.0.0-d5221a8c8a269b66ab9a07bdc23317dd
         hashable-1.2.1.0-7e83190fbb1b0ba81d7022fa876f0f8b
         primitive-0.5.0.1-8e5f40b409f7bb31ae1acfb125279700
         vector-0.10.0.1-1fbb548bc492f07fef7e604d2e6f581d
hugs-options:
cc-options:
ld-options:
framework-dirs:
frameworks:
haddock-interfaces: /usr/lib/ghc-doc/haddock/hashtables-1.0.1.8/hashtables.haddock
haddock-html: /usr/share/doc/libghc-hashtables-doc/html/