Try speeding up weeder with a bloom filter

[NorfairKing]

I had this idea last night so I wanted to try it out, but it looks like this isn't actually faster:

Test with these changes:                       
weeder-check> real      0m32.576s
weeder-check> user      0m30.698s
weeder-check> sys       0m1.788s
 
Test without these changes:
weeder-check> real      0m31.765s
weeder-check> user      0m30.047s
weeder-check> sys       0m1.633s

Perhaps this could still work with a better hash function or some more tuning with respect to how the bloom filter is constructed.

@ocharles I figured you might still like to see this, even though the experiment seems to have failed.
Feel free to close this PR

[NorfairKing]

This is definitely not fast, and could be why this approach doesn't work.

[ryndubei]

Could be worth trying the Uniquable instance of Module and OccName to produce hashes.

Note [The Unique of an OccName]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
They are efficient, because FastStrings have unique Int# keys.  We assume
this key is less than 2^24, and indeed FastStrings are allocated keys
sequentially starting at 0.

So we can make a Unique using
        mkUnique ns key  :: Unique
where 'ns' is a Char representing the name space.  This in turn makes it
easy to build an OccEnv.
-}

(or maybe even better: the Uniquable instance of the original Names we derive the declarations from with nameToDeclaration)

[NorfairKing]

I'm about 50% sure I got this backward in some way, so that might be part of the issue as well.

[NorfairKing]

Another idea that might help make this work: We're now using both a hash and non-hash-based way of putting declarations in a set. If we could re-use the hash of a declaration then we would only need to hash it once and compare only the hash.

[TeofilC]

It might be even better to avoid hashing altogether and just use Ints as keys and IntMap/IntSet. (Maybe from the Unique's that @ryndubei mentions)

Then you just need to worry about the string-y values at the boundaries.

HashMap needs to do Eq checks on the unhashed values if the hashes are equal. So, you can get some savings if you can avoid that.

[NorfairKing]

I had this idea last night so I wanted to try it out, but it looks like this isn't actually faster:

The timings are so similar that I'm a bit suspicious about whether anything is happening at all..