[Equivalent] and [Comparable] are traits for key comparison in maps.

These may be used in the implementation of maps where the lookup type Q may be different than the stored key type K.

• Q: Equivalent<K> checks for equality, similar to the HashMap<K, V> constraint K: Borrow<Q>, Q: Eq.
• Q: Comparable<K> checks the ordering, similar to the BTreeMap<K, V> constraint K: Borrow<Q>, Q: Ord.

These traits are not used by the maps in the standard library, but they may add more flexibility in third-party map implementations, especially in situations where a strict K: Borrow<Q> relationship is not available.

Examples

use equivalent::*;
use std::cmp::Ordering;

pub struct Pair<A, B>(pub A, pub B);

impl<'a, A: ?Sized, B: ?Sized, C, D> Equivalent<(C, D)> for Pair<&'a A, &'a B>
where
A: Equivalent<C>,
B: Equivalent<D>,
{
fn equivalent(&self, key: &(C, D)) -> bool {
self.0.equivalent(&key.0) && self.1.equivalent(&key.1)
}
}

impl<'a, A: ?Sized, B: ?Sized, C, D> Comparable<(C, D)> for Pair<&'a A, &'a B>
where
A: Comparable<C>,
B: Comparable<D>,
{
fn compare(&self, key: &(C, D)) -> Ordering {
match self.0.compare(&key.0) {
Ordering::Equal => self.1.compare(&key.1),
not_equal => not_equal,
}
}
}

fn main() {
let key = (String::from("foo"), String::from("bar"));
let q1 = Pair("foo", "bar");
let q2 = Pair("boo", "bar");
let q3 = Pair("foo", "baz");

assert!(q1.equivalent(&key));
assert!(!q2.equivalent(&key));
assert!(!q3.equivalent(&key));

assert_eq!(q1.compare(&key), Ordering::Equal);
assert_eq!(q2.compare(&key), Ordering::Less);
assert_eq!(q3.compare(&key), Ordering::Greater);
}