Fix ordering in the least bad way possible maybe (fixes #38)

Author: udoprog

fixed-map-derive/src/context.rs

@@ -61,8 +61,10 @@ toks! {
         hash_t = [::core::hash::Hash],
         hasher_t = [::core::hash::Hasher],
         into_iterator_t = [::core::iter::IntoIterator],
+        iterator_cmp = [crate::macro_support::__storage_iterator_cmp],
         iterator_flat_map = [::core::iter::FlatMap],
         iterator_flatten = [::core::iter::Flatten],
+        iterator_partial_cmp = [crate::macro_support::__storage_iterator_partial_cmp],
         iterator_t = [::core::iter::Iterator],
         key_t = [crate::key::Key],
         mem = [::core::mem],

fixed-map-derive/src/unit_variants.rs

@@ -19,8 +19,10 @@ pub(crate) fn implement(cx: &Ctxt<'_>, en: &DataEnum) -> Result<TokenStream, ()>
     let hash = cx.toks.hash_t();
     let hasher = cx.toks.hasher_t();
     let into_iterator_t = cx.toks.into_iterator_t();
+    let iterator_cmp = cx.toks.iterator_cmp();
     let iterator_flat_map = cx.toks.iterator_flat_map();
     let iterator_flatten = cx.toks.iterator_flatten();
+    let iterator_partial_cmp = cx.toks.iterator_partial_cmp();
     let iterator_t = cx.toks.iterator_t();
     let key_trait = cx.toks.key_t();
     let mem = cx.toks.mem();
@@ -192,53 +194,15 @@ pub(crate) fn implement(cx: &Ctxt<'_>, en: &DataEnum) -> Result<TokenStream, ()>
             impl<V> #partial_ord_t for Storage<V> where V: #partial_ord_t {
                 #[inline]
                 fn partial_cmp(&self, other: &Self) -> Option<#ordering> {
-                    #partial_ord_t::partial_cmp(&self.data, &other.data)
-                }
-
-                #[inline]
-                fn lt(&self, other: &Self) -> bool {
-                    #partial_ord_t::lt(&self.data, &other.data)
-                }
-
-                #[inline]
-                fn le(&self, other: &Self) -> bool {
-                    #partial_ord_t::le(&self.data, &other.data)
-                }
-
-                #[inline]
-                fn gt(&self, other: &Self) -> bool {
-                    #partial_ord_t::gt(&self.data, &other.data)
-                }
-
-                #[inline]
-                fn ge(&self, other: &Self) -> bool {
-                    #partial_ord_t::ge(&self.data, &other.data)
+                    #iterator_partial_cmp(&self.data, &other.data)
                 }
             }
 
             #[automatically_derived]
             impl<V> #ord_t for Storage<V> where V: #ord_t {
                 #[inline]
                 fn cmp(&self, other: &Self) -> #ordering {
-                    #ord_t::cmp(self, other)
-                }
-
-                #[inline]
-                fn max(self, other: Self) -> Self {
-                    Self { data: #ord_t::max(self.data, other.data) }
-                }
-
-                #[inline]
-                fn min(self, other: Self) -> Self {
-                    Self { data: #ord_t::min(self.data, other.data) }
-                }
-
-                #[inline]
-                fn clamp(self, min: Self, max: Self) -> Self
-                where
-                    Self: #partial_ord_t<Self>
-                {
-                    Self { data: #ord_t::clamp(self.data, min.data, max.data) }
+                    #iterator_cmp(&self.data, &other.data)
                 }
             }
 

src/lib.rs

@@ -347,3 +347,6 @@ pub mod storage;
 #[doc(hidden)]
 #[cfg(feature = "entry")]
 pub mod option_bucket;
+
+#[doc(hidden)]
+pub mod macro_support;

src/macro_support.rs

@@ -0,0 +1,95 @@
+use core::cmp::Ordering;
+
+/// `partial_cmp` implementation for a single `Option<T>` field.
+fn __storage_option_partial_cmp<T>(x: &Option<T>, y: &Option<T>) -> Option<Ordering>
+where
+    T: PartialOrd<T>,
+{
+    match (x, y) {
+        (Some(x), Some(y)) => x.partial_cmp(&y),
+        (None, Some(_)) => Some(Ordering::Greater),
+        (Some(_), None) => Some(Ordering::Less),
+        _ => Some(Ordering::Equal),
+    }
+}
+
+/// `cmp` implementation for a single `Option<T>` field.
+fn __storage_option_cmp<T>(x: &Option<T>, y: &Option<T>) -> Ordering
+where
+    T: Ord,
+{
+    match (x, y) {
+        (Some(x), Some(y)) => x.cmp(&y),
+        (None, Some(_)) => Ordering::Greater,
+        (Some(_), None) => Ordering::Less,
+        _ => Ordering::Equal,
+    }
+}
+
+/// `partial_cmp` implementation over iterators which ensures that storage
+/// ordering between `None` and `Some` is handled in a reasonable manner.
+#[doc(hidden)]
+pub fn __storage_iterator_partial_cmp<T>(a: &[Option<T>], b: &[Option<T>]) -> Option<Ordering>
+where
+    T: PartialOrd<T>,
+{
+    let mut a = a.into_iter();
+    let mut b = b.into_iter();
+
+    loop {
+        let x = match a.next() {
+            None => {
+                if b.next().is_none() {
+                    return Some(Ordering::Equal);
+                } else {
+                    return Some(Ordering::Less);
+                }
+            }
+            Some(x) => x,
+        };
+
+        let y = match b.next() {
+            None => return Some(Ordering::Greater),
+            Some(y) => y,
+        };
+
+        match __storage_option_partial_cmp(x, y) {
+            Some(Ordering::Equal) => (),
+            ordering => return ordering,
+        }
+    }
+}
+
+/// `cmp` implementation over iterators which ensures that storage ordering
+/// between `None` and `Some` is handled in a reasonable manner.
+#[doc(hidden)]
+pub fn __storage_iterator_cmp<T>(a: &[Option<T>], b: &[Option<T>]) -> Ordering
+where
+    T: Ord,
+{
+    let mut a = a.into_iter();
+    let mut b = b.into_iter();
+
+    loop {
+        let x = match a.next() {
+            None => {
+                if b.next().is_none() {
+                    return Ordering::Equal;
+                } else {
+                    return Ordering::Less;
+                }
+            }
+            Some(x) => x,
+        };
+
+        let y = match b.next() {
+            None => return Ordering::Greater,
+            Some(y) => y,
+        };
+
+        match __storage_option_cmp(x, y) {
+            Ordering::Equal => (),
+            ordering => return ordering,
+        }
+    }
+}

src/map.rs

@@ -1105,10 +1105,10 @@ where
 /// let mut b = Map::new();
 /// b.insert(Key::Second, 1);
 ///
-/// assert!(a > b);
-/// assert!(a >= b);
-/// assert!(!(a < b));
-/// assert!(!(a <= b));
+/// assert!(a < b);
+/// assert!(a <= b);
+/// assert!(!(a > b));
+/// assert!(!(a >= b));
 /// ```
 ///
 /// Using a composite key:
@@ -1181,10 +1181,10 @@ where
 /// let mut b = Map::new();
 /// b.insert(Key::Second, 1);
 ///
-/// let mut list = vec![a, b];
+/// let mut list = vec![b, a];
 /// list.sort();
 ///
-/// assert_eq!(list, [b, a]);
+/// assert_eq!(list, [a, b]);
 /// ```
 ///
 /// Using a composite key:

src/set.rs

@@ -662,10 +662,10 @@ where
 /// let mut b = Set::new();
 /// b.insert(Key::Second);
 ///
-/// assert!(a > b);
-/// assert!(a >= b);
-/// assert!(!(a < b));
-/// assert!(!(a <= b));
+/// assert!(a < b);
+/// assert!(a <= b);
+/// assert!(!(a > b));
+/// assert!(!(a >= b));
 /// ```
 ///
 /// Using a composite key:
@@ -738,10 +738,10 @@ where
 /// let mut b = Set::new();
 /// b.insert(Key::Second);
 ///
-/// let mut list = vec![a, b];
+/// let mut list = vec![b, a];
 /// list.sort();
 ///
-/// assert_eq!(list, [b, a]);
+/// assert_eq!(list, [a, b]);
 /// ```
 ///
 /// Using a composite key: