#[repr(u8)]pub enum Char {
Show 128 variants
Null = 0,
StartOfHeading = 1,
StartOfText = 2,
EndOfText = 3,
EndOfTransmission = 4,
Enquiry = 5,
Acknowledge = 6,
Bell = 7,
Backspace = 8,
CharacterTabulation = 9,
LineFeed = 10,
LineTabulation = 11,
FormFeed = 12,
CarriageReturn = 13,
ShiftOut = 14,
ShiftIn = 15,
DataLinkEscape = 16,
DeviceControlOne = 17,
DeviceControlTwo = 18,
DeviceControlThree = 19,
DeviceControlFour = 20,
NegativeAcknowledge = 21,
SynchronousIdle = 22,
EndOfTransmissionBlock = 23,
Cancel = 24,
EndOfMedium = 25,
Substitute = 26,
Escape = 27,
InformationSeparatorFour = 28,
InformationSeparatorThree = 29,
InformationSeparatorTwo = 30,
InformationSeparatorOne = 31,
Space = 32,
ExclamationMark = 33,
QuotationMark = 34,
NumberSign = 35,
DollarSign = 36,
PercentSign = 37,
Ampersand = 38,
Apostrophe = 39,
LeftParenthesis = 40,
RightParenthesis = 41,
Asterisk = 42,
PlusSign = 43,
Comma = 44,
HyphenMinus = 45,
FullStop = 46,
Solidus = 47,
Digit0 = 48,
Digit1 = 49,
Digit2 = 50,
Digit3 = 51,
Digit4 = 52,
Digit5 = 53,
Digit6 = 54,
Digit7 = 55,
Digit8 = 56,
Digit9 = 57,
Colon = 58,
Semicolon = 59,
LessThanSign = 60,
EqualsSign = 61,
GreaterThanSign = 62,
QuestionMark = 63,
CommercialAt = 64,
CapitalA = 65,
CapitalB = 66,
CapitalC = 67,
CapitalD = 68,
CapitalE = 69,
CapitalF = 70,
CapitalG = 71,
CapitalH = 72,
CapitalI = 73,
CapitalJ = 74,
CapitalK = 75,
CapitalL = 76,
CapitalM = 77,
CapitalN = 78,
CapitalO = 79,
CapitalP = 80,
CapitalQ = 81,
CapitalR = 82,
CapitalS = 83,
CapitalT = 84,
CapitalU = 85,
CapitalV = 86,
CapitalW = 87,
CapitalX = 88,
CapitalY = 89,
CapitalZ = 90,
LeftSquareBracket = 91,
ReverseSolidus = 92,
RightSquareBracket = 93,
CircumflexAccent = 94,
LowLine = 95,
GraveAccent = 96,
SmallA = 97,
SmallB = 98,
SmallC = 99,
SmallD = 100,
SmallE = 101,
SmallF = 102,
SmallG = 103,
SmallH = 104,
SmallI = 105,
SmallJ = 106,
SmallK = 107,
SmallL = 108,
SmallM = 109,
SmallN = 110,
SmallO = 111,
SmallP = 112,
SmallQ = 113,
SmallR = 114,
SmallS = 115,
SmallT = 116,
SmallU = 117,
SmallV = 118,
SmallW = 119,
SmallX = 120,
SmallY = 121,
SmallZ = 122,
LeftCurlyBracket = 123,
VerticalLine = 124,
RightCurlyBracket = 125,
Tilde = 126,
Delete = 127,
}
ascii_char
)Expand description
One of the 128 Unicode characters from U+0000 through U+007F, often known as the ASCII subset.
Officially, this is the first block in Unicode, Basic Latin. For details, see the C0 Controls and Basic Latin code chart.
This block was based on older 7-bit character code standards such as ANSI X3.4-1977, ISO 646-1973, and NIST FIPS 1-2.
§When to use this
The main advantage of this subset is that it’s always valid UTF-8. As such,
the &[ascii::Char]
-> &str
conversion function (as well as other related
ones) are O(1): no runtime checks are needed.
If you’re consuming strings, you should usually handle Unicode and thus
accept str
s, not limit yourself to ascii::Char
s.
However, certain formats are intentionally designed to produce ASCII-only
output in order to be 8-bit-clean. In those cases, it can be simpler and
faster to generate ascii::Char
s instead of dealing with the variable width
properties of general UTF-8 encoded strings, while still allowing the result
to be used freely with other Rust things that deal in general str
s.
For example, a UUID library might offer a way to produce the string
representation of a UUID as an [ascii::Char; 36]
to avoid memory
allocation yet still allow it to be used as UTF-8 via as_str
without
paying for validation (or needing unsafe
code) the way it would if it
were provided as a [u8; 36]
.
§Layout
This type is guaranteed to have a size and alignment of 1 byte.
§Names
The variants on this type are Unicode names of the characters in upper camel case, with a few tweaks:
- For
<control>
characters, the primary alias name is used. LATIN
is dropped, as this block has no non-latin letters.LETTER
is dropped, asCAPITAL
/SMALL
suffices in this block.DIGIT
s use a single digit rather than writing outZERO
,ONE
, etc.
Variants§
Null = 0
ascii_char_variants
)U+0000 (The default variant)
StartOfHeading = 1
ascii_char_variants
)U+0001
StartOfText = 2
ascii_char_variants
)U+0002
EndOfText = 3
ascii_char_variants
)U+0003
EndOfTransmission = 4
ascii_char_variants
)U+0004
Enquiry = 5
ascii_char_variants
)U+0005
Acknowledge = 6
ascii_char_variants
)U+0006
Bell = 7
ascii_char_variants
)U+0007
Backspace = 8
ascii_char_variants
)U+0008
CharacterTabulation = 9
ascii_char_variants
)U+0009
LineFeed = 10
ascii_char_variants
)U+000A
LineTabulation = 11
ascii_char_variants
)U+000B
FormFeed = 12
ascii_char_variants
)U+000C
CarriageReturn = 13
ascii_char_variants
)U+000D
ShiftOut = 14
ascii_char_variants
)U+000E
ShiftIn = 15
ascii_char_variants
)U+000F
DataLinkEscape = 16
ascii_char_variants
)U+0010
DeviceControlOne = 17
ascii_char_variants
)U+0011
DeviceControlTwo = 18
ascii_char_variants
)U+0012
DeviceControlThree = 19
ascii_char_variants
)U+0013
DeviceControlFour = 20
ascii_char_variants
)U+0014
NegativeAcknowledge = 21
ascii_char_variants
)U+0015
SynchronousIdle = 22
ascii_char_variants
)U+0016
EndOfTransmissionBlock = 23
ascii_char_variants
)U+0017
Cancel = 24
ascii_char_variants
)U+0018
EndOfMedium = 25
ascii_char_variants
)U+0019
Substitute = 26
ascii_char_variants
)U+001A
Escape = 27
ascii_char_variants
)U+001B
InformationSeparatorFour = 28
ascii_char_variants
)U+001C
InformationSeparatorThree = 29
ascii_char_variants
)U+001D
InformationSeparatorTwo = 30
ascii_char_variants
)U+001E
InformationSeparatorOne = 31
ascii_char_variants
)U+001F
Space = 32
ascii_char_variants
)U+0020
ExclamationMark = 33
ascii_char_variants
)U+0021
QuotationMark = 34
ascii_char_variants
)U+0022
NumberSign = 35
ascii_char_variants
)U+0023
DollarSign = 36
ascii_char_variants
)U+0024
PercentSign = 37
ascii_char_variants
)U+0025
Ampersand = 38
ascii_char_variants
)U+0026
Apostrophe = 39
ascii_char_variants
)U+0027
LeftParenthesis = 40
ascii_char_variants
)U+0028
RightParenthesis = 41
ascii_char_variants
)U+0029
Asterisk = 42
ascii_char_variants
)U+002A
PlusSign = 43
ascii_char_variants
)U+002B
Comma = 44
ascii_char_variants
)U+002C
HyphenMinus = 45
ascii_char_variants
)U+002D
FullStop = 46
ascii_char_variants
)U+002E
Solidus = 47
ascii_char_variants
)U+002F
Digit0 = 48
ascii_char_variants
)U+0030
Digit1 = 49
ascii_char_variants
)U+0031
Digit2 = 50
ascii_char_variants
)U+0032
Digit3 = 51
ascii_char_variants
)U+0033
Digit4 = 52
ascii_char_variants
)U+0034
Digit5 = 53
ascii_char_variants
)U+0035
Digit6 = 54
ascii_char_variants
)U+0036
Digit7 = 55
ascii_char_variants
)U+0037
Digit8 = 56
ascii_char_variants
)U+0038
Digit9 = 57
ascii_char_variants
)U+0039
Colon = 58
ascii_char_variants
)U+003A
Semicolon = 59
ascii_char_variants
)U+003B
LessThanSign = 60
ascii_char_variants
)U+003C
EqualsSign = 61
ascii_char_variants
)U+003D
GreaterThanSign = 62
ascii_char_variants
)U+003E
QuestionMark = 63
ascii_char_variants
)U+003F
CommercialAt = 64
ascii_char_variants
)U+0040
CapitalA = 65
ascii_char_variants
)U+0041
CapitalB = 66
ascii_char_variants
)U+0042
CapitalC = 67
ascii_char_variants
)U+0043
CapitalD = 68
ascii_char_variants
)U+0044
CapitalE = 69
ascii_char_variants
)U+0045
CapitalF = 70
ascii_char_variants
)U+0046
CapitalG = 71
ascii_char_variants
)U+0047
CapitalH = 72
ascii_char_variants
)U+0048
CapitalI = 73
ascii_char_variants
)U+0049
CapitalJ = 74
ascii_char_variants
)U+004A
CapitalK = 75
ascii_char_variants
)U+004B
CapitalL = 76
ascii_char_variants
)U+004C
CapitalM = 77
ascii_char_variants
)U+004D
CapitalN = 78
ascii_char_variants
)U+004E
CapitalO = 79
ascii_char_variants
)U+004F
CapitalP = 80
ascii_char_variants
)U+0050
CapitalQ = 81
ascii_char_variants
)U+0051
CapitalR = 82
ascii_char_variants
)U+0052
CapitalS = 83
ascii_char_variants
)U+0053
CapitalT = 84
ascii_char_variants
)U+0054
CapitalU = 85
ascii_char_variants
)U+0055
CapitalV = 86
ascii_char_variants
)U+0056
CapitalW = 87
ascii_char_variants
)U+0057
CapitalX = 88
ascii_char_variants
)U+0058
CapitalY = 89
ascii_char_variants
)U+0059
CapitalZ = 90
ascii_char_variants
)U+005A
LeftSquareBracket = 91
ascii_char_variants
)U+005B
ReverseSolidus = 92
ascii_char_variants
)U+005C
RightSquareBracket = 93
ascii_char_variants
)U+005D
CircumflexAccent = 94
ascii_char_variants
)U+005E
LowLine = 95
ascii_char_variants
)U+005F
GraveAccent = 96
ascii_char_variants
)U+0060
SmallA = 97
ascii_char_variants
)U+0061
SmallB = 98
ascii_char_variants
)U+0062
SmallC = 99
ascii_char_variants
)U+0063
SmallD = 100
ascii_char_variants
)U+0064
SmallE = 101
ascii_char_variants
)U+0065
SmallF = 102
ascii_char_variants
)U+0066
SmallG = 103
ascii_char_variants
)U+0067
SmallH = 104
ascii_char_variants
)U+0068
SmallI = 105
ascii_char_variants
)U+0069
SmallJ = 106
ascii_char_variants
)U+006A
SmallK = 107
ascii_char_variants
)U+006B
SmallL = 108
ascii_char_variants
)U+006C
SmallM = 109
ascii_char_variants
)U+006D
SmallN = 110
ascii_char_variants
)U+006E
SmallO = 111
ascii_char_variants
)U+006F
SmallP = 112
ascii_char_variants
)U+0070
SmallQ = 113
ascii_char_variants
)U+0071
SmallR = 114
ascii_char_variants
)U+0072
SmallS = 115
ascii_char_variants
)U+0073
SmallT = 116
ascii_char_variants
)U+0074
SmallU = 117
ascii_char_variants
)U+0075
SmallV = 118
ascii_char_variants
)U+0076
SmallW = 119
ascii_char_variants
)U+0077
SmallX = 120
ascii_char_variants
)U+0078
SmallY = 121
ascii_char_variants
)U+0079
SmallZ = 122
ascii_char_variants
)U+007A
LeftCurlyBracket = 123
ascii_char_variants
)U+007B
VerticalLine = 124
ascii_char_variants
)U+007C
RightCurlyBracket = 125
ascii_char_variants
)U+007D
Tilde = 126
ascii_char_variants
)U+007E
Delete = 127
ascii_char_variants
)U+007F
Implementations§
Source§impl AsciiChar
impl AsciiChar
Sourcepub const MIN: AsciiChar = Self::Null
🔬This is a nightly-only experimental API. (ascii_char
)
pub const MIN: AsciiChar = Self::Null
ascii_char
)The character with the lowest ASCII code.
Sourcepub const MAX: AsciiChar = Self::Delete
🔬This is a nightly-only experimental API. (ascii_char
)
pub const MAX: AsciiChar = Self::Delete
ascii_char
)The character with the highest ASCII code.
Sourcepub const fn from_u8(b: u8) -> Option<AsciiChar>
🔬This is a nightly-only experimental API. (ascii_char
)
pub const fn from_u8(b: u8) -> Option<AsciiChar>
ascii_char
)Creates an ASCII character from the byte b
,
or returns None
if it’s too large.
Sourcepub const unsafe fn from_u8_unchecked(b: u8) -> AsciiChar
🔬This is a nightly-only experimental API. (ascii_char
)
pub const unsafe fn from_u8_unchecked(b: u8) -> AsciiChar
ascii_char
)Creates an ASCII character from the byte b
,
without checking whether it’s valid.
§Safety
b
must be in 0..=127
, or else this is UB.
Sourcepub const fn digit(d: u8) -> Option<AsciiChar>
🔬This is a nightly-only experimental API. (ascii_char
)
pub const fn digit(d: u8) -> Option<AsciiChar>
ascii_char
)When passed the number 0
, 1
, …, 9
, returns the character
'0'
, '1'
, …, '9'
respectively.
If d >= 10
, returns None
.
Sourcepub const unsafe fn digit_unchecked(d: u8) -> AsciiChar
🔬This is a nightly-only experimental API. (ascii_char
)
pub const unsafe fn digit_unchecked(d: u8) -> AsciiChar
ascii_char
)When passed the number 0
, 1
, …, 9
, returns the character
'0'
, '1'
, …, '9'
respectively, without checking that it’s in-range.
§Safety
This is immediate UB if called with d > 64
.
If d >= 10
and d <= 64
, this is allowed to return any value or panic.
Notably, it should not be expected to return hex digits, or any other
reasonable extension of the decimal digits.
(This loose safety condition is intended to simplify soundness proofs when writing code using this method, since the implementation doesn’t need something really specific, not to make those other arguments do something useful. It might be tightened before stabilization.)
Sourcepub const fn to_u8(self) -> u8
🔬This is a nightly-only experimental API. (ascii_char
)
pub const fn to_u8(self) -> u8
ascii_char
)Gets this ASCII character as a byte.
Sourcepub const fn to_char(self) -> char
🔬This is a nightly-only experimental API. (ascii_char
)
pub const fn to_char(self) -> char
ascii_char
)Gets this ASCII character as a char
Unicode Scalar Value.
Sourcepub const fn as_str(&self) -> &str
🔬This is a nightly-only experimental API. (ascii_char
)
pub const fn as_str(&self) -> &str
ascii_char
)Views this ASCII character as a one-code-unit UTF-8 str
.
Sourcepub const fn to_uppercase(self) -> AsciiChar
🔬This is a nightly-only experimental API. (ascii_char
)
pub const fn to_uppercase(self) -> AsciiChar
ascii_char
)Makes a copy of the value in its upper case equivalent.
Letters ‘a’ to ‘z’ are mapped to ‘A’ to ‘Z’.
To uppercase the value in-place, use make_uppercase
.
§Examples
#![feature(ascii_char, ascii_char_variants)]
use std::ascii;
let lowercase_a = ascii::Char::SmallA;
assert_eq!(
ascii::Char::CapitalA,
lowercase_a.to_uppercase(),
);
Sourcepub const fn to_lowercase(self) -> AsciiChar
🔬This is a nightly-only experimental API. (ascii_char
)
pub const fn to_lowercase(self) -> AsciiChar
ascii_char
)Makes a copy of the value in its lower case equivalent.
Letters ‘A’ to ‘Z’ are mapped to ‘a’ to ‘z’.
To lowercase the value in-place, use make_lowercase
.
§Examples
#![feature(ascii_char, ascii_char_variants)]
use std::ascii;
let uppercase_a = ascii::Char::CapitalA;
assert_eq!(
ascii::Char::SmallA,
uppercase_a.to_lowercase(),
);
Sourcepub const fn eq_ignore_case(self, other: AsciiChar) -> bool
🔬This is a nightly-only experimental API. (ascii_char
)
pub const fn eq_ignore_case(self, other: AsciiChar) -> bool
ascii_char
)Checks that two values are a case-insensitive match.
This is equivalent to to_lowercase(a) == to_lowercase(b)
.
§Examples
#![feature(ascii_char, ascii_char_variants)]
use std::ascii;
let lowercase_a = ascii::Char::SmallA;
let uppercase_a = ascii::Char::CapitalA;
assert!(lowercase_a.eq_ignore_case(uppercase_a));
Sourcepub const fn make_uppercase(&mut self)
🔬This is a nightly-only experimental API. (ascii_char
)
pub const fn make_uppercase(&mut self)
ascii_char
)Converts this value to its upper case equivalent in-place.
Letters ‘a’ to ‘z’ are mapped to ‘A’ to ‘Z’.
To return a new uppercased value without modifying the existing one, use
to_uppercase
.
§Examples
#![feature(ascii_char, ascii_char_variants)]
use std::ascii;
let mut letter_a = ascii::Char::SmallA;
letter_a.make_uppercase();
assert_eq!(ascii::Char::CapitalA, letter_a);
Sourcepub const fn make_lowercase(&mut self)
🔬This is a nightly-only experimental API. (ascii_char
)
pub const fn make_lowercase(&mut self)
ascii_char
)Converts this value to its lower case equivalent in-place.
Letters ‘A’ to ‘Z’ are mapped to ‘a’ to ‘z’.
To return a new lowercased value without modifying the existing one, use
to_lowercase
.
§Examples
#![feature(ascii_char, ascii_char_variants)]
use std::ascii;
let mut letter_a = ascii::Char::CapitalA;
letter_a.make_lowercase();
assert_eq!(ascii::Char::SmallA, letter_a);
Sourcepub const fn is_alphabetic(self) -> bool
🔬This is a nightly-only experimental API. (ascii_char
)
pub const fn is_alphabetic(self) -> bool
ascii_char
)Checks if the value is an alphabetic character:
- 0x41 ‘A’ ..= 0x5A ‘Z’, or
- 0x61 ‘a’ ..= 0x7A ‘z’.
§Examples
#![feature(ascii_char, ascii_char_variants)]
use std::ascii;
let uppercase_a = ascii::Char::CapitalA;
let uppercase_g = ascii::Char::CapitalG;
let a = ascii::Char::SmallA;
let g = ascii::Char::SmallG;
let zero = ascii::Char::Digit0;
let percent = ascii::Char::PercentSign;
let space = ascii::Char::Space;
let lf = ascii::Char::LineFeed;
let esc = ascii::Char::Escape;
assert!(uppercase_a.is_alphabetic());
assert!(uppercase_g.is_alphabetic());
assert!(a.is_alphabetic());
assert!(g.is_alphabetic());
assert!(!zero.is_alphabetic());
assert!(!percent.is_alphabetic());
assert!(!space.is_alphabetic());
assert!(!lf.is_alphabetic());
assert!(!esc.is_alphabetic());
Sourcepub const fn is_uppercase(self) -> bool
🔬This is a nightly-only experimental API. (ascii_char
)
pub const fn is_uppercase(self) -> bool
ascii_char
)Checks if the value is an uppercase character: 0x41 ‘A’ ..= 0x5A ‘Z’.
§Examples
#![feature(ascii_char, ascii_char_variants)]
use std::ascii;
let uppercase_a = ascii::Char::CapitalA;
let uppercase_g = ascii::Char::CapitalG;
let a = ascii::Char::SmallA;
let g = ascii::Char::SmallG;
let zero = ascii::Char::Digit0;
let percent = ascii::Char::PercentSign;
let space = ascii::Char::Space;
let lf = ascii::Char::LineFeed;
let esc = ascii::Char::Escape;
assert!(uppercase_a.is_uppercase());
assert!(uppercase_g.is_uppercase());
assert!(!a.is_uppercase());
assert!(!g.is_uppercase());
assert!(!zero.is_uppercase());
assert!(!percent.is_uppercase());
assert!(!space.is_uppercase());
assert!(!lf.is_uppercase());
assert!(!esc.is_uppercase());
Sourcepub const fn is_lowercase(self) -> bool
🔬This is a nightly-only experimental API. (ascii_char
)
pub const fn is_lowercase(self) -> bool
ascii_char
)Checks if the value is a lowercase character: 0x61 ‘a’ ..= 0x7A ‘z’.
§Examples
#![feature(ascii_char, ascii_char_variants)]
use std::ascii;
let uppercase_a = ascii::Char::CapitalA;
let uppercase_g = ascii::Char::CapitalG;
let a = ascii::Char::SmallA;
let g = ascii::Char::SmallG;
let zero = ascii::Char::Digit0;
let percent = ascii::Char::PercentSign;
let space = ascii::Char::Space;
let lf = ascii::Char::LineFeed;
let esc = ascii::Char::Escape;
assert!(!uppercase_a.is_lowercase());
assert!(!uppercase_g.is_lowercase());
assert!(a.is_lowercase());
assert!(g.is_lowercase());
assert!(!zero.is_lowercase());
assert!(!percent.is_lowercase());
assert!(!space.is_lowercase());
assert!(!lf.is_lowercase());
assert!(!esc.is_lowercase());
Sourcepub const fn is_alphanumeric(self) -> bool
🔬This is a nightly-only experimental API. (ascii_char
)
pub const fn is_alphanumeric(self) -> bool
ascii_char
)Checks if the value is an alphanumeric character:
- 0x41 ‘A’ ..= 0x5A ‘Z’, or
- 0x61 ‘a’ ..= 0x7A ‘z’, or
- 0x30 ‘0’ ..= 0x39 ‘9’.
§Examples
#![feature(ascii_char, ascii_char_variants)]
use std::ascii;
let uppercase_a = ascii::Char::CapitalA;
let uppercase_g = ascii::Char::CapitalG;
let a = ascii::Char::SmallA;
let g = ascii::Char::SmallG;
let zero = ascii::Char::Digit0;
let percent = ascii::Char::PercentSign;
let space = ascii::Char::Space;
let lf = ascii::Char::LineFeed;
let esc = ascii::Char::Escape;
assert!(uppercase_a.is_alphanumeric());
assert!(uppercase_g.is_alphanumeric());
assert!(a.is_alphanumeric());
assert!(g.is_alphanumeric());
assert!(zero.is_alphanumeric());
assert!(!percent.is_alphanumeric());
assert!(!space.is_alphanumeric());
assert!(!lf.is_alphanumeric());
assert!(!esc.is_alphanumeric());
Sourcepub const fn is_digit(self) -> bool
🔬This is a nightly-only experimental API. (ascii_char
)
pub const fn is_digit(self) -> bool
ascii_char
)Checks if the value is a decimal digit: 0x30 ‘0’ ..= 0x39 ‘9’.
§Examples
#![feature(ascii_char, ascii_char_variants)]
use std::ascii;
let uppercase_a = ascii::Char::CapitalA;
let uppercase_g = ascii::Char::CapitalG;
let a = ascii::Char::SmallA;
let g = ascii::Char::SmallG;
let zero = ascii::Char::Digit0;
let percent = ascii::Char::PercentSign;
let space = ascii::Char::Space;
let lf = ascii::Char::LineFeed;
let esc = ascii::Char::Escape;
assert!(!uppercase_a.is_digit());
assert!(!uppercase_g.is_digit());
assert!(!a.is_digit());
assert!(!g.is_digit());
assert!(zero.is_digit());
assert!(!percent.is_digit());
assert!(!space.is_digit());
assert!(!lf.is_digit());
assert!(!esc.is_digit());
Sourcepub const fn is_octdigit(self) -> bool
🔬This is a nightly-only experimental API. (ascii_char
)
pub const fn is_octdigit(self) -> bool
ascii_char
)Checks if the value is an octal digit: 0x30 ‘0’ ..= 0x37 ‘7’.
§Examples
#![feature(ascii_char, ascii_char_variants, is_ascii_octdigit)]
use std::ascii;
let uppercase_a = ascii::Char::CapitalA;
let a = ascii::Char::SmallA;
let zero = ascii::Char::Digit0;
let seven = ascii::Char::Digit7;
let eight = ascii::Char::Digit8;
let percent = ascii::Char::PercentSign;
let lf = ascii::Char::LineFeed;
let esc = ascii::Char::Escape;
assert!(!uppercase_a.is_octdigit());
assert!(!a.is_octdigit());
assert!(zero.is_octdigit());
assert!(seven.is_octdigit());
assert!(!eight.is_octdigit());
assert!(!percent.is_octdigit());
assert!(!lf.is_octdigit());
assert!(!esc.is_octdigit());
Sourcepub const fn is_hexdigit(self) -> bool
🔬This is a nightly-only experimental API. (ascii_char
)
pub const fn is_hexdigit(self) -> bool
ascii_char
)Checks if the value is a hexadecimal digit:
- 0x30 ‘0’ ..= 0x39 ‘9’, or
- 0x41 ‘A’ ..= 0x46 ‘F’, or
- 0x61 ‘a’ ..= 0x66 ‘f’.
§Examples
#![feature(ascii_char, ascii_char_variants)]
use std::ascii;
let uppercase_a = ascii::Char::CapitalA;
let uppercase_g = ascii::Char::CapitalG;
let a = ascii::Char::SmallA;
let g = ascii::Char::SmallG;
let zero = ascii::Char::Digit0;
let percent = ascii::Char::PercentSign;
let space = ascii::Char::Space;
let lf = ascii::Char::LineFeed;
let esc = ascii::Char::Escape;
assert!(uppercase_a.is_hexdigit());
assert!(!uppercase_g.is_hexdigit());
assert!(a.is_hexdigit());
assert!(!g.is_hexdigit());
assert!(zero.is_hexdigit());
assert!(!percent.is_hexdigit());
assert!(!space.is_hexdigit());
assert!(!lf.is_hexdigit());
assert!(!esc.is_hexdigit());
Sourcepub const fn is_punctuation(self) -> bool
🔬This is a nightly-only experimental API. (ascii_char
)
pub const fn is_punctuation(self) -> bool
ascii_char
)Checks if the value is a punctuation character:
- 0x21 ..= 0x2F
! " # $ % & ' ( ) * + , - . /
, or - 0x3A ..= 0x40
: ; < = > ? @
, or - 0x5B ..= 0x60
[ \ ] ^ _ `
, or - 0x7B ..= 0x7E
{ | } ~
§Examples
#![feature(ascii_char, ascii_char_variants)]
use std::ascii;
let uppercase_a = ascii::Char::CapitalA;
let uppercase_g = ascii::Char::CapitalG;
let a = ascii::Char::SmallA;
let g = ascii::Char::SmallG;
let zero = ascii::Char::Digit0;
let percent = ascii::Char::PercentSign;
let space = ascii::Char::Space;
let lf = ascii::Char::LineFeed;
let esc = ascii::Char::Escape;
assert!(!uppercase_a.is_punctuation());
assert!(!uppercase_g.is_punctuation());
assert!(!a.is_punctuation());
assert!(!g.is_punctuation());
assert!(!zero.is_punctuation());
assert!(percent.is_punctuation());
assert!(!space.is_punctuation());
assert!(!lf.is_punctuation());
assert!(!esc.is_punctuation());
Sourcepub const fn is_graphic(self) -> bool
🔬This is a nightly-only experimental API. (ascii_char
)
pub const fn is_graphic(self) -> bool
ascii_char
)Checks if the value is a graphic character: 0x21 ‘!’ ..= 0x7E ‘~’.
§Examples
#![feature(ascii_char, ascii_char_variants)]
use std::ascii;
let uppercase_a = ascii::Char::CapitalA;
let uppercase_g = ascii::Char::CapitalG;
let a = ascii::Char::SmallA;
let g = ascii::Char::SmallG;
let zero = ascii::Char::Digit0;
let percent = ascii::Char::PercentSign;
let space = ascii::Char::Space;
let lf = ascii::Char::LineFeed;
let esc = ascii::Char::Escape;
assert!(uppercase_a.is_graphic());
assert!(uppercase_g.is_graphic());
assert!(a.is_graphic());
assert!(g.is_graphic());
assert!(zero.is_graphic());
assert!(percent.is_graphic());
assert!(!space.is_graphic());
assert!(!lf.is_graphic());
assert!(!esc.is_graphic());
Sourcepub const fn is_whitespace(self) -> bool
🔬This is a nightly-only experimental API. (ascii_char
)
pub const fn is_whitespace(self) -> bool
ascii_char
)Checks if the value is a whitespace character: 0x20 SPACE, 0x09 HORIZONTAL TAB, 0x0A LINE FEED, 0x0C FORM FEED, or 0x0D CARRIAGE RETURN.
Rust uses the WhatWG Infra Standard’s definition of ASCII whitespace. There are several other definitions in wide use. For instance, the POSIX locale includes 0x0B VERTICAL TAB as well as all the above characters, but—from the very same specification—the default rule for “field splitting” in the Bourne shell considers only SPACE, HORIZONTAL TAB, and LINE FEED as whitespace.
If you are writing a program that will process an existing file format, check what that format’s definition of whitespace is before using this function.
§Examples
#![feature(ascii_char, ascii_char_variants)]
use std::ascii;
let uppercase_a = ascii::Char::CapitalA;
let uppercase_g = ascii::Char::CapitalG;
let a = ascii::Char::SmallA;
let g = ascii::Char::SmallG;
let zero = ascii::Char::Digit0;
let percent = ascii::Char::PercentSign;
let space = ascii::Char::Space;
let lf = ascii::Char::LineFeed;
let esc = ascii::Char::Escape;
assert!(!uppercase_a.is_whitespace());
assert!(!uppercase_g.is_whitespace());
assert!(!a.is_whitespace());
assert!(!g.is_whitespace());
assert!(!zero.is_whitespace());
assert!(!percent.is_whitespace());
assert!(space.is_whitespace());
assert!(lf.is_whitespace());
assert!(!esc.is_whitespace());
Sourcepub const fn is_control(self) -> bool
🔬This is a nightly-only experimental API. (ascii_char
)
pub const fn is_control(self) -> bool
ascii_char
)Checks if the value is a control character: 0x00 NUL ..= 0x1F UNIT SEPARATOR, or 0x7F DELETE. Note that most whitespace characters are control characters, but SPACE is not.
§Examples
#![feature(ascii_char, ascii_char_variants)]
use std::ascii;
let uppercase_a = ascii::Char::CapitalA;
let uppercase_g = ascii::Char::CapitalG;
let a = ascii::Char::SmallA;
let g = ascii::Char::SmallG;
let zero = ascii::Char::Digit0;
let percent = ascii::Char::PercentSign;
let space = ascii::Char::Space;
let lf = ascii::Char::LineFeed;
let esc = ascii::Char::Escape;
assert!(!uppercase_a.is_control());
assert!(!uppercase_g.is_control());
assert!(!a.is_control());
assert!(!g.is_control());
assert!(!zero.is_control());
assert!(!percent.is_control());
assert!(!space.is_control());
assert!(lf.is_control());
assert!(esc.is_control());
Sourcepub fn escape_ascii(self) -> EscapeDefault ⓘ
🔬This is a nightly-only experimental API. (ascii_char
)
pub fn escape_ascii(self) -> EscapeDefault ⓘ
ascii_char
)Returns an iterator that produces an escaped version of a character.
The behavior is identical to
ascii::escape_default
.
§Examples
#![feature(ascii_char, ascii_char_variants)]
use std::ascii;
let zero = ascii::Char::Digit0;
let tab = ascii::Char::CharacterTabulation;
let cr = ascii::Char::CarriageReturn;
let lf = ascii::Char::LineFeed;
let apostrophe = ascii::Char::Apostrophe;
let double_quote = ascii::Char::QuotationMark;
let backslash = ascii::Char::ReverseSolidus;
assert_eq!("0", zero.escape_ascii().to_string());
assert_eq!("\\t", tab.escape_ascii().to_string());
assert_eq!("\\r", cr.escape_ascii().to_string());
assert_eq!("\\n", lf.escape_ascii().to_string());
assert_eq!("\\'", apostrophe.escape_ascii().to_string());
assert_eq!("\\\"", double_quote.escape_ascii().to_string());
assert_eq!("\\\\", backslash.escape_ascii().to_string());
Trait Implementations§
Source§impl Ord for AsciiChar
impl Ord for AsciiChar
Source§impl PartialOrd for AsciiChar
impl PartialOrd for AsciiChar
Source§impl Step for AsciiChar
impl Step for AsciiChar
Source§fn steps_between(_: &AsciiChar, _: &AsciiChar) -> (usize, Option<usize>)
fn steps_between(_: &AsciiChar, _: &AsciiChar) -> (usize, Option<usize>)
step_trait
)start
to end
like Iterator::size_hint()
. Read moreSource§fn forward_checked(start: AsciiChar, count: usize) -> Option<AsciiChar>
fn forward_checked(start: AsciiChar, count: usize) -> Option<AsciiChar>
step_trait
)Source§fn backward_checked(start: AsciiChar, count: usize) -> Option<AsciiChar>
fn backward_checked(start: AsciiChar, count: usize) -> Option<AsciiChar>
step_trait
)Source§unsafe fn forward_unchecked(start: AsciiChar, count: usize) -> AsciiChar
unsafe fn forward_unchecked(start: AsciiChar, count: usize) -> AsciiChar
step_trait
)Source§unsafe fn backward_unchecked(start: AsciiChar, count: usize) -> AsciiChar
unsafe fn backward_unchecked(start: AsciiChar, count: usize) -> AsciiChar
step_trait
)