Enum ascii::AsciiChar

#[repr(u8)]
pub enum AsciiChar {
    Null,
    SOH,
    SOX,
    ETX,
    EOT,
    ENQ,
    ACK,
    Bell,
    BackSpace,
    Tab,
    LineFeed,
    VT,
    FF,
    CarriageReturn,
    SI,
    SO,
    DLE,
    DC1,
    DC2,
    DC3,
    DC4,
    NAK,
    SYN,
    ETB,
    CAN,
    EM,
    SUB,
    ESC,
    FS,
    GS,
    RS,
    US,
    Space,
    Exclamation,
    Quotation,
    Hash,
    Dollar,
    Percent,
    Ampersand,
    Apostrophe,
    ParenOpen,
    ParenClose,
    Asterisk,
    Plus,
    Comma,
    Minus,
    Dot,
    Slash,
    _0,
    _1,
    _2,
    _3,
    _4,
    _5,
    _6,
    _7,
    _8,
    _9,
    Colon,
    Semicolon,
    LessThan,
    Equal,
    GreaterThan,
    Question,
    At,
    A,
    B,
    C,
    D,
    E,
    F,
    G,
    H,
    I,
    J,
    K,
    L,
    M,
    N,
    O,
    P,
    Q,
    R,
    S,
    T,
    U,
    V,
    W,
    X,
    Y,
    Z,
    BracketOpen,
    BackSlash,
    BracketClose,
    Caret,
    UnderScore,
    Grave,
    a,
    b,
    c,
    d,
    e,
    f,
    g,
    h,
    i,
    j,
    k,
    l,
    m,
    n,
    o,
    p,
    q,
    r,
    s,
    t,
    u,
    v,
    w,
    x,
    y,
    z,
    CurlyBraceOpen,
    VerticalBar,
    CurlyBraceClose,
    Tilde,
    DEL,
}

An ASCII character. It wraps a u8, with the highest bit always zero.

Variants

Null

'\0'

SOH

Start Of Heading

SOX

Start Of teXt

ETX

End of TeXt

EOT

End Of Transmission

ENQ

Enquiry

ACK

Acknowledgement

Bell

bell / alarm / audible

'\a' is not recognized by Rust.

BackSpace

Backspace

'\b' is not recognized by Rust.

Tab

'\t'

LineFeed

'\n'

VT

Vertical tab

'\v' is not recognized by Rust.

FF

Form Feed

'\f' is not recognized by Rust.

CarriageReturn

'\r'

SI

Shift In

SO

Shift Out

DLE

Data Link Escape

DC1

Device control 1, often XON

DC2

Device control 2

DC3

Device control 3, Often XOFF

DC4

Device control 4

NAK

Negative AcKnowledgement

SYN

Synchronous idle

ETB

End of Transmission Block

CAN

Cancel

EM

End of Medium

SUB

Substitute

ESC

Escape

'\e' is not recognized by Rust.

FS

File Separator

GS

Group Separator

RS

Record Separator

US

Unit Separator

Space

' '

Exclamation

'!'

Quotation

'"'

Hash

'#'

Dollar

'$'

Percent

'%'

Ampersand

'&'

Apostrophe

'\''

ParenOpen

'('

ParenClose

')'

Asterisk

'*'

Plus

'+'

Comma

','

Minus

'-'

Dot

'.'

Slash

'/'

_0

'0'

_1

'1'

_2

'2'

_3

'3'

_4

'4'

_5

'5'

_6

'6'

_7

'7'

_8

'8'

_9

'9'

Colon

':'

Semicolon

';'

LessThan

'<'

Equal

'='

GreaterThan

'>'

Question

'?'

At

'@'

A

'A'

B

'B'

C

'C'

D

'D'

E

'E'

F

'F'

G

'G'

H

'H'

I

'I'

J

'J'

K

'K'

L

'L'

M

'M'

N

'N'

O

'O'

P

'P'

Q

'Q'

R

'R'

S

'S'

T

'T'

U

'U'

V

'V'

W

'W'

X

'X'

Y

'Y'

Z

'Z'

BracketOpen

'['

BackSlash

'\'

BracketClose

']'

Caret

'_'

UnderScore

'_'

Grave

''`

a

'a'

b

'b'

c

'c'

d

'd'

e

'e'

f

'f'

g

'g'

h

'h'

i

'i'

j

'j'

k

'k'

l

'l'

m

'm'

n

'n'

o

'o'

p

'p'

q

'q'

r

'r'

s

's'

t

't'

u

'u'

v

'v'

w

'w'

x

'x'

y

'y'

z

'z'

CurlyBraceOpen

'{'

VerticalBar

'|'

CurlyBraceClose

'}'

Tilde

'~'

DEL

Delete

Methods

impl AsciiChar

pub fn from_ascii<C: ToAsciiChar>(ch: C) -> Result<Self, ToAsciiCharError>

Constructs an ASCII character from a u8, char or other character type.

Failure

Returns Err(()) if the character can't be ASCII encoded.

Example

let a = AsciiChar::from_ascii('g').unwrap();
assert_eq!(a.as_char(), 'g');

pub const fn new(ch: char) -> AsciiChar

Create an AsciiChar from a char, panicking if it's not ASCII.

This function is intended for creating AsciiChar values from hardcoded known-good character literals such as 'K', '-' or '\0', and for use in const contexts. Use from_ascii() instead when you're not certain the character is ASCII.

Examples

assert_eq!(AsciiChar::new('@'), AsciiChar::At);
assert_eq!(AsciiChar::new('C').as_char(), 'C');

In a constant:

const SPLIT_ON: AsciiChar = AsciiChar::new(',');

This will not compile:

const BAD: AsciiChar = AsciiChar::new('Ø');

Panics

This function will panic if passed a non-ASCII character.

The panic message might not be the most descriptive due to the current limitations of const fn.

pub unsafe fn from_ascii_unchecked(ch: u8) -> Self

Constructs an ASCII character from a u8, char or other character type without any checks.

Safety

This function is very unsafe as it can create invalid enum discriminants, which instantly creates undefined behavior. (let _ = AsciiChar::from_ascii_unchecked(200); alone is UB).

The undefined behavior is not just theoretical either: For example, [0; 128][AsciiChar::from_ascii_unchecked(255) as u8 as usize] = 0 might not panic, creating a buffer overflow, and Some(AsciiChar::from_ascii_unchecked(128)) might be None.

pub const fn as_byte(self) -> u8

Converts an ASCII character into a u8.

pub const fn as_char(self) -> char

Converts an ASCII character into a char.

pub const fn is_alphabetic(self) -> bool

Check if the character is a letter (a-z, A-Z)

pub const fn is_ascii_alphabetic(&self) -> bool

Check if the character is a letter (a-z, A-Z).

This method is identical to is_alphabetic()

pub fn is_digit(self, radix: u32) -> bool

Check if the character is a digit in the given radix.

If the radix is always 10 or 16, is_ascii_digit() and is_ascii_hexdigit() will be faster.

Panics

Radixes greater than 36 are not supported and will result in a panic.

pub const fn is_ascii_digit(&self) -> bool

Check if the character is a number (0-9)

Examples

assert_eq!(AsciiChar::new('0').is_ascii_digit(), true);
assert_eq!(AsciiChar::new('9').is_ascii_digit(), true);
assert_eq!(AsciiChar::new('a').is_ascii_digit(), false);
assert_eq!(AsciiChar::new('A').is_ascii_digit(), false);
assert_eq!(AsciiChar::new('/').is_ascii_digit(), false);

pub const fn is_alphanumeric(self) -> bool

Check if the character is a letter or number

pub const fn is_ascii_alphanumeric(&self) -> bool

Check if the character is a letter or number

This method is identical to is_alphanumeric()

pub const fn is_ascii_blank(&self) -> bool

Check if the character is a space or horizontal tab

Examples

assert!(AsciiChar::Space.is_ascii_blank());
assert!(AsciiChar::Tab.is_ascii_blank());
assert!(!AsciiChar::VT.is_ascii_blank());
assert!(!AsciiChar::LineFeed.is_ascii_blank());
assert!(!AsciiChar::CarriageReturn.is_ascii_blank());
assert!(!AsciiChar::FF.is_ascii_blank());

pub const fn is_whitespace(self) -> bool

Check if the character one of ' ', '\t', '\n', '\r', '\0xb' (vertical tab) or '\0xc' (form feed).

pub const fn is_ascii_whitespace(&self) -> bool

Check if the character is a ' ', '\t', '\n', '\r' or '\0xc' (form feed).

This method is NOT identical to is_whitespace().

pub const fn is_ascii_control(&self) -> bool

Check if the character is a control character

Examples

assert_eq!(AsciiChar::new('\0').is_ascii_control(), true);
assert_eq!(AsciiChar::new('n').is_ascii_control(), false);
assert_eq!(AsciiChar::new(' ').is_ascii_control(), false);
assert_eq!(AsciiChar::new('\n').is_ascii_control(), true);
assert_eq!(AsciiChar::new('\t').is_ascii_control(), true);
assert_eq!(AsciiChar::EOT.is_ascii_control(), true);

pub const fn is_ascii_graphic(&self) -> bool

Checks if the character is printable (except space)

Examples

assert_eq!(AsciiChar::new('n').is_ascii_graphic(), true);
assert_eq!(AsciiChar::new(' ').is_ascii_graphic(), false);
assert_eq!(AsciiChar::new('\n').is_ascii_graphic(), false);

pub const fn is_ascii_printable(&self) -> bool

Checks if the character is printable (including space)

Examples

assert_eq!(AsciiChar::new('n').is_ascii_printable(), true);
assert_eq!(AsciiChar::new(' ').is_ascii_printable(), true);
assert_eq!(AsciiChar::new('\n').is_ascii_printable(), false);

pub const fn is_lowercase(self) -> bool

Checks if the character is alphabetic and lowercase (a-z).

Examples

use ascii::AsciiChar;
assert_eq!(AsciiChar::new('a').is_lowercase(), true);
assert_eq!(AsciiChar::new('A').is_lowercase(), false);
assert_eq!(AsciiChar::new('@').is_lowercase(), false);

pub const fn is_ascii_lowercase(&self) -> bool

Checks if the character is alphabetic and lowercase (a-z).

This method is identical to is_lowercase()

pub const fn is_uppercase(self) -> bool

Checks if the character is alphabetic and uppercase (A-Z).

Examples

assert_eq!(AsciiChar::new('A').is_uppercase(), true);
assert_eq!(AsciiChar::new('a').is_uppercase(), false);
assert_eq!(AsciiChar::new('@').is_uppercase(), false);

pub const fn is_ascii_uppercase(&self) -> bool

Checks if the character is alphabetic and uppercase (A-Z).

This method is identical to is_uppercase()

pub const fn is_ascii_punctuation(&self) -> bool

Checks if the character is punctuation

Examples

assert_eq!(AsciiChar::new('n').is_ascii_punctuation(), false);
assert_eq!(AsciiChar::new(' ').is_ascii_punctuation(), false);
assert_eq!(AsciiChar::new('_').is_ascii_punctuation(), true);
assert_eq!(AsciiChar::new('~').is_ascii_punctuation(), true);

pub const fn is_ascii_hexdigit(&self) -> bool

Checks if the character is a valid hex digit

Examples

assert_eq!(AsciiChar::new('5').is_ascii_hexdigit(), true);
assert_eq!(AsciiChar::new('a').is_ascii_hexdigit(), true);
assert_eq!(AsciiChar::new('F').is_ascii_hexdigit(), true);
assert_eq!(AsciiChar::new('G').is_ascii_hexdigit(), false);
assert_eq!(AsciiChar::new(' ').is_ascii_hexdigit(), false);

pub fn as_printable_char(self) -> char

Unicode has printable versions of the ASCII control codes, like '␛'.

This function is identical with .as_char() for all values .is_printable() returns true for, but replaces the control codes with those unicodes printable versions.

Examples

assert_eq!(AsciiChar::new('\0').as_printable_char(), '␀');
assert_eq!(AsciiChar::new('\n').as_printable_char(), '␊');
assert_eq!(AsciiChar::new(' ').as_printable_char(), ' ');
assert_eq!(AsciiChar::new('p').as_printable_char(), 'p');

pub fn make_ascii_uppercase(&mut self)

Replaces letters a to z with A to Z

pub fn make_ascii_lowercase(&mut self)

Replaces letters A to Z with a to z

pub const fn to_ascii_uppercase(&self) -> Self

Maps letters a-z to A-Z and returns any other character unchanged.

Examples

assert_eq!(AsciiChar::new('u').to_ascii_uppercase().as_char(), 'U');
assert_eq!(AsciiChar::new('U').to_ascii_uppercase().as_char(), 'U');
assert_eq!(AsciiChar::new('2').to_ascii_uppercase().as_char(), '2');
assert_eq!(AsciiChar::new('=').to_ascii_uppercase().as_char(), '=');
assert_eq!(AsciiChar::new('[').to_ascii_uppercase().as_char(), '[');

pub const fn to_ascii_lowercase(&self) -> Self

Maps letters A-Z to a-z and returns any other character unchanged.

Examples

assert_eq!(AsciiChar::new('U').to_ascii_lowercase().as_char(), 'u');
assert_eq!(AsciiChar::new('u').to_ascii_lowercase().as_char(), 'u');
assert_eq!(AsciiChar::new('2').to_ascii_lowercase().as_char(), '2');
assert_eq!(AsciiChar::new('^').to_ascii_lowercase().as_char(), '^');
assert_eq!(AsciiChar::new('\x7f').to_ascii_lowercase().as_char(), '\x7f');

pub const fn eq_ignore_ascii_case(&self, other: &Self) -> bool

Compares two characters case-insensitively.

Trait Implementations

impl ToAsciiChar for AsciiChar

fn to_ascii_char(self) -> Result<AsciiChar, ToAsciiCharError>

Convert to AsciiChar.

unsafe fn to_ascii_char_unchecked(self) -> AsciiChar

Convert to AsciiChar without checking that it is an ASCII character.

impl Copy for AsciiChar

impl AsRef<AsciiStr> for AsciiChar

fn as_ref(&self) -> &AsciiStr

Performs the conversion.

impl Default for AsciiChar

fn default() -> AsciiChar

Returns the "default value" for a type.

impl Eq for AsciiChar

impl Clone for AsciiChar

fn clone(&self) -> AsciiChar

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl PartialOrd<AsciiChar> for AsciiChar

fn partial_cmp(&self, other: &AsciiChar) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use] fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use] fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use] fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use] fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<u8> for AsciiChar

fn partial_cmp(&self, rhs: &u8) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use] fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use] fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use] fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use] fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<AsciiChar> for u8

fn partial_cmp(&self, rhs: &AsciiChar) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use] fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use] fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use] fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use] fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<char> for AsciiChar

fn partial_cmp(&self, rhs: &char) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use] fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use] fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use] fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use] fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<AsciiChar> for char

fn partial_cmp(&self, rhs: &AsciiChar) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use] fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use] fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use] fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use] fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialEq<AsciiChar> for AsciiChar

fn eq(&self, other: &AsciiChar) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<u8> for AsciiChar

fn eq(&self, rhs: &u8) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<AsciiChar> for u8

fn eq(&self, rhs: &AsciiChar) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<char> for AsciiChar

fn eq(&self, rhs: &char) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<AsciiChar> for char

fn eq(&self, rhs: &AsciiChar) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl From<AsciiChar> for u8

fn from(a: AsciiChar) -> u8

Performs the conversion.

impl From<AsciiChar> for char

fn from(a: AsciiChar) -> char

Performs the conversion.

impl Ord for AsciiChar

fn cmp(&self, other: &AsciiChar) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl Hash for AsciiChar

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl Display for AsciiChar

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Debug for AsciiChar

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.