Implement Num for NotNaN

Author: f-fr

src/lib.rs

@@ -15,7 +15,7 @@ use std::fmt;
 use std::io;
 use std::mem;
 use unreachable::unreachable;
-use num_traits::{Bounded, Float, FromPrimitive, One, ToPrimitive, Zero};
+use num_traits::{Bounded, Float, FromPrimitive, Num, One, ToPrimitive, Zero};
 
 /// A wrapper around Floats providing an implementation of Ord and Hash.
 ///
@@ -621,6 +621,37 @@ impl<T: Float + ToPrimitive> ToPrimitive for NotNaN<T> {
     fn to_f64(&self) -> Option<f64> { self.0.to_f64() }
 }
 
+/// An error indicating a parse error from a string for `NotNaN`.
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub enum ParseNotNaNError<E> {
+    /// A plain parse error from the underlying float type.
+    ParseFloatError(E),
+    /// The parsed float value resulted in a NaN.
+    IsNaN,
+}
+
+impl<E: fmt::Debug> Error for ParseNotNaNError<E> {
+    fn description(&self) -> &str {
+        return "Error parsing a not-NaN floating point value";
+    }
+}
+
+impl<E: fmt::Debug> fmt::Display for ParseNotNaNError<E> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        <Self as fmt::Debug>::fmt(self, f)
+    }
+}
+
+impl<T: Float + Num> Num for NotNaN<T> {
+    type FromStrRadixErr = ParseNotNaNError<T::FromStrRadixErr>;
+
+    fn from_str_radix(src: &str, radix: u32) -> Result<Self, Self::FromStrRadixErr> {
+        T::from_str_radix(src, radix)
+            .map_err(|err| ParseNotNaNError::ParseFloatError(err))
+            .and_then(|n| NotNaN::new(n).map_err(|_| ParseNotNaNError::IsNaN))
+    }
+}
+
 #[cfg(feature = "serde")]
 mod impl_serde {
     extern crate serde;

tests/test.rs

@@ -5,7 +5,7 @@ extern crate ordered_float;
 extern crate num_traits;
 
 pub use ordered_float::*;
-pub use num_traits::{Bounded, Float, FromPrimitive, One, ToPrimitive, Zero};
+pub use num_traits::{Bounded, Float, FromPrimitive, Num, One, ToPrimitive, Zero};
 pub use std::cmp::Ordering::*;
 pub use std::{f32, f64, panic};
 
@@ -155,6 +155,11 @@ describe! not_nan32 {
         assert_eq!(x.to_f64(), Some(42f64));
         assert_eq!(x.to_f64(), Some(42f64));
     }
+
+    it "should implement Num" {
+        assert_eq!(NotNaN::<f32>::from_str_radix("42.0", 10).unwrap(), NotNaN::from(42.0f32));
+        assert!(NotNaN::<f32>::from_str_radix("NaN", 10).is_err());
+    }
 }
 
 describe! not_nan64 {
@@ -269,6 +274,11 @@ describe! not_nan64 {
         assert_eq!(x.to_f64(), Some(42f64));
         assert_eq!(x.to_f64(), Some(42f64));
     }
+
+    it "should implement Num" {
+        assert_eq!(NotNaN::<f64>::from_str_radix("42.0", 10).unwrap(), NotNaN::from(42.0f64));
+        assert!(NotNaN::<f64>::from_str_radix("NaN", 10).is_err());
+    }
 }
 
 describe! hashing {