1 files changed, 0 insertions, 113 deletions
diff --git a/vendor/equivalent/src/lib.rs b/vendor/equivalent/src/lib.rs
deleted file mode 100644
index 09ba58df..00000000
--- a/vendor/equivalent/src/lib.rs
+++ /dev/null
@@ -1,113 +0,0 @@
-//! [`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);
-//! }
-//! ```
-
-#![no_std]
-
-use core::borrow::Borrow;
-use core::cmp::Ordering;
-
-/// Key equivalence trait.
-///
-/// This trait allows hash table lookup to be customized. It has one blanket
-/// implementation that uses the regular solution with `Borrow` and `Eq`, just
-/// like `HashMap` does, 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 it is hashable.
-pub trait Equivalent<K: ?Sized> {
-    /// Compare self to `key` and return `true` if they are equal.
-    fn equivalent(&self, key: &K) -> bool;
-}
-
-impl<Q: ?Sized, K: ?Sized> Equivalent<K> for Q
-where
-    Q: Eq,
-    K: Borrow<Q>,
-{
-    #[inline]
-    fn equivalent(&self, key: &K) -> bool {
-        PartialEq::eq(self, key.borrow())
-    }
-}
-
-/// Key ordering trait.
-///
-/// This trait allows ordered map lookup to be customized. It has one blanket
-/// implementation that uses the regular solution with `Borrow` and `Ord`, just
-/// like `BTreeMap` does, so that you can pass `&str` to lookup into a map with
-/// `String` keys and so on.
-pub trait Comparable<K: ?Sized>: Equivalent<K> {
-    /// Compare self to `key` and return their ordering.
-    fn compare(&self, key: &K) -> Ordering;
-}
-
-impl<Q: ?Sized, K: ?Sized> Comparable<K> for Q
-where
-    Q: Ord,
-    K: Borrow<Q>,
-{
-    #[inline]
-    fn compare(&self, key: &K) -> Ordering {
-        Ord::cmp(self, key.borrow())
-    }
-}