Atomic Bomb

Author: MaxMahem

.gitignore

@@ -0,0 +1 @@
+/target

Cargo.lock

@@ -0,0 +1,9 @@
+[package]
+name = "prefix_parse"
+version = "1.0.0"
+edition = "2024"
+
+[dependencies]
+num-traits = "0.2.19"
+tap = "1.0.1"
+thiserror = "2.0.16"

Cargo.toml

@@ -0,0 +1,49 @@
+# 📦 prefix_parse
+A lightweight Rust crate for parsing numeric strings with radix-indicating prefixes like 0x, 0o, and 0b. It provides a trait-based interface for parsing numbers with standard or custom prefixes, supporting any type that implements [num_traits::Num](https://docs.rs/num-traits/latest/num_traits/trait.Num.html). Which includes all base rust numeric types.
+
+The implementation relies on `[from_str_radix](https://docs.rs/num-traits/0.2.19/num_traits/trait.Num.html#tymethod.from_str_radix)` internally, so the same limitations and capabilities present their apply.
+
+## ✨ Features
+- ✅ Parse hexadecimal (0x), octal (0o), binary (0b), and decimal numbers
+- ✅ Support for custom prefix formats and arbitrary radices
+- ✅ Works with any type implementing Num, including u32, i64, u8, etc.
+
+### Detect common prefixes
+```rust
+use prefix_parse::PrefixParse;
+
+assert_eq!(u32::parse("0x10"), Ok(16));
+assert_eq!(u32::parse("0o10"), Ok(8));
+assert_eq!(u32::parse("0b10"), Ok(2));
+assert_eq!(u32::parse("10"), Ok(10));
+```
+
+### Built-in Prefixes
+```rust
+use prefix_parse::{PrefixParse, HEX, OCT, BIN, DEC};
+
+assert_eq!(u32::parse_with(&HEX, "0xFF"), Ok(255));
+assert_eq!(u32::parse_with(&OCT, "0o77"), Ok(63));
+assert_eq!(u32::parse_with(&BIN, "0b1010"), Ok(10));
+assert_eq!(u32::parse_with(&DEC, "42"), Ok(42));
+```
+
+### Custom Prefixes
+```rust
+use prefix_parse::{PrefixFmt, PrefixParse};
+let base36 = PrefixFmt {
+    prefix: "0z",
+    radix: 36,
+};
+
+assert_eq!(u32::parse_with(&base36, "0z1jz"), Ok(2015));
+```
+
+## 🔧 Extending
+Any new type that implements `Num` from `num_traits` will automatically implement this.
+
+## 📝 License
+MIT or Apache-2.0 — your choice.
+
+## 💬 Feedback
+Contributions welcome!

README.md

@@ -0,0 +1,105 @@
+use num_traits::Num;
+use tap::Pipe;
+
+/// Defines a prefix format.
+#[derive(Debug)]
+pub struct PrefixFmt<'a> {
+    pub prefix: &'a str,
+    pub radix: u32,
+}
+
+/// '0x' prefix for hexadecimal numbers
+pub const HEX: PrefixFmt = PrefixFmt {
+    prefix: "0x",
+    radix: 16,
+};
+/// '0o' prefix for octal numbers
+pub const OCT: PrefixFmt = PrefixFmt {
+    prefix: "0o",
+    radix: 8,
+};
+
+/// '0b' prefix for binary numbers
+pub const BIN: PrefixFmt = PrefixFmt {
+    prefix: "0b",
+    radix: 2,
+};
+
+/// '' prefix for decimal numbers
+pub const DEC: PrefixFmt = PrefixFmt {
+    prefix: "",
+    radix: 10,
+};
+
+/// Trait for parsing prefixed numbers
+pub trait PrefixParse {
+    /// Parse a number prefixed with `0x`, `0o`, and `0b`
+    ///
+    /// # Example
+    /// ```rust
+    /// use prefix_parse::PrefixParse;
+    ///
+    /// assert_eq!(u32::parse("0x10"), Ok(16));
+    /// assert_eq!(u32::parse("0o10"), Ok(8));
+    /// assert_eq!(u32::parse("0b10"), Ok(2));
+    /// assert_eq!(u32::parse("10"), Ok(10));
+    /// ```
+    fn parse(src: &str) -> Result<Self, ParseError<Self>>
+    where
+        Self: Sized + Num,
+    {
+        // SAFETY: if src is a valid UTF-8 string, and we strip no multibyte characters from the start,
+        // then the remaining string will be valid UTF-8
+        match src.as_bytes() {
+            [b'0', b'x', rest @ ..] => {
+                Self::from_str_radix(unsafe { str::from_utf8_unchecked(rest) }, 16)
+                    .map_err(ParseError::RadixParseFailed)
+            }
+            [b'0', b'o', rest @ ..] => {
+                Self::from_str_radix(unsafe { str::from_utf8_unchecked(rest) }, 8)
+                    .map_err(ParseError::RadixParseFailed)
+            }
+            [b'0', b'b', rest @ ..] => {
+                Self::from_str_radix(unsafe { str::from_utf8_unchecked(rest) }, 2)
+                    .map_err(ParseError::RadixParseFailed)
+            }
+            _ => Self::from_str_radix(src, 10).map_err(ParseError::RadixParseFailed),
+        }
+    }
+
+    /// Parse a number with a custom prefix
+    ///
+    /// # Example
+    /// ```
+    /// use prefix_parse::{PrefixParse, ParseError, PrefixFmt, HEX};
+    ///
+    /// assert_eq!(u32::parse_with(&HEX, "0x10"), Ok(16));
+    ///
+    /// let custom_fmt = PrefixFmt {
+    ///     prefix: "0z",
+    ///     radix: 36,
+    /// };
+    /// assert_eq!(u32::parse_with(&custom_fmt, "0z1jz"), Ok(2015));
+    /// ```
+    fn parse_with(fmt: &PrefixFmt, src: &str) -> Result<Self, ParseError<Self>>
+    where
+        Self: Sized + Num,
+    {
+        src.strip_prefix(fmt.prefix)
+            .ok_or(ParseError::NoPrefixMatch)?
+            .pipe(|rest| Self::from_str_radix(rest, fmt.radix))
+            .map_err(ParseError::RadixParseFailed)
+    }
+}
+
+/// Implementation for all number types that implement the `Num` interface.
+impl<T: Num> PrefixParse for T {}
+
+/// Error type for `PrefixParse`
+#[derive(Debug, PartialEq, Eq, thiserror::Error)]
+pub enum ParseError<T: Num> {
+    #[error("No Prefix Match")]
+    NoPrefixMatch,
+    #[error(transparent)]
+    RadixParseFailed(T::FromStrRadixErr),
+}