Add additional format versions and enhancements.

CHANGELOG

@@ -15,7 +15,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Added `build_checked` to our `Options` API (#204).
 - Added `has_digit_separator` to `NumberFormat` (#204).
 - Re-export `NumberFormat` to our other crates (#204).
-- Add `Options::from_radix` for all options for similar APIs for each (#208).
+- Added `Options::from_radix` for all options for similar APIs for each (#208).
+- Support for `required_integer_digits_with_exponent`, `required_fraction_digits_with_exponent`, and `required_mantissa_digits_with_exponent`, that is,`1.e5` and `.1e5`, as opposed to just requiring`1e5` (#215).
+- Added `required_base_prefix` and `required_base_suffix` for our number formats, requiring base prefixes and/or suffixes when parsing, and allowing writing base prefixes and/or suffixes (#215).
+- Added `NumberFormatBuilder::none()` for create a format with no flags set (#215).
+- Added in many more digit separator flags for the `NumberFormat`, including for signs, base prefixes, base suffixes, and restricting digit separators at the start of the number (#215).
+- Added many more pre-defined formatting constants (#215).
+- Added additional sign configurations, with `no_unsigned_negative_sign`, `no_mantissa_sign`, and `no_exponent_sign` (#215).
 
 ### Changed
 

extras/benchmark/Cargo.toml

@@ -12,4 +12,3 @@ resolver = "2"
 opt-level = 3
 debug = false
 debug-assertions = false
-lto = true

lexical-parse-float/src/api.rs

@@ -65,6 +65,12 @@ macro_rules! float_from_lexical {
                 options: &Self::Options,
             ) -> lexical_util::result::Result<(Self, usize)>
             {
+                let format = NumberFormat::<{ FORMAT }> {};
+                if !format.is_valid() {
+                    return Err(format.error());
+                } else if !is_valid_options_punctuation(FORMAT, options.exponent(), options.decimal_point()) {
+                    return Err(Error::InvalidPunctuation);
+                }
                 Self::parse_partial::<FORMAT>(bytes, options)
             }
         }

lexical-parse-float/src/binary.rs

@@ -101,7 +101,7 @@ pub fn binary<F: RawFloat, const FORMAT: u128>(num: &Number, lossy: bool) -> Ext
 #[cfg_attr(not(feature = "compact"), inline(always))]
 #[allow(unused_mut)]
 pub fn parse_u64_digits<'a, Iter, const FORMAT: u128>(
-    mut iter: Iter,
+    iter: &mut Iter,
     mantissa: &mut u64,
     step: &mut usize,
     overflowed: &mut bool,
@@ -118,7 +118,7 @@ pub fn parse_u64_digits<'a, Iter, const FORMAT: u128>(
         debug_assert!(radix < 16, "larger radices will wrap on radix^8");
         let radix8 = format.radix8() as u64;
         while *step > 8 {
-            if let Some(v) = algorithm::try_parse_8digits::<u64, _, FORMAT>(&mut iter) {
+            if let Some(v) = algorithm::try_parse_8digits::<u64, _, FORMAT>(iter) {
                 *mantissa = mantissa.wrapping_mul(radix8).wrapping_add(v);
                 *step -= 8;
             } else {
@@ -169,9 +169,10 @@ pub fn slow_binary<F: RawFloat, const FORMAT: u128>(num: Number) -> ExtendedFloa
     // Parse the integer digits.
     let mut step = u64_step(radix);
     let mut integer = num.integer.bytes::<FORMAT>();
-    integer.integer_iter().skip_zeros();
+    let mut integer_iter = integer.integer_iter();
+    integer_iter.skip_zeros();
     parse_u64_digits::<_, FORMAT>(
-        integer.integer_iter(),
+        &mut integer_iter,
         &mut mantissa,
         &mut step,
         &mut overflow,
@@ -181,11 +182,12 @@ pub fn slow_binary<F: RawFloat, const FORMAT: u128>(num: Number) -> ExtendedFloa
     // Parse the fraction digits.
     if let Some(fraction) = num.fraction {
         let mut fraction = fraction.bytes::<FORMAT>();
+        let mut fraction_iter = fraction.fraction_iter();
         if mantissa == 0 {
-            fraction.fraction_iter().skip_zeros();
+            fraction_iter.skip_zeros();
         }
         parse_u64_digits::<_, FORMAT>(
-            fraction.fraction_iter(),
+            &mut fraction_iter,
             &mut mantissa,
             &mut step,
             &mut overflow,

lexical-parse-float/src/lib.rs

@@ -59,7 +59,7 @@
 //! [Comprehensive Configuration]: #comprehensive-configuration
 //!
 //! ```rust
-//! # #[cfg(feature = "radix")] {
+//! # #[cfg(feature = "format")] {
 //! # use core::str;
 //! use lexical_parse_float::{Error, FromLexicalWithOptions, NumberFormatBuilder, Options};
 //!
@@ -78,7 +78,7 @@
 //!
 //! let value = "1.234e+300";
 //! let result = f64::from_lexical_with_options::<FORMAT>(value.as_bytes(), &OPTIONS);
-//! assert_eq!(result, Err(Error::MissingSign(0)));
+//! assert_eq!(result, Err(Error::MissingMantissaSign(0)));
 //! # }
 //! ```
 //!
@@ -132,7 +132,7 @@
 //! }
 //!
 //! assert_eq!(parse_json_float(b"-1"), Ok(-1.0));
-//! assert_eq!(parse_json_float(b"+1"), Err(Error::InvalidPositiveSign(0)));
+//! assert_eq!(parse_json_float(b"+1"), Err(Error::InvalidPositiveMantissaSign(0)));
 //! assert_eq!(parse_json_float(b"1"), Ok(1.0));
 //! assert_eq!(parse_json_float(b"1."), Err(Error::EmptyFraction(2)));
 //! assert_eq!(parse_json_float(b"0.1"), Ok(0.1));
@@ -193,7 +193,7 @@
 //! assert_eq!(value.map(|x| x.is_nan()), Ok(true));
 //!
 //! let value = f64::from_lexical_with_options::<FORMAT>(b"+1_2.3_4", &OPTIONS);
-//! assert_eq!(value, Err(Error::InvalidPositiveSign(0)));
+//! assert_eq!(value, Err(Error::InvalidPositiveMantissaSign(0)));
 //!
 //! let value = f64::from_lexical_with_options::<FORMAT>(b"0.3_4", &OPTIONS);
 //! assert_eq!(value, Ok(0.34));
@@ -566,9 +566,6 @@ mod table_lemire;
 mod table_radix;
 mod table_small;
 
-#[macro_use(parse_sign)]
-extern crate lexical_parse_integer;
-
 // Re-exports
 #[cfg(feature = "f16")]
 pub use lexical_util::bf16::bf16;