Add a proper public-facing API with Result etc

Author: aldanor

extras/simple-bench/src/main.rs

@@ -10,7 +10,7 @@ use fastrand::Rng;
 use lexical::FromLexical;
 use structopt::StructOpt;
 
-use fast_float::Float;
+use fast_float::ParseFloat;
 
 use random::RandomGen;
 
@@ -66,7 +66,7 @@ struct BenchResult {
     pub times: Vec<i64>,
 }
 
-fn run_one_bench<T: Float, F: Fn(&str) -> T>(
+fn run_one_bench<T: ParseFloat, F: Fn(&str) -> T>(
     name: &str,
     inputs: &[String],
     repeat: usize,
@@ -87,15 +87,11 @@ fn run_one_bench<T: Float, F: Fn(&str) -> T>(
     BenchResult { name, times }
 }
 
-fn run_all_benches<T: Float + FromLexical + FromStr>(
+fn run_all_benches<T: ParseFloat + FromLexical + FromStr>(
     inputs: &[String],
     repeat: usize,
 ) -> Vec<BenchResult> {
-    let ff_func = |s: &str| {
-        fast_float::parse_float::<T>(s.as_bytes())
-            .unwrap_or_default()
-            .0
-    };
+    let ff_func = |s: &str| fast_float::parse_partial::<T, _>(s).unwrap_or_default().0;
     let ff_res = run_one_bench("fast_float", inputs, repeat, ff_func);
 
     let lex_func = |s: &str| {

src/lib.rs

@@ -1,3 +1,6 @@
+use std::error::Error as StdError;
+use std::fmt::{self, Display};
+
 mod binary;
 mod common;
 mod decimal;
@@ -8,7 +11,70 @@ mod parse;
 mod simple;
 
 pub use format::FloatFormat;
-pub use parse::{parse_float, parse_float_fmt};
 
-#[doc(hidden)]
-pub use float::Float;
+/// Opaque error type for fast-float parsing functions.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct Error;
+
+impl Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "error while parsing a float")
+    }
+}
+
+impl StdError for Error {}
+
+/// Result type alias for fast-float parsing functions.
+pub type Result<T> = std::result::Result<T, Error>;
+
+pub trait ParseFloat: float::Float {
+    #[inline]
+    fn parse_float<S: AsRef<[u8]>>(s: S) -> Result<Self> {
+        Self::parse_float_fmt(s, FloatFormat::default())
+    }
+
+    #[inline]
+    fn parse_float_partial<S: AsRef<[u8]>>(s: S) -> Result<(Self, usize)> {
+        Self::parse_float_partial_fmt(s, FloatFormat::default())
+    }
+
+    #[inline]
+    fn parse_float_fmt<S: AsRef<[u8]>>(s: S, fmt: FloatFormat) -> Result<Self> {
+        let s = s.as_ref();
+        match Self::parse_float_partial_fmt(s, fmt) {
+            Ok((v, n)) if n == s.len() => Ok(v),
+            _ => Err(Error),
+        }
+    }
+
+    #[inline]
+    fn parse_float_partial_fmt<S: AsRef<[u8]>>(s: S, fmt: FloatFormat) -> Result<(Self, usize)> {
+        parse::parse_float_fmt(s.as_ref(), fmt).ok_or(Error)
+    }
+}
+
+impl ParseFloat for f32 {}
+impl ParseFloat for f64 {}
+
+#[inline]
+pub fn parse<T: ParseFloat, S: AsRef<[u8]>>(s: S) -> Result<T> {
+    T::parse_float(s)
+}
+
+#[inline]
+pub fn parse_fmt<T: ParseFloat, S: AsRef<[u8]>>(s: S, fmt: FloatFormat) -> Result<T> {
+    T::parse_float_fmt(s, fmt)
+}
+
+#[inline]
+pub fn parse_partial<T: ParseFloat, S: AsRef<[u8]>>(s: S) -> Result<(T, usize)> {
+    T::parse_float_partial(s)
+}
+
+#[inline]
+pub fn parse_partial_fmt<T: ParseFloat, S: AsRef<[u8]>>(
+    s: S,
+    fmt: FloatFormat,
+) -> Result<(T, usize)> {
+    T::parse_float_partial_fmt(s, fmt)
+}

src/parse.rs

@@ -47,8 +47,3 @@ pub fn parse_float_fmt<F: Float>(mut s: &[u8], fmt: FloatFormat) -> Option<(F, u
 
     Some((value, rest))
 }
-
-#[inline]
-pub fn parse_float<F: Float>(s: &[u8]) -> Option<(F, usize)> {
-    parse_float_fmt(s, Default::default())
-}

tests/test_basic.rs

@@ -13,11 +13,9 @@ macro_rules! check {
         check!($ty, $s, <$ty>::NEG_INFINITY)
     }};
     ($ty:ty, $s:expr, $e:expr) => {{
-        // eprintln!("\n\nCHECKING: {:?}", $s);
         let s = $s.as_bytes();
-        let (result, n) = fast_float::parse_float::<$ty>(s).unwrap();
-        assert_eq!(n, s.len());
         let expected: $ty = $e;
+        let result = fast_float::parse::<$ty, _>(s).unwrap();
         assert_eq!(result, expected);
         let lex = lexical_core::parse::<$ty>(s).unwrap();
         assert_eq!(result, lex);
@@ -375,7 +373,7 @@ fn test_f64_pow10() {
     for i in -308..=308 {
         let s = format!("1e{}", i);
         let v = f64::from_str(&s).unwrap();
-        assert_eq!(fast_float::parse_float::<f64>(s.as_bytes()).unwrap().0, v);
+        assert_eq!(fast_float::parse::<f64, _>(s).unwrap(), v);
     }
 }
 
@@ -384,6 +382,6 @@ fn test_f32_pow10() {
     for i in -38..=38 {
         let s = format!("1e{}", i);
         let v = f32::from_str(&s).unwrap();
-        assert_eq!(fast_float::parse_float::<f32>(s.as_bytes()).unwrap().0, v);
+        assert_eq!(fast_float::parse::<f32, _>(s).unwrap(), v);
     }
 }