Remove supports_parsing_* and supports_writing_*.

This is a waste of flag space and should be removed prior to any releases.

Author: Alexhuszagh

CHANGELOG

@@ -17,10 +17,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Re-export `NumberFormat` to our other crates (#204).
 - 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 `supports_parsing_integers`, `supports_parsing_floats`, `supports_writing_integers`, and `supports_writing_floats` for our number formats (#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).
 
 ### Changed
 

lexical-parse-float/src/api.rs

@@ -51,9 +51,7 @@ macro_rules! float_from_lexical {
             ) -> lexical_util::result::Result<Self>
             {
                 let format = NumberFormat::<{ FORMAT }> {};
-                if !format.supports_parsing_floats() {
-                    return Err(Error::Unsupported);
-                } else if !format.is_valid() {
+                if !format.is_valid() {
                     return Err(format.error());
                 } else if !is_valid_options_punctuation(FORMAT, options.exponent(), options.decimal_point()) {
                     return Err(Error::InvalidPunctuation);
@@ -68,9 +66,7 @@ macro_rules! float_from_lexical {
             ) -> lexical_util::result::Result<(Self, usize)>
             {
                 let format = NumberFormat::<{ FORMAT }> {};
-                if !format.supports_parsing_floats() {
-                    return Err(Error::Unsupported);
-                } else if !format.is_valid() {
+                if !format.is_valid() {
                     return Err(format.error());
                 } else if !is_valid_options_punctuation(FORMAT, options.exponent(), options.decimal_point()) {
                     return Err(Error::InvalidPunctuation);

lexical-parse-float/tests/api_tests.rs

@@ -1276,38 +1276,6 @@ fn issue68_test() {
     assert_eq!(f64::INFINITY, f64::from_lexical_with_options::<FORMAT>(hex, &OPTIONS).unwrap());
 }
 
-#[test]
-#[cfg(feature = "format")]
-fn unsupported_test() {
-    const FORMAT: u128 = NumberFormatBuilder::new().supports_parsing_floats(false).build_strict();
-    const OPTIONS: Options = Options::new();
-
-    let float = "12345.0";
-    let value = f64::from_lexical_with_options::<FORMAT>(float.as_bytes(), &OPTIONS);
-    assert_eq!(value, Err(Error::Unsupported));
-
-    let value = f64::from_lexical_partial_with_options::<FORMAT>(float.as_bytes(), &OPTIONS);
-    assert_eq!(value, Err(Error::Unsupported));
-}
-
-#[test]
-#[cfg(feature = "format")]
-fn supported_test() {
-    const FORMAT: u128 = NumberFormatBuilder::new()
-        .supports_parsing_integers(false)
-        .supports_writing_integers(false)
-        .supports_writing_floats(false)
-        .build_strict();
-    const OPTIONS: Options = Options::new();
-
-    let float = "12345.0";
-    let value = f64::from_lexical_with_options::<FORMAT>(float.as_bytes(), &OPTIONS);
-    assert_eq!(value, Ok(12345.0));
-
-    let value = f64::from_lexical_partial_with_options::<FORMAT>(float.as_bytes(), &OPTIONS);
-    assert_eq!(value, Ok((12345.0, 7)));
-}
-
 #[test]
 #[cfg(all(feature = "format", feature = "power-of-two"))]
 fn require_base_prefix_test() {

lexical-parse-integer/src/api.rs

@@ -2,7 +2,6 @@
 
 #![doc(hidden)]
 
-use lexical_util::error::Error;
 use lexical_util::format::{NumberFormat, STANDARD};
 use lexical_util::{from_lexical, from_lexical_with_options};
 
@@ -43,9 +42,7 @@ macro_rules! integer_from_lexical {
             ) -> lexical_util::result::Result<Self>
             {
                 let format = NumberFormat::<{ FORMAT }> {};
-                if !format.supports_parsing_integers() {
-                    return Err(Error::Unsupported);
-                } else if !format.is_valid() {
+                if !format.is_valid() {
                     return Err(format.error());
                 }
                 Self::parse_complete::<FORMAT>(bytes, options)
@@ -58,9 +55,7 @@ macro_rules! integer_from_lexical {
             ) -> lexical_util::result::Result<(Self, usize)>
             {
                 let format = NumberFormat::<{ FORMAT }> {};
-                if !format.supports_parsing_integers() {
-                    return Err(Error::Unsupported);
-                } else if !format.is_valid() {
+                if !format.is_valid() {
                     return Err(format.error());
                 }
                 Self::parse_partial::<FORMAT>(bytes, options)

lexical-parse-integer/tests/api_tests.rs

@@ -367,50 +367,6 @@ fn base_prefix_and_suffix_test() {
     assert_eq!(i32::from_lexical_with_options::<FORMAT>(b"+0x", &OPTIONS), Err(Error::Empty(3)));
 }
 
-#[test]
-#[cfg(feature = "format")]
-fn unsupported_test() {
-    const FORMAT: u128 = NumberFormatBuilder::new().supports_parsing_integers(false).build_strict();
-    const OPTIONS: Options = Options::new();
-
-    let integer = "12345";
-    let value = i64::from_lexical_with_options::<FORMAT>(integer.as_bytes(), &OPTIONS);
-    assert_eq!(value, Err(Error::Unsupported));
-
-    let value = i64::from_lexical_partial_with_options::<FORMAT>(integer.as_bytes(), &OPTIONS);
-    assert_eq!(value, Err(Error::Unsupported));
-
-    let value = u64::from_lexical_with_options::<FORMAT>(integer.as_bytes(), &OPTIONS);
-    assert_eq!(value, Err(Error::Unsupported));
-
-    let value = u64::from_lexical_partial_with_options::<FORMAT>(integer.as_bytes(), &OPTIONS);
-    assert_eq!(value, Err(Error::Unsupported));
-}
-
-#[test]
-#[cfg(feature = "format")]
-fn supported_test() {
-    const FORMAT: u128 = NumberFormatBuilder::new()
-        .supports_parsing_floats(false)
-        .supports_writing_integers(false)
-        .supports_writing_floats(false)
-        .build_strict();
-    const OPTIONS: Options = Options::new();
-
-    let integer = "12345";
-    let value = i64::from_lexical_with_options::<FORMAT>(integer.as_bytes(), &OPTIONS);
-    assert_eq!(value, Ok(12345));
-
-    let value = i64::from_lexical_partial_with_options::<FORMAT>(integer.as_bytes(), &OPTIONS);
-    assert_eq!(value, Ok((12345, 5)));
-
-    let value = u64::from_lexical_with_options::<FORMAT>(integer.as_bytes(), &OPTIONS);
-    assert_eq!(value, Ok(12345));
-
-    let value = u64::from_lexical_partial_with_options::<FORMAT>(integer.as_bytes(), &OPTIONS);
-    assert_eq!(value, Ok((12345, 5)));
-}
-
 #[test]
 #[cfg(all(feature = "format", feature = "power-of-two"))]
 fn require_base_prefix_test() {

lexical-util/src/error.rs

@@ -98,8 +98,6 @@ pub enum Error {
     InvalidConsecutiveExponentDigitSeparator,
     /// Invalid flags were set without the format feature.
     InvalidFlags,
-    /// If the operation is unsupported.
-    Unsupported,
 
     // OPTION ERRORS
     /// Invalid NaN string: must start with an `n` character.
@@ -195,7 +193,6 @@ impl Error {
             Self::InvalidConsecutiveFractionDigitSeparator => "'enabled consecutive digit separators in the fraction without setting a valid location'",
             Self::InvalidConsecutiveExponentDigitSeparator => "'enabled consecutive digit separators in the exponent without setting a valid location'",
             Self::InvalidFlags => "'invalid flags enabled without the format feature'",
-            Self::Unsupported => "'the desired operation is unsupported for this format'",
 
             // OPTION ERRORS
             Self::InvalidNanString => "'NaN string must started with `n`'",
@@ -264,7 +261,6 @@ impl Error {
             Self::InvalidConsecutiveFractionDigitSeparator => None,
             Self::InvalidConsecutiveExponentDigitSeparator => None,
             Self::InvalidFlags => None,
-            Self::Unsupported => None,
 
             // OPTION ERRORS
             Self::InvalidNanString => None,
@@ -332,7 +328,6 @@ impl Error {
         InvalidConsecutiveExponentDigitSeparator
     );
     is_error_type!(is_invalid_flags, InvalidFlags);
-    is_error_type!(is_unsupported, Unsupported);
     is_error_type!(is_invalid_nan_string, InvalidNanString);
     is_error_type!(is_nan_string_too_long, NanStringTooLong);
     is_error_type!(is_invalid_inf_string, InvalidInfString);
@@ -435,7 +430,6 @@ impl fmt::Display for Error {
                 format_message!(formatter, description)
             },
             Self::InvalidFlags => format_message!(formatter, description),
-            Self::Unsupported => format_message!(formatter, description),
 
             // OPTION ERRORS
             Self::InvalidNanString => options_message!(formatter, description),

lexical-util/src/feature_format.rs

@@ -755,78 +755,6 @@ impl<const FORMAT: u128> NumberFormat<FORMAT> {
         Self::REQUIRED_MANTISSA_DIGITS_WITH_EXPONENT
     }
 
-    /// If the format supports parsing integers.
-    ///
-    /// See [`supports_parsing_integers`][Self::supports_parsing_integers].
-    pub const SUPPORTS_PARSING_INTEGERS: bool = from_flag!(FORMAT, SUPPORTS_PARSING_INTEGERS);
-
-    /// Get if the format supports parsing integers.
-    ///
-    /// Can only be modified with [`feature`][crate#features] `format`. Defaults
-    /// to [`true`].
-    ///
-    /// # Used For
-    ///
-    /// - Parse Integer
-    #[inline(always)]
-    pub const fn supports_parsing_integers(&self) -> bool {
-        Self::SUPPORTS_PARSING_INTEGERS
-    }
-
-    /// If the format supports parsing floats.
-    ///
-    /// See [`supports_parsing_floats`][Self::supports_parsing_floats].
-    pub const SUPPORTS_PARSING_FLOATS: bool = from_flag!(FORMAT, SUPPORTS_PARSING_FLOATS);
-
-    /// Get if the format supports parsing floats.
-    ///
-    /// Can only be modified with [`feature`][crate#features] `format`. Defaults
-    /// to [`true`].
-    ///
-    /// # Used For
-    ///
-    /// - Parse Float
-    #[inline(always)]
-    pub const fn supports_parsing_floats(&self) -> bool {
-        Self::SUPPORTS_PARSING_FLOATS
-    }
-
-    /// If the format supports writing integers.
-    ///
-    /// See [`supports_writing_integers`][Self::supports_writing_integers].
-    pub const SUPPORTS_WRITING_INTEGERS: bool = from_flag!(FORMAT, SUPPORTS_WRITING_INTEGERS);
-
-    /// Get if the format supports writing integers.
-    ///
-    /// Can only be modified with [`feature`][crate#features] `format`. Defaults
-    /// to [`true`].
-    ///
-    /// # Used For
-    ///
-    /// - Write Integer
-    #[inline(always)]
-    pub const fn supports_writing_integers(&self) -> bool {
-        Self::SUPPORTS_WRITING_INTEGERS
-    }
-
-    /// If the format supports writing floats.
-    ///
-    /// See [`supports_writing_floats`][Self::supports_writing_floats].
-    pub const SUPPORTS_WRITING_FLOATS: bool = from_flag!(FORMAT, SUPPORTS_WRITING_FLOATS);
-
-    /// Get if the format supports writing floats.
-    ///
-    /// Can only be modified with [`feature`][crate#features] `format`. Defaults
-    /// to [`true`].
-    ///
-    /// # Used For
-    ///
-    /// - Write Float
-    #[inline(always)]
-    pub const fn supports_writing_floats(&self) -> bool {
-        Self::SUPPORTS_WRITING_FLOATS
-    }
-
     /// If the format requires base prefixes.
     ///
     /// See [`required_base_prefix`][Self::required_base_prefix].