Support RangeBounds for T: Comparable

Author: al8n

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

@@ -63,6 +63,7 @@
 
 use core::borrow::Borrow;
 use core::cmp::Ordering;
+use core::ops::{Bound, RangeBounds};
 
 /// Key equivalence trait.
 ///
@@ -111,3 +112,42 @@ 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<T: ?Sized>: RangeBounds<T> {
+    /// Returns `true` if `item` is contained in the range.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// assert!( (3..5).comparable_contains(&4));
+    /// assert!(!(3..5).comparable_contains(&2));
+    ///
+    /// assert!( (0.0..1.0).comparable_contains(&0.5));
+    /// assert!(!(0.0..1.0).comparable_contains(&f32::NAN));
+    /// assert!(!(0.0..f32::NAN).comparable_contains(&0.5));
+    /// assert!(!(f32::NAN..1.0).comparable_contains(&0.5));
+    /// ```
+    fn comparable_contains<Q>(&self, item: &Q) -> bool
+    where
+        T: Comparable<Q>,
+        Q: ?Sized,
+    {
+        (match self.start_bound() {
+            Bound::Included(start) => {
+                matches!(start.compare(item), Ordering::Less | Ordering::Equal)
+            }
+            Bound::Excluded(start) => start.compare(item) == Ordering::Less,
+            Bound::Unbounded => true,
+        }) && (match self.end_bound() {
+            Bound::Included(end) => {
+                matches!(end.compare(item), Ordering::Greater | Ordering::Equal)
+            }
+            Bound::Excluded(end) => end.compare(item) == Ordering::Greater,
+            Bound::Unbounded => true,
+        })
+    }
+}
+
+impl<R, T: ?Sized> ComparableRangeBounds<T> for R where R: RangeBounds<T> {}