Crate equivalent

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);
}

Traits

Comparable

Key ordering trait.

Equivalent

Key equivalence trait.