Crate equivalent
source ·Expand description
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 theHashMap<K, V>
constraintK: Borrow<Q>, Q: Eq
.Q: Comparable<K>
checks the ordering, similar to theBTreeMap<K, V>
constraintK: 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);
}
Traits§
- Key ordering trait.
- Key equivalence trait.