Merge pull request #33 from greyblake/float-ord

Float ord

CHANGELOG.md

@@ -1,5 +1,6 @@
 ### v0.3.0 - 2023-??-??
 * Add `finite` validation for float types which checks against NaN and infinity.
+* Enable deriving of `Eq` and `Ord` on float types (if `finite` validation is present)
 
 ### v0.2.0 - 2023-04-13
 

README.md

@@ -231,6 +231,15 @@ The float inner types are: `f32`, `f64`.
 The following traits can be derived for a float-based type:
 `Debug`, `Clone`, `Copy`, `PartialEq`, `PartialOrd`, `FromStr`, `AsRef`, `Into`, `From`, `TryFrom`, `Hash`, `Borrow`, `Display`, `Serialize`, `Deserialize`.
 
+It's also possible to derive `Eq` and `Ord` if the validation rules guarantee that `NaN` is excluded.
+This can be done applying by `finite` validation. For example:
+
+```rust
+#[nutype(validate(finite))]
+#[derive(PartialEq, Eq, PartialOrd, Ord)]
+struct Size(f64);
+```
+
 ## Custom sanitizers
 
 You can set custom sanitizers using the `with` option.

WORKLOG.md

@@ -1,9 +1,9 @@
-## Roadmap
-* JsonSchema: add README, lib docs
-* Use `enum-kind` crate
+## TODO
+* Update to Rust 1.69
 
 ## Tech debt
 * Make individual UI tests possible to opt-out depending on the feature flags.
+* Use `enum-kind` crate
 
 ### TODO Refactor:
 * Refactor parsers
@@ -19,6 +19,11 @@
   * Ord requires PartialOrd
   * Eq requires PartialEq
 
+## Ideas for recipes (docs)
+* Derive Eq and Ord on float based type if `finite` validation is set
+* Validating strings with regex
+
+
 ### Later
 * Support decimals libraries:
   * https://crates.io/crates/rust_decimal
@@ -120,3 +125,14 @@
 * JsonSchema: Add unit tests
 * JsonSchema: UI test
 * Validation with regex
+* JsonSchema: add README, lib docs
+* Implement unit tests for float Ord
+  * Test cmp
+  * Test sort()
+* Implement UI tests for derive(Ord), cover cases:
+  * When finite is not set
+  * When Eq is not derived
+  * When PartialOrd is not derived
+* Prop-based tests for Ord
+* Add note about Eq and Ord on floats in README
+* Update CHANGELOG

dummy/src/main.rs

@@ -1,7 +1,7 @@
 use nutype::nutype;
 use schemars::JsonSchema;
-#[nutype(validate(max = 12.34))]
-#[derive(FromStr, Display, Clone, Copy, Serialize, Deserialize, JsonSchema)]
+#[nutype(validate(finite, max = 12.34))]
+#[derive(FromStr, Display, Clone, Copy, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
 pub struct Dist(f64);
 
 #[nutype(
@@ -27,6 +27,13 @@ lazy_static! {
 #[derive(Debug)]
 pub struct PinCode(String);
 
+#[nutype(
+    new_unchecked
+    validate(finite)
+)]
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
+pub struct Coefficient(f64);
+
 fn main() {
     let dist: Dist = "11.4".parse().unwrap();
     println!("dist = {}", dist.into_inner());
@@ -49,4 +56,12 @@ fn main() {
 
     let pin_result = PinCode::new("1223  ");
     println!("\npin_result = {pin_result:?}\n");
+
+    let k1 = Coefficient::new(0.0).unwrap();
+    let k2 = Coefficient::new(1.21).unwrap();
+    let k3 = Coefficient::new(3.21).unwrap();
+
+    let mut ks = [k3, k1, k2, k1, k3];
+    ks.sort();
+    println!("{ks:?}");
 }

nutype/src/lib.rs

@@ -228,6 +228,17 @@
 //! The following traits can be derived for a float-based type:
 //! `Debug`, `Clone`, `Copy`, `PartialEq`, `PartialOrd`, `FromStr`, `AsRef`, `Into`, `From`, `TryFrom`, `Hash`, `Borrow`, `Display`, `Serialize`, `Deserialize`.
 //!
+//! It's also possible to derive `Eq` and `Ord` if the validation rules guarantee that `NaN` is excluded.
+//! This can be done by applying `finite` validation. For example:
+//!
+//! ```rust
+//! use nutype::nutype;
+//!
+//! #[nutype(validate(finite))]
+//! #[derive(PartialEq, Eq, PartialOrd, Ord)]
+//! struct Size(f64);
+//! ```
+//!
 //! ## Custom sanitizers
 //!
 //! You can set custom sanitizers using the `with` option.

nutype_macros/src/common/models.rs

@@ -216,7 +216,7 @@ pub enum DeriveTrait {
     Normal(NormalDeriveTrait),
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum NormalDeriveTrait {
     // Standard library
     Debug,

nutype_macros/src/float/gen/traits.rs

@@ -35,6 +35,8 @@ enum FloatIrregularTrait {
     AsRef,
     Into,
     From,
+    Eq,
+    Ord,
     TryFrom,
     Borrow,
     Display,
@@ -57,9 +59,11 @@ impl From<FloatDeriveTrait> for FloatGeneratableTrait {
             FloatDeriveTrait::PartialEq => {
                 FloatGeneratableTrait::Transparent(FloatTransparentTrait::PartialEq)
             }
+            FloatDeriveTrait::Eq => FloatGeneratableTrait::Irregular(FloatIrregularTrait::Eq),
             FloatDeriveTrait::PartialOrd => {
                 FloatGeneratableTrait::Transparent(FloatTransparentTrait::PartialOrd)
             }
+            FloatDeriveTrait::Ord => FloatGeneratableTrait::Irregular(FloatIrregularTrait::Ord),
             FloatDeriveTrait::FromStr => {
                 FloatGeneratableTrait::Irregular(FloatIrregularTrait::FromStr)
             }
@@ -161,6 +165,35 @@ fn gen_implemented_traits(
                 inner_type,
                 maybe_error_type_name.as_ref(),
             ),
+            FloatIrregularTrait::Eq => gen_impl_trait_eq(type_name),
+            FloatIrregularTrait::Ord => gen_impl_trait_ord(type_name),
         })
         .collect()
 }
+
+fn gen_impl_trait_eq(type_name: &TypeName) -> TokenStream {
+    quote! {
+        impl ::core::cmp::Eq for #type_name { }
+    }
+}
+
+// The implementation below may panic.
+// Function `partial_cmp` returns `None` only for `NaN` values, but
+// `NaN` values are supposed to be exluded by `finite` validation rule.
+// Without `finite` validation deriving `Ord` is not allowed.
+fn gen_impl_trait_ord(type_name: &TypeName) -> TokenStream {
+    let tp = type_name.to_string();
+    quote! {
+        // Make clippy ignore this manual implementation of Ord even when PartialOrd is derived.
+        #[allow(clippy::derive_ord_xor_partial_ord)]
+        impl ::core::cmp::Ord for #type_name {
+            fn cmp(&self, other: &Self) -> ::core::cmp::Ordering {
+                self.partial_cmp(other)
+                    .unwrap_or_else(|| {
+                        let tp = #tp;
+                        panic!("{tp}::cmp() panicked, because partial_cmp() returned None. Could it be that you're using unsafe {tp}::new_unchecked() ?", tp=tp);
+                    })
+            }
+        }
+    }
+}

nutype_macros/src/float/models.rs

@@ -96,7 +96,9 @@ pub enum FloatDeriveTrait {
     Clone,
     Copy,
     PartialEq,
+    Eq,
     PartialOrd,
+    Ord,
     FromStr,
     AsRef,
     Into,