FInally derive Eq for BorrowedValue and OwnedValue and prove it works!

All tests pass with and without - as an intellectual exercise I'm looking at LazyValue too :)

src/value/borrowed.rs

@@ -77,6 +77,7 @@ pub fn to_value_with_buffers<'value>(
 /// Borrowed JSON-DOM Value, consider using the `ValueTrait`
 /// to access its content
 #[derive(Debug, Clone)]
+#[cfg_attr(feature = "ordered-float", derive(Eq))]
 pub enum Value<'value> {
     /// Static values
     Static(StaticNode),

src/value/owned.rs

@@ -74,6 +74,7 @@ pub fn to_value_with_buffers(s: &mut [u8], buffers: &mut Buffers) -> Result<Valu
 /// This is slower then the `BorrowedValue` as a tradeoff
 /// for getting rid of lifetimes.
 #[derive(Debug, Clone)]
+#[cfg_attr(feature = "ordered-float", derive(Eq))]
 pub enum Value {
     /// Static values
     Static(StaticNode),

tests/ordered_float.rs

@@ -0,0 +1,26 @@
+// A small test to show that ordered-float does allow us to "do stuff" Eq-wise
+// with values when we opt for an Eq-compatible representation of floats.
+// Easiest way is simply to construct a type that derives Eq and include
+// simd Values in it, construct it, and compare it! This won't even compile 
+// if we have got it wrong
+#[cfg(feature = "ordered-float")]
+use simd_json::{BorrowedValue, OwnedValue};
+
+#[cfg(feature = "ordered-float")]
+#[test]
+fn test_values_as_hashmap_keys() {
+	#[derive(Eq, PartialEq, Debug)]
+	struct AnEqType {
+		owned_value: OwnedValue,
+		borrowed_value: BorrowedValue<'static>
+	}
+	let an_eq_type = AnEqType {
+		owned_value: OwnedValue::from("an-owned-value"),
+		borrowed_value: BorrowedValue::from("a-borrowed-value")
+	};
+
+	assert_eq!(an_eq_type, AnEqType {
+		owned_value: OwnedValue::from("an-owned-value"),
+		borrowed_value: BorrowedValue::from("a-borrowed-value")
+	});
+}