From 7fa1e34c22f4c5bfa99925560be9c23bb2d6d670 Mon Sep 17 00:00:00 2001
From: John Turner <jturner.usa@gmail.com>
Date: Thu, 20 Nov 2025 23:12:54 +0000
Subject: impl ascii alternatives to alphabetic, numeric and whitespace methods
 and parsers

---
 src/input.rs | 26 +++++++++++++++++++++
 src/lib.rs   | 76 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 102 insertions(+)

(limited to 'src')

diff --git a/src/input.rs b/src/input.rs
index 0857c8c..0b38556 100644
--- a/src/input.rs
+++ b/src/input.rs
@@ -48,22 +48,44 @@ impl<'a> Input for &'a [u8] {
 }
 
 pub trait Character {
+    fn is_ascii(&self) -> bool;
+
     fn is_alphabetic(&self) -> bool;
 
+    fn is_ascii_alphabetic(&self) -> bool;
+
     fn is_numeric(&self) -> bool;
 
+    fn is_ascii_numeric(&self) -> bool {
+        self.is_ascii() && self.is_numeric()
+    }
+
     fn is_whitespace(&self) -> bool;
 
+    fn is_ascii_whitespace(&self) -> bool;
+
     fn is_alphanumeric(&self) -> bool {
         self.is_alphabetic() || self.is_numeric()
     }
+
+    fn is_ascii_alphanumeric(&self) -> bool {
+        self.is_ascii_alphabetic() || self.is_ascii_numeric()
+    }
 }
 
 impl Character for char {
+    fn is_ascii(&self) -> bool {
+        (*self).is_ascii()
+    }
+
     fn is_alphabetic(&self) -> bool {
         (*self).is_ascii_alphabetic()
     }
 
+    fn is_ascii_alphabetic(&self) -> bool {
+        (*self).is_ascii_alphabetic()
+    }
+
     fn is_numeric(&self) -> bool {
         (*self).is_numeric()
     }
@@ -71,6 +93,10 @@ impl Character for char {
     fn is_whitespace(&self) -> bool {
         (*self).is_whitespace()
     }
+
+    fn is_ascii_whitespace(&self) -> bool {
+        (*self).is_ascii_whitespace()
+    }
 }
 
 #[derive(Clone)]
diff --git a/src/lib.rs b/src/lib.rs
index fe9a720..5d6c3d3 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -965,6 +965,14 @@ where
     r#if(|c: &I::Item| c.is_alphabetic())
 }
 
+pub fn ascii_alpha<I>() -> impl Parser<I, Output = I::Item>
+where
+    I: Input,
+    I::Item: Character,
+{
+    r#if(|c: &I::Item| c.is_ascii_alphabetic())
+}
+
 pub fn alpha1<I>() -> impl Parser<I, Output = I>
 where
     I: Input,
@@ -976,6 +984,17 @@ where
         .recognize()
 }
 
+pub fn ascii_alpha1<I>() -> impl Parser<I, Output = I>
+where
+    I: Input,
+    I::Item: Character,
+{
+    r#if(|c: &I::Item| c.is_ascii_alphabetic())
+        .repeated()
+        .at_least(1)
+        .recognize()
+}
+
 pub fn numeric<I>() -> impl Parser<I, Output = I::Item>
 where
     I: Input,
@@ -984,6 +1003,14 @@ where
     r#if(|c: &I::Item| c.is_numeric())
 }
 
+pub fn ascii_numeric<I>() -> impl Parser<I, Output = I::Item>
+where
+    I: Input,
+    I::Item: Character,
+{
+    r#if(|c: &I::Item| c.is_ascii() && c.is_numeric())
+}
+
 pub fn numeric1<I>() -> impl Parser<I, Output = I>
 where
     I: Input,
@@ -995,6 +1022,17 @@ where
         .recognize()
 }
 
+pub fn ascii_numeric1<I>() -> impl Parser<I, Output = I>
+where
+    I: Input,
+    I::Item: Character,
+{
+    r#if(|c: &I::Item| c.is_ascii() && c.is_numeric())
+        .repeated()
+        .at_least(1)
+        .recognize()
+}
+
 pub fn alphanumeric<I>() -> impl Parser<I, Output = I::Item>
 where
     I: Input,
@@ -1003,6 +1041,14 @@ where
     r#if(|c: &I::Item| c.is_alphanumeric())
 }
 
+pub fn ascii_alphanumeric<I>() -> impl Parser<I, Output = I::Item>
+where
+    I: Input,
+    I::Item: Character,
+{
+    r#if(|c: &I::Item| c.is_ascii_alphanumeric())
+}
+
 pub fn alphanumeric1<I>() -> impl Parser<I, Output = I>
 where
     I: Input,
@@ -1014,6 +1060,17 @@ where
         .recognize()
 }
 
+pub fn ascii_alphanumeric1<I>() -> impl Parser<I, Output = I>
+where
+    I: Input,
+    I::Item: Character,
+{
+    r#if(|c: &I::Item| c.is_ascii_alphanumeric())
+        .repeated()
+        .at_least(1)
+        .recognize()
+}
+
 pub fn whitespace<I>() -> impl Parser<I, Output = I::Item>
 where
     I: Input,
@@ -1022,6 +1079,14 @@ where
     r#if(|c: &I::Item| c.is_whitespace())
 }
 
+pub fn ascii_whitespace<I>() -> impl Parser<I, Output = I::Item>
+where
+    I: Input,
+    I::Item: Character,
+{
+    r#if(|c: &I::Item| c.is_ascii_whitespace())
+}
+
 pub fn whitespace1<I>() -> impl Parser<I, Output = I>
 where
     I: Input,
@@ -1033,6 +1098,17 @@ where
         .recognize()
 }
 
+pub fn ascii_whitespace1<I>() -> impl Parser<I, Output = I>
+where
+    I: Input,
+    I::Item: Character,
+{
+    r#if(|c: &I::Item| c.is_ascii_whitespace())
+        .repeated()
+        .at_least(1)
+        .recognize()
+}
+
 pub fn any<I>() -> impl Parser<I, Output = I::Item>
 where
     I: Input,
-- 
cgit v1.2.3