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<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('g').unwrap();
assert_eq!(a.as_char(), 'g');

pub unsafe fn from_unchecked<C: ToAsciiChar>(ch: C) -> Self

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

pub fn as_byte(self) -> u8

Converts an ASCII character into a u8.

pub fn as_char(self) -> char

Converts an ASCII character into a char.

pub fn is_alphabetic(self) -> bool

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

pub fn is_digit(self) -> bool

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

pub fn is_alphanumeric(self) -> bool

Check if the character is a letter or number

pub fn is_blank(self) -> bool

Check if the character is a space or horizontal tab

pub fn is_whitespace(self) -> bool

Check if the character is a ' ', '\t', '\n' or '\r'

pub fn is_control(self) -> bool

Check if the character is a control character

Examples

use ascii::ToAsciiChar;
assert_eq!('\0'.to_ascii_char().unwrap().is_control(), true);
assert_eq!('n'.to_ascii_char().unwrap().is_control(), false);
assert_eq!(' '.to_ascii_char().unwrap().is_control(), false);
assert_eq!('\n'.to_ascii_char().unwrap().is_control(), true);

pub fn is_graph(self) -> bool

Checks if the character is printable (except space)

Examples

use ascii::ToAsciiChar;
assert_eq!('n'.to_ascii_char().unwrap().is_graph(), true);
assert_eq!(' '.to_ascii_char().unwrap().is_graph(), false);
assert_eq!('\n'.to_ascii_char().unwrap().is_graph(), false);

pub fn is_print(self) -> bool

Checks if the character is printable (including space)

Examples

use ascii::ToAsciiChar;
assert_eq!('n'.to_ascii_char().unwrap().is_print(), true);
assert_eq!(' '.to_ascii_char().unwrap().is_print(), true);
assert_eq!('\n'.to_ascii_char().unwrap().is_print(), false);

pub fn is_lowercase(self) -> bool

Checks if the character is alphabetic and lowercase

Examples

use ascii::ToAsciiChar;
assert_eq!('a'.to_ascii_char().unwrap().is_lowercase(), true);
assert_eq!('A'.to_ascii_char().unwrap().is_lowercase(), false);
assert_eq!('@'.to_ascii_char().unwrap().is_lowercase(), false);

pub fn is_uppercase(self) -> bool

Checks if the character is alphabetic and uppercase

Examples

use ascii::ToAsciiChar;
assert_eq!('A'.to_ascii_char().unwrap().is_uppercase(), true);
assert_eq!('a'.to_ascii_char().unwrap().is_uppercase(), false);
assert_eq!('@'.to_ascii_char().unwrap().is_uppercase(), false);

pub fn is_punctuation(self) -> bool

Checks if the character is punctuation

Examples

use ascii::ToAsciiChar;
assert_eq!('n'.to_ascii_char().unwrap().is_punctuation(), false);
assert_eq!(' '.to_ascii_char().unwrap().is_punctuation(), false);
assert_eq!('_'.to_ascii_char().unwrap().is_punctuation(), true);
assert_eq!('~'.to_ascii_char().unwrap().is_punctuation(), true);

pub fn is_hex(self) -> bool

Checks if the character is a valid hex digit

Examples

use ascii::ToAsciiChar;
assert_eq!('5'.to_ascii_char().unwrap().is_hex(), true);
assert_eq!('a'.to_ascii_char().unwrap().is_hex(), true);
assert_eq!('F'.to_ascii_char().unwrap().is_hex(), true);
assert_eq!('G'.to_ascii_char().unwrap().is_hex(), false);
assert_eq!(' '.to_ascii_char().unwrap().is_hex(), 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!('\0'.to_ascii_char().unwrap().as_printable_char(), '␀');
assert_eq!('\n'.to_ascii_char().unwrap().as_printable_char(), '␊');
assert_eq!(' '.to_ascii_char().unwrap().as_printable_char(), ' ');
assert_eq!('p'.to_ascii_char().unwrap().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 fn to_ascii_uppercase(&self) -> Self

Maps letters a...z to A...Z and returns everything else unchanged.

pub fn to_ascii_lowercase(&self) -> Self

Maps letters A...Z to a...z and returns everything else unchanged.

pub 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 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 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 Extend<AsciiChar> for AsciiString

fn extend<I: IntoIterator<Item = AsciiChar>>(&mut self, iterable: I)

Extends a collection with the contents of an iterator.

impl<'a> Extend<&'a AsciiChar> for AsciiString

fn extend<I: IntoIterator<Item = &'a AsciiChar>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

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 Eq for AsciiChar

impl Copy for AsciiChar

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.

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 FromIterator<AsciiChar> for AsciiString

fn from_iter<I: IntoIterator<Item = AsciiChar>>(iter: I) -> AsciiString

Creates a value from an iterator.

impl AsciiExt for AsciiChar

type Owned = AsciiChar

Deprecated since 1.26.0:

use inherent methods instead

Container type for copied ASCII characters.

fn is_ascii(&self) -> bool

Deprecated since 1.26.0:

use inherent methods instead

Checks if the value is within the ASCII range.

fn to_ascii_uppercase(&self) -> AsciiChar

Deprecated since 1.26.0:

use inherent methods instead

Makes a copy of the value in its ASCII upper case equivalent.

fn to_ascii_lowercase(&self) -> AsciiChar

Deprecated since 1.26.0:

use inherent methods instead

Makes a copy of the value in its ASCII lower case equivalent.

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

Deprecated since 1.26.0:

use inherent methods instead

Checks that two values are an ASCII case-insensitive match.

fn make_ascii_uppercase(&mut self)

Deprecated since 1.26.0:

use inherent methods instead

Converts this type to its ASCII upper case equivalent in-place.

fn make_ascii_lowercase(&mut self)

Deprecated since 1.26.0:

use inherent methods instead

Converts this type to its ASCII lower case equivalent in-place.