Support RangeBounds for T: Comparable

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "equivalent"
-version = "1.0.1"
-rust-version = "1.6"
+version = "1.1.0"
+rust-version = "1.28"
 license = "Apache-2.0 OR MIT"
 description = "Traits for key comparison in maps."
 repository = "https://github.com/cuviper/equivalent"

src/lib.rs

@@ -56,13 +56,19 @@
 //!     assert_eq!(q1.compare(&key), Ordering::Equal);
 //!     assert_eq!(q2.compare(&key), Ordering::Less);
 //!     assert_eq!(q3.compare(&key), Ordering::Greater);
+//!
+//!     // You cannot do this with the `RangeBounds::contains` method.
+//!     // assert!((q1..q3).contains(key));
+//!     // But you can do this with the `ComparableRangeBounds::compare_contains` method.
+//!     assert!((q1..q3).compare_contains(&key));
 //! }
 //! ```
 
 #![no_std]
 
 use core::borrow::Borrow;
 use core::cmp::Ordering;
+use core::ops::{Bound, RangeBounds};
 
 /// Key equivalence trait.
 ///
@@ -111,3 +117,35 @@ where
         Ord::cmp(self, key.borrow())
     }
 }
+
+/// `ComparableRangeBounds` is implemented as an extention to `RangeBounds` to
+/// allow for comparison of items with range bounds.
+pub trait ComparableRangeBounds<Q: ?Sized>: RangeBounds<Q> {
+    /// Returns `true` if `item` is contained in the range.
+    ///
+    /// # Examples
+    ///
+    /// See the [crate-level documentation](crate).
+    fn compare_contains<K>(&self, item: &K) -> bool
+    where
+        Q: Comparable<K>,
+        K: ?Sized,
+    {
+        (match self.start_bound() {
+            Bound::Included(start) => start.compare(item) != Ordering::Greater,
+            Bound::Excluded(start) => start.compare(item) == Ordering::Less,
+            Bound::Unbounded => true,
+        }) && (match self.end_bound() {
+            Bound::Included(end) => end.compare(item) != Ordering::Less,
+            Bound::Excluded(end) => end.compare(item) == Ordering::Greater,
+            Bound::Unbounded => true,
+        })
+    }
+}
+
+impl<R, T> ComparableRangeBounds<T> for R
+where
+    R: ?Sized + RangeBounds<T>,
+    T: ?Sized,
+{
+}