OrderedFloat and NotNan now implement FromStr

Author: Lucretiel

src/lib.rs

@@ -14,6 +14,8 @@ use core::hash::{Hash, Hasher};
 use core::fmt;
 use core::mem;
 use core::hint::unreachable_unchecked;
+use core::str::FromStr;
+
 use num_traits::{Bounded, Float, FromPrimitive, Num, NumCast, One, Signed, ToPrimitive,
                  Zero};
 
@@ -166,6 +168,23 @@ impl<T: Float> Bounded for OrderedFloat<T> {
     }
 }
 
+impl<T: Float + FromStr> FromStr for OrderedFloat<T> {
+    type Err = T::Err;
+
+    /// Convert a &str to `OrderedFloat`. Returns an error if the string fails to parse.
+    ///
+    /// ```
+    /// use ordered_float::OrderedFloat;
+    ///
+    /// assert!("-10".parse::<OrderedFloat<f32>>().is_ok());
+    /// assert!("abc".parse::<OrderedFloat<f32>>().is_err());
+    /// assert!("NaN".parse::<OrderedFloat<f32>>().is_ok());
+    /// ```
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        T::from_str(s).map(OrderedFloat)
+    }
+}
+
 /// A wrapper around Floats providing an implementation of Ord and Hash.
 ///
 /// A NaN value cannot be stored in this type.
@@ -614,6 +633,26 @@ impl<T: Float> Bounded for NotNan<T> {
     }
 }
 
+impl<T: Float + FromStr> FromStr for NotNan<T> {
+    type Err = ParseNotNanError<T::Err>;
+
+    /// Convert a &str to `NotNan`. Returns an error if the string fails to parse,
+    /// or if the resulting value is NaN
+    ///
+    /// ```
+    /// use ordered_float::NotNan;
+    ///
+    /// assert!("-10".parse::<NotNan<f32>>().is_ok());
+    /// assert!("abc".parse::<NotNan<f32>>().is_err());
+    /// assert!("NaN".parse::<NotNan<f32>>().is_err());
+    /// ```
+    fn from_str(src: &str) -> Result<Self, Self::Err> {
+        src.parse()
+            .map_err(ParseNotNanError::ParseFloatError)
+            .and_then(|f| NotNan::new(f).map_err(|_| ParseNotNanError::IsNaN))
+    }
+}
+
 impl<T: Float + FromPrimitive> FromPrimitive for NotNan<T> {
     fn from_i64(n: i64) -> Option<Self> { T::from_i64(n).and_then(|n| NotNan::new(n).ok()) }
     fn from_u64(n: u64) -> Option<Self> { T::from_u64(n).and_then(|n| NotNan::new(n).ok()) }