Use hashbrown. Everything was faster, except contains. Not that great that it was contains that was slower, but I think it will be worth it.

Cargo.toml

@@ -4,7 +4,7 @@ version = "0.1.0"
 authors = ["logaritmisk <anders.e.olsson@gmail.com>"]
 
 [dependencies]
-ordermap = "0.4"
+hashbrown = "0.1"
 rayon = "1.0"
 serde = "1.0"
 unreachable = "1.0"

src/hasher.rs

@@ -1,32 +0,0 @@
-use std::default::Default;
-use std::hash::{BuildHasherDefault, Hasher};
-
-use unreachable;
-
-pub struct BitHasher(u64);
-
-impl Default for BitHasher {
-    #[inline]
-    fn default() -> BitHasher {
-        BitHasher(0)
-    }
-}
-
-impl Hasher for BitHasher {
-    #[inline]
-    fn finish(&self) -> u64 {
-        self.0
-    }
-
-    #[inline]
-    fn write(&mut self, _: &[u8]) {
-        unsafe { unreachable::unreachable() };
-    }
-
-    #[inline]
-    fn write_u64(&mut self, i: u64) {
-        *self = BitHasher(i);
-    }
-}
-
-pub type BitBuildHasher = BuildHasherDefault<BitHasher>;

src/lib.rs

@@ -1,26 +1,22 @@
+extern crate hashbrown;
 extern crate rayon;
 extern crate serde;
 extern crate unreachable;
 
-use std::collections::{HashMap, LinkedList};
+use std::collections::LinkedList;
 use std::default::Default;
 use std::fmt;
 use std::iter::{FromIterator, IntoIterator, Iterator};
 use std::ops;
 
+use hashbrown::HashMap;
 use rayon::iter::{FromParallelIterator, IntoParallelIterator, ParallelExtend, ParallelIterator};
 use serde::de::{SeqAccess, Visitor};
 use serde::ser::SerializeSeq;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
-mod hasher;
-
-use hasher::BitBuildHasher;
-
 const BITS: u64 = 64;
 
-pub type BitHashMap<V> = HashMap<u64, V, BitBuildHasher>;
-
 #[inline]
 fn block_bit(x: u64, d: u64) -> (u64, u64) {
     (x / d, x % d)
@@ -28,7 +24,7 @@ fn block_bit(x: u64, d: u64) -> (u64, u64) {
 
 #[derive(PartialEq, Eq, Clone)]
 pub struct BitSet {
-    blocks: HashMap<u64, u64, BitBuildHasher>,
+    blocks: HashMap<u64, u64>,
     nbits: usize,
 }
 
@@ -285,14 +281,14 @@ impl<'a> ops::Sub<&'a BitSet> for &'a BitSet {
 }
 
 pub struct Iter<'a> {
-    iter: std::collections::hash_map::Iter<'a, u64, u64>,
+    iter: hashbrown::hash_map::Iter<'a, u64, u64>,
     block: u64,
     bits: u64,
     bit: u64,
 }
 
 pub struct IntoIter {
-    iter: std::collections::hash_map::IntoIter<u64, u64>,
+    iter: hashbrown::hash_map::IntoIter<u64, u64>,
     block: u64,
     bits: u64,
     bit: u64,