Convert Ascii into an enum.

Allows static initialization, nicer pattern matches and comparisons.

Naming conventions:

* alphabetic: just use it. breaks CamelCase convention, but worth it for simplicity.
* digits: prepend _ to make them valid identifiers, but still short.
* non-alphanumeric but visible: Use Wikipedia names CamelCased, but remove -Mark endings.
* rarely used control codes: use uppercase acronym to deter use.
* more commonly used control codes: Expand and CamelCase acronym to preserve meaning, eg LineFeed not NewLine or LineBreak.

I'm not certain which control codes should be expanded; Currently BEL and DEL are, but should they?

I'm not sure whether this is a breaking change.

Author: tormol

src/ascii.rs

@@ -1,11 +1,143 @@
+use std::mem::transmute;
 use std::fmt;
 use std::ascii::AsciiExt;
 
 use AsciiCast;
 
+#[allow(non_camel_case_types)]
 /// Datatype to hold one ascii character. It wraps a `u8`, with the highest bit always zero.
 #[derive(Clone, PartialEq, PartialOrd, Ord, Eq, Hash, Copy)]
-pub struct Ascii { chr: u8 }
+#[repr(u8)]
+pub enum Ascii {
+	NUL             =   0,
+	SOH             =   1,
+	SOX             =   2,
+	ETX             =   3,
+	EOT             =   4,
+	ENQ             =   5,
+	ACK             =   6,
+	Bell            =   7,
+	BackSpace       =   8,
+	Tab             =   9,
+	LineFeed        =  10,
+	VT              =  11,
+	FF              =  12,
+	CarriageReturn  =  13,
+	SI              =  14,
+	SO              =  15,
+	DLE             =  16,
+	DC1             =  17,
+	DC2             =  18,
+	DC3             =  19,
+	DC4             =  20,
+	NAK             =  21,
+	SYN             =  22,
+	ETB             =  23,
+	CAN             =  24,
+	EM              =  25,
+	SUB             =  26,
+	Escape          =  27,
+	FS              =  28,
+	GS              =  29,
+	RS              =  30,
+	US              =  31,
+	Space           =  32,
+	Exclamation     =  33,
+	Quotation       =  34,
+	Hash            =  35,
+	Dollar          =  36,
+	Percent         =  37,
+	Ampersand       =  38,
+	Apostrophe      =  39,
+	ParenOpen       =  40,
+	ParenClose      =  41,
+	Asterisk        =  42,
+	Plus            =  43,
+	Comma           =  44,
+	Minus           =  45,
+	Dot             =  46,
+	Slash           =  47,
+	_0              =  48,
+	_1              =  49,
+	_2              =  50,
+	_3              =  51,
+	_4              =  52,
+	_5              =  53,
+	_6              =  54,
+	_7              =  55,
+	_8              =  56,
+	_9              =  57,
+	Colon           =  58,
+	SemiColon       =  59,
+	LessThan        =  60,
+	Equal           =  61,
+	GreaterThan     =  62,
+	Question        =  63,
+	At              =  64,
+	A               =  65,
+	B               =  66,
+	C               =  67,
+	D               =  68,
+	E               =  69,
+	F               =  70,
+	G               =  71,
+	H               =  72,
+	I               =  73,
+	J               =  74,
+	K               =  75,
+	L               =  76,
+	M               =  77,
+	N               =  78,
+	O               =  79,
+	P               =  80,
+	Q               =  81,
+	R               =  82,
+	S               =  83,
+	T               =  84,
+	U               =  85,
+	V               =  86,
+	W               =  87,
+	X               =  88,
+	Y               =  89,
+	Z               =  90,
+	BracketOpen     =  91,
+	BackSlash       =  92,
+	BracketClose    =  93,
+	Caret           =  94,
+	UnderScore      =  95,
+	Grave           =  96,
+	a               =  97,
+	b               =  98,
+	c               =  99,
+	d               = 100,
+	e               = 101,
+	f               = 102,
+	g               = 103,
+	h               = 104,
+	i               = 105,
+	j               = 106,
+	k               = 107,
+	l               = 108,
+	m               = 109,
+	n               = 110,
+	o               = 111,
+	p               = 112,
+	q               = 113,
+	r               = 114,
+	s               = 115,
+	t               = 116,
+	u               = 117,
+	v               = 118,
+	w               = 119,
+	x               = 120,
+	y               = 121,
+	z               = 122,
+	CurlyBraceOpen  = 123,
+	VerticalBar     = 124,
+	CurlyBraceClose = 125,
+	Tilde           = 126,
+	Delete          = 127,
+}
 
 impl Ascii {
     /// Constructs an Ascii character from a `char`.
@@ -23,7 +155,7 @@ impl Ascii {
     #[inline]
     pub fn from(ch: char) -> Result<Ascii, ()> {
         if ch as u32 <= 0x7F {
-            return Ok( Ascii { chr: ch as u8 });
+            return Ok(unsafe{ ch.to_ascii_nocheck() });
         }
         Err(())
     }
@@ -44,35 +176,36 @@ impl Ascii {
     #[inline]
     pub fn from_byte(ch: u8) -> Result<Ascii, ()> {
         if ch <= 0x7F {
-            return Ok( Ascii { chr: ch });
+            return Ok(unsafe{ ch.to_ascii_nocheck() });
         }
         Err(())
     }
 
     /// Converts an ascii character into a `u8`.
     #[inline]
     pub fn as_byte(&self) -> u8 {
-        self.chr
+        unsafe{ transmute(*self) }
     }
 
     /// Converts an ascii character into a `char`.
     #[inline]
     pub fn as_char(&self) -> char {
-        self.chr as char
+        self.as_byte() as char
     }
 
     // the following methods are like ctype, and the implementation is inspired by musl
 
     /// Check if the character is a letter (a-z, A-Z)
     #[inline]
     pub fn is_alphabetic(&self) -> bool {
-        (self.chr >= 0x41 && self.chr <= 0x5A) || (self.chr >= 0x61 && self.chr <= 0x7A)
+        (self >= &Ascii::a && self <= &Ascii::z) ||
+        (self >= &Ascii::A && self <= &Ascii::Z)
     }
 
     /// Check if the character is a number (0-9)
     #[inline]
     pub fn is_digit(&self) -> bool {
-        self.chr >= 0x30 && self.chr <= 0x39
+        self >= &Ascii::_0 && self <= &Ascii::_9
     }
 
     /// Check if the character is a letter or number
@@ -84,37 +217,37 @@ impl Ascii {
     /// Check if the character is a space or horizontal tab
     #[inline]
     pub fn is_blank(&self) -> bool {
-        self.chr == b' ' || self.chr == b'\t'
+        *self == Ascii::Space || *self == Ascii::Tab
     }
 
     /// Check if the character is a control character
     #[inline]
     pub fn is_control(&self) -> bool {
-        self.chr < 0x20 || self.chr == 0x7F
+        self.as_byte() < 0x20 || *self == Ascii::Delete
     }
 
     /// Checks if the character is printable (except space)
     #[inline]
     pub fn is_graph(&self) -> bool {
-        (self.chr - 0x21) < 0x5E
+        (self.as_byte() - 0x21) < 0x5E
     }
 
     /// Checks if the character is printable (including space)
     #[inline]
     pub fn is_print(&self) -> bool {
-        (self.chr - 0x20) < 0x5F
+        (self.as_byte() - 0x20) < 0x5F
     }
 
     /// Checks if the character is alphabetic and lowercase
     #[inline]
     pub fn is_lowercase(&self) -> bool {
-        (self.chr - b'a') < 26
+        (self.as_byte() - b'a') < 26
     }
 
     /// Checks if the character is alphabetic and uppercase
     #[inline]
     pub fn is_uppercase(&self) -> bool {
-        (self.chr - b'A') < 26
+        (self.as_byte() - b'A') < 26
     }
 
     /// Checks if the character is punctuation
@@ -126,7 +259,7 @@ impl Ascii {
     /// Checks if the character is a valid hex digit
     #[inline]
     pub fn is_hex(&self) -> bool {
-        self.is_digit() || ((self.chr | 32u8) - b'a') < 6
+        self.is_digit() || ((self.as_byte() | 32u8) - b'a') < 6
     }
 }
 
@@ -152,25 +285,25 @@ impl AsciiExt for Ascii {
     }
 
     fn to_ascii_uppercase(&self) -> Ascii {
-        Ascii{chr: self.chr.to_ascii_uppercase()}
+        unsafe{ self.as_byte().to_ascii_uppercase().to_ascii_nocheck() }
     }
 
     fn to_ascii_lowercase(&self) -> Ascii {
-        Ascii{chr: self.chr.to_ascii_lowercase()}
+        unsafe{ self.as_byte().to_ascii_uppercase().to_ascii_nocheck() }
     }
 
     fn eq_ignore_ascii_case(&self, other: &Self) -> bool {
-        self.chr.eq_ignore_ascii_case(&other.chr)
+        self.as_byte().eq_ignore_ascii_case(&other.as_byte())
     }
 
     #[inline]
     fn make_ascii_uppercase(&mut self) {
-        self.chr.make_ascii_uppercase()
+        *self = self.to_ascii_uppercase();
     }
 
     #[inline]
     fn make_ascii_lowercase(&mut self) {
-        self.chr.make_ascii_lowercase()
+        *self = self.to_ascii_lowercase();
     }
 }
 
@@ -179,7 +312,7 @@ impl<'a> AsciiCast<'a> for u8 {
 
     #[inline]
     unsafe fn to_ascii_nocheck(&self) -> Ascii {
-        Ascii{ chr: *self }
+        transmute(*self)
     }
 }
 
@@ -188,7 +321,7 @@ impl<'a> AsciiCast<'a> for char {
 
     #[inline]
     unsafe fn to_ascii_nocheck(&self) -> Ascii {
-        Ascii{ chr: *self as u8 }
+        (*self as u8).to_ascii_nocheck()
     }
 }
 
@@ -199,10 +332,10 @@ mod tests {
 
     #[test]
     fn to_ascii() {
-        assert_eq!(65_u8.to_ascii(), Ok(Ascii { chr: 65_u8 }));
+        assert_eq!(65_u8.to_ascii(), Ok(Ascii::A));
         assert_eq!(255_u8.to_ascii(), Err(()));
 
-        assert_eq!('A'.to_ascii(), Ok(Ascii { chr: 65_u8 }));
+        assert_eq!('A'.to_ascii(), Ok(Ascii::A));
         assert_eq!('λ'.to_ascii(), Err(()));
     }
 
@@ -235,13 +368,11 @@ mod tests {
 
     #[test]
     fn fmt_display_ascii() {
-        let s = Ascii { chr: b't' };
-        assert_eq!(format!("{}", s), "t".to_string());
+        assert_eq!(format!("{}", Ascii::t), "t".to_string());
     }
 
     #[test]
     fn fmt_debug_ascii() {
-        let c = Ascii { chr: b't' };
-        assert_eq!(format!("{:?}", c), "'t'".to_string());
+        assert_eq!(format!("{:?}", Ascii::t), "'t'".to_string());
     }
 }