Implement ToPrimitive 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, Zero};
+use num_traits::{Bounded, Float, FromPrimitive, One, ToPrimitive, Zero};
 
 /// A wrapper around Floats providing an implementation of Ord and Hash.
 ///
@@ -605,6 +605,22 @@ impl<T: Float + FromPrimitive> FromPrimitive for NotNaN<T> {
     fn from_f64(n: f64) -> Option<Self> { T::from_f64(n).and_then(|n| NotNaN::new(n).ok()) }
 }
 
+impl<T: Float + ToPrimitive> ToPrimitive for NotNaN<T> {
+    fn to_i64(&self) -> Option<i64> { self.0.to_i64() }
+    fn to_u64(&self) -> Option<u64> { self.0.to_u64() }
+
+    fn to_isize(&self) -> Option<isize> { self.0.to_isize() }
+    fn to_i8(&self) -> Option<i8> { self.0.to_i8() }
+    fn to_i16(&self) -> Option<i16> { self.0.to_i16() }
+    fn to_i32(&self) -> Option<i32> { self.0.to_i32() }
+    fn to_usize(&self) -> Option<usize> { self.0.to_usize() }
+    fn to_u8(&self) -> Option<u8> { self.0.to_u8() }
+    fn to_u16(&self) -> Option<u16> { self.0.to_u16() }
+    fn to_u32(&self) -> Option<u32> { self.0.to_u32() }
+    fn to_f32(&self) -> Option<f32> { self.0.to_f32() }
+    fn to_f64(&self) -> Option<f64> { self.0.to_f64() }
+}
+
 #[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, Zero};
+pub use num_traits::{Bounded, Float, FromPrimitive, One, ToPrimitive, Zero};
 pub use std::cmp::Ordering::*;
 pub use std::{f32, f64, panic};
 
@@ -137,6 +137,24 @@ describe! not_nan32 {
         assert_eq!(NotNaN::<f32>::from_f32(Float::nan()), None);
         assert_eq!(NotNaN::<f32>::from_f64(Float::nan()), None);
     }
+
+    it "should implement ToPrimitive" {
+        let x = NotNaN::from(42.0f32);
+        assert_eq!(x.to_u8(), Some(42u8));
+        assert_eq!(x.to_i8(), Some(42i8));
+        assert_eq!(x.to_u16(), Some(42u16));
+        assert_eq!(x.to_i16(), Some(42i16));
+        assert_eq!(x.to_u32(), Some(42u32));
+        assert_eq!(x.to_i32(), Some(42i32));
+        assert_eq!(x.to_u64(), Some(42u64));
+        assert_eq!(x.to_i64(), Some(42i64));
+        assert_eq!(x.to_usize(), Some(42usize));
+        assert_eq!(x.to_isize(), Some(42isize));
+        assert_eq!(x.to_f32(), Some(42f32));
+        assert_eq!(x.to_f32(), Some(42f32));
+        assert_eq!(x.to_f64(), Some(42f64));
+        assert_eq!(x.to_f64(), Some(42f64));
+    }
 }
 
 describe! not_nan64 {
@@ -233,6 +251,24 @@ describe! not_nan64 {
         assert_eq!(NotNaN::<f64>::from_f32(Float::nan()), None);
         assert_eq!(NotNaN::<f64>::from_f64(Float::nan()), None);
     }
+
+    it "should implement ToPrimitive" {
+        let x = NotNaN::from(42.0f64);
+        assert_eq!(x.to_u8(), Some(42u8));
+        assert_eq!(x.to_i8(), Some(42i8));
+        assert_eq!(x.to_u16(), Some(42u16));
+        assert_eq!(x.to_i16(), Some(42i16));
+        assert_eq!(x.to_u32(), Some(42u32));
+        assert_eq!(x.to_i32(), Some(42i32));
+        assert_eq!(x.to_u64(), Some(42u64));
+        assert_eq!(x.to_i64(), Some(42i64));
+        assert_eq!(x.to_usize(), Some(42usize));
+        assert_eq!(x.to_isize(), Some(42isize));
+        assert_eq!(x.to_f32(), Some(42f32));
+        assert_eq!(x.to_f32(), Some(42f32));
+        assert_eq!(x.to_f64(), Some(42f64));
+        assert_eq!(x.to_f64(), Some(42f64));
+    }
 }
 
 describe! hashing {