Add PyItem container

Also reduce queue item trait bound from Ord to just PartialOrd

src/backing/containers/mod.rs

@@ -1,3 +1,5 @@
 mod pair;
+mod py_item;
 
 pub use pair::Pair;
+pub use py_item::PyItem;

src/backing/containers/pair.rs

@@ -1,8 +1,7 @@
 use std::cmp::Ordering;
 
-/// Helper struct to associate an item with its priority
+/// Container to associate an item with a priority
 #[derive(Debug, Clone, Copy)]
-// I mean I guess P should be Ord but I want to use f64 so whatever
 pub struct Pair<D: Clone, P: PartialOrd + Clone> {
     data: D,
     priority: P,
@@ -14,23 +13,13 @@ impl<D: Clone, P: PartialOrd + Clone> Pair<D, P> {
         Self { data, priority }
     }
 
-    /// Retrieve the internal data, it would be nicer to implement this using [`From`] or [`Into`], but I don't see a way to do that using generics
+    /// Retrieves the internal data.
+    /// It would be nicer to implement this using [`From`] or [`Into`], but I don't see a way to do that using generics.
     pub fn data(self) -> D {
         self.data
     }
 }
 
-// The relevant Ord implementations are based just on the priority
-impl<D: Clone, P: PartialOrd + Clone> Ord for Pair<D, P> {
-    fn cmp(&self, other: &Self) -> Ordering {
-        // Yeah this is bad design
-        // My excuse is that i'm still learning Rust
-        self.priority
-            .partial_cmp(&other.priority)
-            .unwrap_or(Ordering::Equal)
-    }
-}
-
 impl<D: Clone, P: PartialOrd + Clone> PartialOrd for Pair<D, P> {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         self.priority.partial_cmp(&other.priority)
@@ -42,5 +31,3 @@ impl<D: Clone, P: PartialOrd + Clone> PartialEq for Pair<D, P> {
         self.priority == other.priority
     }
 }
-
-impl<D: Clone, P: PartialOrd + Clone> Eq for Pair<D, P> {}

src/backing/containers/py_item.rs

@@ -0,0 +1,46 @@
+use std::cmp::Ordering;
+
+use pyo3::prelude::*;
+
+/// Container that provides PartialOrd based on the Python object it holds
+#[derive(Debug, Clone)]
+pub struct PyItem(Py<PyAny>);
+
+impl PyItem {
+    /// Creates a new instance
+    fn new(item: Py<PyAny>) -> Self {
+        PyItem(item)
+    }
+
+    /// Retrieves the internal data
+    fn item(self) -> Py<PyAny> {
+        self.0
+    }
+}
+
+impl PartialOrd for PyItem {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Python::with_gil(|py| {
+            // Bind objects for convenience
+            let ours = self.0.bind(py);
+            let theirs = other.0.bind(py);
+
+            // Compare based on Python comparison implementations
+            match ours.lt(theirs) {
+                Ok(true) => Some(Ordering::Less),
+                Ok(false) => match ours.gt(theirs) {
+                    Ok(true) => Some(Ordering::Greater),
+                    Ok(false) => Some(Ordering::Equal), // If the python class is implemented strangely then this may be wrong
+                    Err(_) => None,
+                },
+                Err(_) => None,
+            }
+        })
+    }
+}
+
+impl PartialEq for PyItem {
+    fn eq(&self, other: &Self) -> bool {
+        Python::with_gil(|py| self.0.bind(py).eq(other.0.bind(py)).unwrap_or(false))
+    }
+}

src/backing/indexed/mod.rs

@@ -2,7 +2,7 @@
 use super::{containers::Pair, pure::PureBacking};
 
 /// A data structure usable for backing an "indexed" queue
-pub trait IndexedBacking<D: Clone + Send + Sync, P: Ord + Clone + Send + Sync>:
+pub trait IndexedBacking<D: Clone + Send + Sync, P: PartialOrd + Clone + Send + Sync>:
     PureBacking<Pair<D, P>>
 {
     /// Update an item's priority

src/backing/pure/binary_heap.rs

@@ -2,12 +2,6 @@ use std::fmt;
 
 use super::PureBacking;
 
-/// A binary min-heap backed by an array
-#[derive(Debug)]
-pub struct BinaryHeap<T: Ord + Clone + Send + Sync> {
-    data: Vec<T>,
-}
-
 /// Indicates why a sift failed
 #[derive(Debug, Clone)]
 struct SiftError {
@@ -33,7 +27,13 @@ impl fmt::Display for SiftError {
 /// Whether a sift operation succeeded
 type SiftResult = Result<(), SiftError>;
 
-impl<T: Ord + Clone + Send + Sync> BinaryHeap<T> {
+/// A binary min-heap backed by an array
+#[derive(Debug)]
+pub struct BinaryHeap<T: PartialOrd + Clone + Send + Sync> {
+    data: Vec<T>,
+}
+
+impl<T: PartialOrd + Clone + Send + Sync> BinaryHeap<T> {
     /// Instantiates a new (empty) binary heap
     pub fn new() -> Self {
         Self { data: vec![] }
@@ -108,7 +108,7 @@ impl<T: Ord + Clone + Send + Sync> BinaryHeap<T> {
     }
 }
 
-impl<T: Ord + Clone + Send + Sync> FromIterator<T> for BinaryHeap<T> {
+impl<T: PartialOrd + Clone + Send + Sync> FromIterator<T> for BinaryHeap<T> {
     fn from_iter<U: IntoIterator<Item = T>>(iter: U) -> Self {
         let mut this = Self {
             data: Vec::from_iter(iter),
@@ -120,7 +120,7 @@ impl<T: Ord + Clone + Send + Sync> FromIterator<T> for BinaryHeap<T> {
     }
 }
 
-impl<T: Ord + Clone + Send + Sync> PureBacking<T> for BinaryHeap<T> {
+impl<T: PartialOrd + Clone + Send + Sync> PureBacking<T> for BinaryHeap<T> {
     fn add(&mut self, item: T) {
         // Append item
         self.data.push(item);

src/backing/pure/mod.rs

@@ -3,7 +3,7 @@ mod binary_heap;
 pub use binary_heap::BinaryHeap;
 
 /// A data structure usable for backing a "pure" queue
-pub trait PureBacking<T: Ord + Send + Sync>: Send + Sync {
+pub trait PureBacking<T: PartialOrd + Send + Sync>: Send + Sync {
     /// Places an item into the queue
     fn add(&mut self, item: T);
     /// Removes the item with minimum priority, if it exists