Swap from fxhash to ahash. Closes #1.

Cargo.toml

@@ -27,7 +27,7 @@ default = ["bitvec"]
 [dependencies]
 bitvec = { version = "1.0.1", optional = true }
 take_mut = { version = "0.2.2", optional = true }
-fxhash = "0.2.1"
 index_vec = "0.1.3"
 splitmut = "0.2.1"
-roaring = { version = "0.10.2", optional = true }
+roaring = { version = "0.10.2", optional = true }
+ahash = "0.8.6"

src/domain.rs

@@ -1,4 +1,4 @@
-use fxhash::FxHashMap as HashMap;
+use ahash::AHashMap;
 use index_vec::{Idx, IndexVec};
 use std::fmt;
 
@@ -9,7 +9,7 @@ use crate::IndexedValue;
 /// Contains a reverse-mapping from `T` to `T::Index` for efficient lookups of indices.
 pub struct IndexedDomain<T: IndexedValue> {
     domain: IndexVec<T::Index, T>,
-    reverse_map: HashMap<T, T::Index>,
+    reverse_map: AHashMap<T, T::Index>,
 }
 
 impl<T: IndexedValue> IndexedDomain<T> {

src/map.rs

@@ -5,20 +5,20 @@ use std::{
     ops::{Index, IndexMut},
 };
 
-use fxhash::FxHashMap;
+use ahash::AHashMap;
 use index_vec::{Idx, IndexVec};
 
 use crate::{
     pointer::{ArcFamily, PointerFamily, RcFamily, RefFamily},
-    IndexedDomain, IndexedValue, ToIndex,
+    FromIndexicalIterator, IndexedDomain, IndexedValue, ToIndex,
 };
 
 /// A mapping from indexed keys to values, implemented sparsely with a hash map.
 ///
 /// This is more memory-efficient than the [`DenseIndexMap`] with a small
 /// number of keys.
 pub struct SparseIndexMap<'a, K: IndexedValue + 'a, V, P: PointerFamily<'a>> {
-    map: FxHashMap<K::Index, V>,
+    map: AHashMap<K::Index, V>,
     domain: P::Pointer<IndexedDomain<K>>,
 }
 
@@ -39,7 +39,7 @@ where
     /// Constructs an empty map within the given domain.
     pub fn new(domain: &P::Pointer<IndexedDomain<K>>) -> Self {
         SparseIndexMap {
-            map: FxHashMap::default(),
+            map: AHashMap::default(),
             domain: domain.clone(),
         }
     }
@@ -97,6 +97,18 @@ where
         let idx = key.to_index(&self.domain);
         self.map.entry(idx)
     }
+
+    /// Returns the number of entries in the map.
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.map.len()
+    }
+
+    /// Returns true if the map has no elements.
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.map.is_empty()
+    }
 }
 
 impl<'a, K, V, P> Index<K::Index> for SparseIndexMap<'a, K, V, P>
@@ -121,6 +133,40 @@ where
     }
 }
 
+impl<'a, K, V, P, M, U> FromIndexicalIterator<'a, K, P, M, (U, V)> for SparseIndexMap<'a, K, V, P>
+where
+    K: IndexedValue + 'a,
+    P: PointerFamily<'a>,
+    U: ToIndex<K, M>,
+{
+    fn from_indexical_iter(
+        iter: impl Iterator<Item = (U, V)>,
+        domain: &P::Pointer<IndexedDomain<K>>,
+    ) -> Self {
+        let map = iter
+            .map(|(u, v)| (u.to_index(domain), v))
+            .collect::<AHashMap<_, _>>();
+        SparseIndexMap {
+            map,
+            domain: domain.clone(),
+        }
+    }
+}
+
+impl<'a, 'b, K, V, P> IntoIterator for &'b SparseIndexMap<'a, K, V, P>
+where
+    K: IndexedValue + 'a + 'b,
+    V: 'b,
+    P: PointerFamily<'a>,
+{
+    type Item = (&'b K::Index, &'b V);
+    type IntoIter = hash_map::Iter<'b, K::Index, V>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.map.iter()
+    }
+}
+
 /// A mapping from indexed keys to values, implemented densely with a vector.
 ///
 /// This is more time-efficient than the [`SparseIndexMap`] for lookup,
@@ -147,8 +193,13 @@ where
     /// Constructs a new map with an initial element of `mk_elem(i)` for each `i` in `domain`.
     #[inline]
     pub fn new(domain: &P::Pointer<IndexedDomain<K>>, mk_elem: impl FnMut(K::Index) -> V) -> Self {
+        Self::from_vec(domain, IndexVec::from_iter(domain.indices().map(mk_elem)))
+    }
+
+    #[inline]
+    fn from_vec(domain: &P::Pointer<IndexedDomain<K>>, map: IndexVec<K::Index, V>) -> Self {
         DenseIndexMap {
-            map: IndexVec::from_iter(domain.indices().map(mk_elem)),
+            map,
             domain: domain.clone(),
         }
     }
@@ -224,3 +275,24 @@ where
         self.get_mut(index).unwrap()
     }
 }
+
+impl<'a, K, V, P, M, U> FromIndexicalIterator<'a, K, P, M, (U, V)> for DenseIndexMap<'a, K, V, P>
+where
+    K: IndexedValue + 'a,
+    P: PointerFamily<'a>,
+    U: ToIndex<K, M>,
+{
+    fn from_indexical_iter(
+        iter: impl Iterator<Item = (U, V)>,
+        domain: &P::Pointer<IndexedDomain<K>>,
+    ) -> Self {
+        let mut map = iter
+            .map(|(u, v)| (u.to_index(domain), v))
+            .collect::<AHashMap<_, _>>();
+        let vec = domain
+            .indices()
+            .map(|i| map.remove(&i).unwrap_or_else(|| panic!("Cannot use FromIndexicalIterator for a DenseIndexMap with a sparse key set")))
+            .collect::<IndexVec<_, _>>();
+        DenseIndexMap::from_vec(domain, vec)
+    }
+}

src/matrix.rs

@@ -1,4 +1,4 @@
-use fxhash::FxHashMap;
+use ahash::AHashMap;
 use splitmut::SplitMut;
 use std::{fmt, hash::Hash};
 
@@ -12,7 +12,7 @@ use crate::{
 /// "Sparse" means "hash map from rows to bit-sets of columns". Subsequently, only column types `C` must be indexed,
 /// while row types `R` only need be hashable.
 pub struct IndexMatrix<'a, R, C: IndexedValue + 'a, S: BitSet, P: PointerFamily<'a>> {
-    pub(crate) matrix: FxHashMap<R, IndexSet<'a, C, S, P>>,
+    pub(crate) matrix: AHashMap<R, IndexSet<'a, C, S, P>>,
     empty_set: IndexSet<'a, C, S, P>,
     col_domain: P::Pointer<IndexedDomain<C>>,
 }
@@ -27,7 +27,7 @@ where
     /// Creates an empty matrix.
     pub fn new(col_domain: &P::Pointer<IndexedDomain<C>>) -> Self {
         IndexMatrix {
-            matrix: FxHashMap::default(),
+            matrix: AHashMap::default(),
             empty_set: IndexSet::new(col_domain),
             col_domain: col_domain.clone(),
         }