Abstract key lookup into a trait, so that it can be extended

Note: It's a type inference break for the case of ``.remove(&&K)`` which
previously compiled (due to deref coercion?)

benches/bench.rs

@@ -557,7 +557,7 @@ fn remove_ordermap_100_000(b: &mut Bencher) {
     b.iter(|| {
         let mut map = map.clone();
         for key in &keys {
-            map.remove(&key).is_some();
+            map.remove(key).is_some();
         }
         assert_eq!(map.len(), 0);
         map

src/equivalent.rs

@@ -0,0 +1,27 @@
+
+use std::borrow::Borrow;
+
+/// Key equivalence trait.
+///
+/// This trait allows hash table lookup to be customized.
+/// It has one blanket implementation that uses the regular `Borrow` solution,
+/// just like `HashMap` and `BTreeMap` do, so that you can pass `&str` to lookup
+/// into a map with `String` keys and so on.
+///
+/// # Contract
+///
+/// The implementor must hash like `K`, if applicable.
+pub trait Equivalent<K> {
+    /// Compare self to `key` and return `true` if they are equal.
+    fn equivalent(&self, key: &K) -> bool;
+}
+
+impl<Q: ?Sized, K> Equivalent<K> for Q
+    where Q: Eq,
+          K: Borrow<Q>,
+{
+    #[inline]
+    fn equivalent(&self, key: &K) -> bool {
+        *self == *key.borrow()
+    }
+}

src/lib.rs

@@ -5,12 +5,12 @@ mod macros;
 #[cfg(feature = "serde-1")]
 mod serde;
 mod util;
+mod equivalent;
 
 use std::hash::Hash;
 use std::hash::BuildHasher;
 use std::hash::Hasher;
 use std::collections::hash_map::RandomState;
-use std::borrow::Borrow;
 use std::ops::RangeFull;
 
 use std::cmp::{max, Ordering};
@@ -19,6 +19,7 @@ use std::mem::{replace};
 use std::marker::PhantomData;
 
 use util::{second, ptrdistance, enumerate};
+pub use equivalent::Equivalent;
 
 fn hash_elem_using<B: BuildHasher, K: ?Sized + Hash>(build: &B, k: &K) -> HashValue {
     let mut h = build.build_hasher();
@@ -824,8 +825,7 @@ impl<K, V, S> OrderMap<K, V, S>
     ///
     /// Computes in **O(1)** time (average).
     pub fn contains_key<Q: ?Sized>(&self, key: &Q) -> bool
-        where K: Borrow<Q>,
-              Q: Eq + Hash,
+        where Q: Hash + Equivalent<K>,
     {
         self.find(key).is_some()
     }
@@ -835,15 +835,13 @@ impl<K, V, S> OrderMap<K, V, S>
     ///
     /// Computes in **O(1)** time (average).
     pub fn get<Q: ?Sized>(&self, key: &Q) -> Option<&V>
-        where K: Borrow<Q>,
-              Q: Eq + Hash,
+        where Q: Hash + Equivalent<K>,
     {
         self.get_pair(key).map(second)
     }
 
     pub fn get_pair<Q: ?Sized>(&self, key: &Q) -> Option<(&K, &V)>
-        where K: Borrow<Q>,
-              Q: Eq + Hash,
+        where Q: Hash + Equivalent<K>,
     {
         if let Some((_, found)) = self.find(key) {
             let entry = &self.entries[found];
@@ -855,8 +853,7 @@ impl<K, V, S> OrderMap<K, V, S>
 
     /// Return item index, key and value
     pub fn get_pair_index<Q: ?Sized>(&self, key: &Q) -> Option<(usize, &K, &V)>
-        where K: Borrow<Q>,
-              Q: Eq + Hash,
+        where Q: Hash + Equivalent<K>,
     {
         if let Some((_, found)) = self.find(key) {
             let entry = &self.entries[found];
@@ -867,16 +864,14 @@ impl<K, V, S> OrderMap<K, V, S>
     }
 
     pub fn get_mut<Q: ?Sized>(&mut self, key: &Q) -> Option<&mut V>
-        where K: Borrow<Q>,
-              Q: Eq + Hash,
+        where Q: Hash + Equivalent<K>,
     {
         self.get_pair_mut(key).map(second)
     }
 
     pub fn get_pair_mut<Q: ?Sized>(&mut self, key: &Q)
         -> Option<(&mut K, &mut V)>
-        where K: Borrow<Q>,
-              Q: Eq + Hash,
+        where Q: Hash + Equivalent<K>,
     {
         if let Some((_, found)) = self.find(key) {
             let entry = &mut self.entries[found];
@@ -888,8 +883,7 @@ impl<K, V, S> OrderMap<K, V, S>
 
     pub fn get_pair_index_mut<Q: ?Sized>(&mut self, key: &Q)
         -> Option<(usize, &mut K, &mut V)>
-        where K: Borrow<Q>,
-              Q: Eq + Hash,
+        where Q: Hash + Equivalent<K>,
     {
         if let Some((_, found)) = self.find(key) {
             let entry = &mut self.entries[found];
@@ -901,12 +895,11 @@ impl<K, V, S> OrderMap<K, V, S>
 
     /// Return probe (indices) and position (entries)
     fn find<Q: ?Sized>(&self, key: &Q) -> Option<(usize, usize)>
-        where K: Borrow<Q>,
-              Q: Eq + Hash,
+        where Q: Hash + Equivalent<K>,
     {
         if self.len() == 0 { return None; }
         let h = hash_elem_using(&self.hash_builder, key);
-        self.find_using(h, move |entry| { *entry.key.borrow() == *key })
+        self.find_using(h, move |entry| { Q::equivalent(key, &entry.key) })
     }
 
     /// Remove the key-value pair equivalent to `key` and return
@@ -920,8 +913,7 @@ impl<K, V, S> OrderMap<K, V, S>
     ///
     /// Computes in **O(1)** time (average).
     pub fn swap_remove<Q: ?Sized>(&mut self, key: &Q) -> Option<V>
-        where K: Borrow<Q>,
-              Q: Eq + Hash,
+        where Q: Hash + Equivalent<K>,
     {
         self.swap_remove_pair(key).map(second)
     }
@@ -930,8 +922,7 @@ impl<K, V, S> OrderMap<K, V, S>
     ///
     /// Computes in **O(1)** time (average).
     pub fn remove<Q: ?Sized>(&mut self, key: &Q) -> Option<V>
-        where K: Borrow<Q>,
-              Q: Eq + Hash,
+        where Q: Hash + Equivalent<K>,
     {
         self.swap_remove(key)
     }
@@ -944,8 +935,7 @@ impl<K, V, S> OrderMap<K, V, S>
     ///
     /// Return `None` if `key` is not in map.
     pub fn swap_remove_pair<Q: ?Sized>(&mut self, key: &Q) -> Option<(K, V)>
-        where K: Borrow<Q>,
-              Q: Eq + Hash,
+        where Q: Hash + Equivalent<K>,
     {
         let (probe, found) = match self.find(key) {
             None => return None,
@@ -1470,9 +1460,8 @@ impl<K, V, S> IntoIterator for OrderMap<K, V, S>
 use std::ops::{Index, IndexMut};
 
 impl<'a, K, V, Q: ?Sized, S> Index<&'a Q> for OrderMap<K, V, S>
-    where K: Eq + Hash,
-          K: Borrow<Q>,
-          Q: Eq + Hash,
+    where Q: Hash + Equivalent<K>,
+          K: Hash + Eq,
           S: BuildHasher,
 {
     type Output = V;
@@ -1492,9 +1481,8 @@ impl<'a, K, V, Q: ?Sized, S> Index<&'a Q> for OrderMap<K, V, S>
 ///
 /// You can **not** insert new pairs with index syntax, use `.insert()`.
 impl<'a, K, V, Q: ?Sized, S> IndexMut<&'a Q> for OrderMap<K, V, S>
-    where K: Eq + Hash,
-          K: Borrow<Q>,
-          Q: Eq + Hash,
+    where Q: Hash + Equivalent<K>,
+          K: Hash + Eq,
           S: BuildHasher,
 {
     /// ***Panics*** if `key` is not present in the map.

tests/equivalent_trait.rs

@@ -0,0 +1,42 @@
+
+#[macro_use] extern crate ordermap;
+
+use ordermap::Equivalent;
+
+use std::hash::Hash;
+
+#[derive(Debug, Hash)]
+pub struct Pair<A, B>(pub A, pub B);
+
+impl<A, B, C, D> PartialEq<(A, B)> for Pair<C, D>
+    where C: PartialEq<A>,
+          D: PartialEq<B>,
+{
+    fn eq(&self, rhs: &(A, B)) -> bool {
+        self.0 == rhs.0 &&
+        self.1 == rhs.1 &&
+        true
+    }
+}
+
+impl<A, B, X> Equivalent<X> for Pair<A, B>
+    where Pair<A, B>: PartialEq<X>,
+          A: Hash + Eq,
+          B: Hash + Eq,
+{
+    fn equivalent(&self, other: &X) -> bool {
+        *self == *other
+    }
+}
+
+#[test]
+fn test_lookup() {
+    let s = String::from;
+    let map = ordermap! {
+        (s("a"), s("b")) => 1,
+        (s("a"), s("x")) => 2,
+    };
+
+    assert!(map.contains_key(&Pair("a", "b")));
+    assert!(!map.contains_key(&Pair("b", "a")));
+}