The lowest valid code point achar can have,'\0'.

Unlike integer types,char actually has a gap in the middle,meaning that the range of possiblechars is smaller than youmight expect. Ranges ofchar will automatically hop this gapfor you:

letdist = u32::from(char::MAX) - u32::from(char::MIN);letsize = (char::MIN..=char::MAX).count()asu32;assert!(size < dist);

Despite this gap, theMIN andMAX values can be used as bounds forallchar values.

§Examples

letc: char = something_which_returns_char();assert!(char::MIN <= c);letvalue_at_min = u32::from(char::MIN);assert_eq!(char::from_u32(value_at_min),Some('\0'));

The highest valid code point achar can have,'\u{10FFFF}'.

Unlike integer types,char actually has a gap in the middle,meaning that the range of possiblechars is smaller than youmight expect. Ranges ofchar will automatically hop this gapfor you:

letdist = u32::from(char::MAX) - u32::from(char::MIN);letsize = (char::MIN..=char::MAX).count()asu32;assert!(size < dist);

Despite this gap, theMIN andMAX values can be used as bounds forallchar values.

§Examples

letc: char = something_which_returns_char();assert!(c <= char::MAX);letvalue_at_max = u32::from(char::MAX);assert_eq!(char::from_u32(value_at_max),Some('\u{10FFFF}'));assert_eq!(char::from_u32(value_at_max +1),None);

The maximum number of bytes required toencode achar toUTF-8 encoding.

The maximum number of two-byte units required toencode acharto UTF-16 encoding.

U+FFFD REPLACEMENT CHARACTER (�) is used in Unicode to represent adecoding error.

It can occur, for example, when giving ill-formed UTF-8 bytes toString::from_utf8_lossy.

The version ofUnicode that the Unicode parts ofchar andstr methods are based on.

New versions of Unicode are released regularly and subsequently all methodsin the standard library depending on Unicode are updated. Therefore thebehavior of somechar andstr methods and the value of this constantchanges over time. This isnot considered to be a breaking change.

The version numbering scheme is explained inUnicode 11.0 or later, Section 3.1 Versions of the Unicode Standard.

Creates an iterator over the native endian UTF-16 encoded code points initer,returning unpaired surrogates asErrs.

§Examples

Basic usage:

// 𝄞mus<invalid>ic<invalid>letv = [0xD834,0xDD1E,0x006d,0x0075,0x0073,0xDD1E,0x0069,0x0063,0xD834,];assert_eq!(    char::decode_utf16(v)        .map(|r| r.map_err(|e| e.unpaired_surrogate()))        .collect::<Vec<_>>(),vec![Ok('𝄞'),Ok('m'),Ok('u'),Ok('s'),Err(0xDD1E),Ok('i'),Ok('c'),Err(0xD834)    ]);

A lossy decoder can be obtained by replacingErr results with the replacement character:

// 𝄞mus<invalid>ic<invalid>letv = [0xD834,0xDD1E,0x006d,0x0075,0x0073,0xDD1E,0x0069,0x0063,0xD834,];assert_eq!(    char::decode_utf16(v)       .map(|r| r.unwrap_or(char::REPLACEMENT_CHARACTER))       .collect::<String>(),"𝄞mus�ic�");

Converts au32 to achar.

Note that allchars are validu32s, and can be cast to one withas:

letc ='💯';leti = casu32;assert_eq!(128175, i);

However, the reverse is not true: not all validu32s are validchars.from_u32() will returnNone if the input is not a valid valuefor achar.

For an unsafe version of this function which ignores these checks, seefrom_u32_unchecked.

§Examples

Basic usage:

letc = char::from_u32(0x2764);assert_eq!(Some('❤'), c);

ReturningNone when the input is not a validchar:

letc = char::from_u32(0x110000);assert_eq!(None, c);

Converts au32 to achar, ignoring validity.

Note that allchars are validu32s, and can be cast to one withas:

letc ='💯';leti = casu32;assert_eq!(128175, i);

However, the reverse is not true: not all validu32s are validchars.from_u32_unchecked() will ignore this, and blindly cast tochar, possibly creating an invalid one.

§Safety

This function is unsafe, as it may construct invalidchar values.

For a safe version of this function, see thefrom_u32 function.

§Examples

Basic usage:

letc =unsafe{ char::from_u32_unchecked(0x2764) };assert_eq!('❤', c);

Converts a digit in the given radix to achar.

A ‘radix’ here is sometimes also called a ‘base’. A radix of twoindicates a binary number, a radix of ten, decimal, and a radix ofsixteen, hexadecimal, to give some common values. Arbitraryradices are supported.

from_digit() will returnNone if the input is not a digit inthe given radix.

§Panics

Panics if given a radix larger than 36.

§Examples

Basic usage:

letc = char::from_digit(4,10);assert_eq!(Some('4'), c);// Decimal 11 is a single digit in base 16letc = char::from_digit(11,16);assert_eq!(Some('b'), c);

ReturningNone when the input is not a digit:

letc = char::from_digit(20,10);assert_eq!(None, c);

Passing a large radix, causing a panic:

// this panicslet_c = char::from_digit(1,37);

Checks if achar is a digit in the given radix.

A ‘radix’ here is sometimes also called a ‘base’. A radix of twoindicates a binary number, a radix of ten, decimal, and a radix ofsixteen, hexadecimal, to give some common values. Arbitraryradices are supported.

Compared tois_numeric(), this function only recognizes the characters0-9,a-z andA-Z.

‘Digit’ is defined to be only the following characters:

• 0-9
• a-z
• A-Z

For a more comprehensive understanding of ‘digit’, seeis_numeric().

§Panics

Panics if given a radix smaller than 2 or larger than 36.

§Examples

Basic usage:

assert!('1'.is_digit(10));assert!('f'.is_digit(16));assert!(!'f'.is_digit(10));

Passing a large radix, causing a panic:

// this panics'1'.is_digit(37);

Passing a small radix, causing a panic:

// this panics'1'.is_digit(1);

Converts achar to a digit in the given radix.

A ‘radix’ here is sometimes also called a ‘base’. A radix of twoindicates a binary number, a radix of ten, decimal, and a radix ofsixteen, hexadecimal, to give some common values. Arbitraryradices are supported.

‘Digit’ is defined to be only the following characters:

• 0-9
• a-z
• A-Z

§Errors

ReturnsNone if thechar does not refer to a digit in the given radix.

§Panics

Panics if given a radix smaller than 2 or larger than 36.

§Examples

Basic usage:

assert_eq!('1'.to_digit(10),Some(1));assert_eq!('f'.to_digit(16),Some(15));

Passing a non-digit results in failure:

assert_eq!('f'.to_digit(10),None);assert_eq!('z'.to_digit(16),None);

Passing a large radix, causing a panic:

// this panicslet _='1'.to_digit(37);

Passing a small radix, causing a panic:

// this panicslet _='1'.to_digit(1);

Returns an iterator that yields the hexadecimal Unicode escape of acharacter aschars.

This will escape characters with the Rust syntax of the form\u{NNNNNN} whereNNNNNN is a hexadecimal representation.

§Examples

As an iterator:

forcin'❤'.escape_unicode() {print!("{c}");}println!();

Usingprintln! directly:

println!("{}",'❤'.escape_unicode());

Both are equivalent to:

println!("\\u{{2764}}");

Usingto_string:

assert_eq!('❤'.escape_unicode().to_string(),"\\u{2764}");

Returns an iterator that yields the literal escape code of a characteraschars.

This will escape the characters similar to theDebug implementationsofstr orchar.

§Examples

As an iterator:

forcin'\n'.escape_debug() {print!("{c}");}println!();

Usingprintln! directly:

println!("{}",'\n'.escape_debug());

Both are equivalent to:

println!("\\n");

Usingto_string:

assert_eq!('\n'.escape_debug().to_string(),"\\n");

Returns an iterator that yields the literal escape code of a characteraschars.

The default is chosen with a bias toward producing literals that arelegal in a variety of languages, including C++11 and similar C-familylanguages. The exact rules are:

• Tab is escaped as\t.
• Carriage return is escaped as\r.
• Line feed is escaped as\n.
• Single quote is escaped as\'.
• Double quote is escaped as\".
• Backslash is escaped as\\.
• Any character in the ‘printable ASCII’ range0x20 ..0x7einclusive is not escaped.
• All other characters are given hexadecimal Unicode escapes; seeescape_unicode.

§Examples

As an iterator:

forcin'"'.escape_default() {print!("{c}");}println!();

Usingprintln! directly:

println!("{}",'"'.escape_default());

Both are equivalent to:

println!("\\\"");

Usingto_string:

assert_eq!('"'.escape_default().to_string(),"\\\"");

Returns the number of bytes thischar would need if encoded in UTF-8.

That number of bytes is always between 1 and 4, inclusive.

§Examples

Basic usage:

letlen ='A'.len_utf8();assert_eq!(len,1);letlen ='ß'.len_utf8();assert_eq!(len,2);letlen ='ℝ'.len_utf8();assert_eq!(len,3);letlen ='💣'.len_utf8();assert_eq!(len,4);

The&str type guarantees that its contents are UTF-8, and so we can compare the length itwould take if each code point was represented as achar vs in the&str itself:

// as charsleteastern ='東';letcapital ='京';// both can be represented as three bytesassert_eq!(3, eastern.len_utf8());assert_eq!(3, capital.len_utf8());// as a &str, these two are encoded in UTF-8lettokyo ="東京";letlen = eastern.len_utf8() + capital.len_utf8();// we can see that they take six bytes total...assert_eq!(6, tokyo.len());// ... just like the &strassert_eq!(len, tokyo.len());

Returns the number of 16-bit code units thischar would need ifencoded in UTF-16.

That number of code units is always either 1 or 2, for unicode scalar values inthebasic multilingual plane orsupplementary planes respectively.

See the documentation forlen_utf8() for more explanation of thisconcept. This function is a mirror, but for UTF-16 instead of UTF-8.

§Examples

Basic usage:

letn ='ß'.len_utf16();assert_eq!(n,1);letlen ='💣'.len_utf16();assert_eq!(len,2);

Encodes this character as UTF-8 into the provided byte buffer,and then returns the subslice of the buffer that contains the encoded character.

§Panics

Panics if the buffer is not large enough.A buffer of length four is large enough to encode anychar.

§Examples

In both of these examples, ‘ß’ takes two bytes to encode.

letmutb = [0;2];letresult ='ß'.encode_utf8(&mutb);assert_eq!(result,"ß");assert_eq!(result.len(),2);

A buffer that’s too small:

letmutb = [0;1];// this panics'ß'.encode_utf8(&mutb);

Encodes this character as native endian UTF-16 into the providedu16 buffer,and then returns the subslice of the buffer that contains the encoded character.

§Panics

Panics if the buffer is not large enough.A buffer of length 2 is large enough to encode anychar.

§Examples

In both of these examples, ‘𝕊’ takes twou16s to encode.

letmutb = [0;2];letresult ='𝕊'.encode_utf16(&mutb);assert_eq!(result.len(),2);

A buffer that’s too small:

letmutb = [0;1];// this panics'𝕊'.encode_utf16(&mutb);

Returnstrue if thischar has theAlphabetic property.

Alphabetic is described in Chapter 4 (Character Properties) of theUnicode Standard andspecified in theUnicode Character DatabaseDerivedCoreProperties.txt.

§Examples

Basic usage:

assert!('a'.is_alphabetic());assert!('京'.is_alphabetic());letc ='💝';// love is many things, but it is not alphabeticassert!(!c.is_alphabetic());

Returnstrue if thischar has theLowercase property.

Lowercase is described in Chapter 4 (Character Properties) of theUnicode Standard andspecified in theUnicode Character DatabaseDerivedCoreProperties.txt.

§Examples

Basic usage:

assert!('a'.is_lowercase());assert!('δ'.is_lowercase());assert!(!'A'.is_lowercase());assert!(!'Δ'.is_lowercase());// The various Chinese scripts and punctuation do not have case, and so:assert!(!'中'.is_lowercase());assert!(!' '.is_lowercase());

In a const context:

constCAPITAL_DELTA_IS_LOWERCASE: bool ='Δ'.is_lowercase();assert!(!CAPITAL_DELTA_IS_LOWERCASE);

Returnstrue if thischar has theUppercase property.

Uppercase is described in Chapter 4 (Character Properties) of theUnicode Standard andspecified in theUnicode Character DatabaseDerivedCoreProperties.txt.

§Examples

Basic usage:

assert!(!'a'.is_uppercase());assert!(!'δ'.is_uppercase());assert!('A'.is_uppercase());assert!('Δ'.is_uppercase());// The various Chinese scripts and punctuation do not have case, and so:assert!(!'中'.is_uppercase());assert!(!' '.is_uppercase());

In a const context:

constCAPITAL_DELTA_IS_UPPERCASE: bool ='Δ'.is_uppercase();assert!(CAPITAL_DELTA_IS_UPPERCASE);

Returnstrue if thischar has theWhite_Space property.

White_Space is specified in theUnicode Character DatabasePropList.txt.

§Examples

Basic usage:

assert!(' '.is_whitespace());// line breakassert!('\n'.is_whitespace());// a non-breaking spaceassert!('\u{A0}'.is_whitespace());assert!(!'越'.is_whitespace());

Returnstrue if thischar satisfies eitheris_alphabetic() oris_numeric().

§Examples

Basic usage:

assert!('٣'.is_alphanumeric());assert!('7'.is_alphanumeric());assert!('৬'.is_alphanumeric());assert!('¾'.is_alphanumeric());assert!('①'.is_alphanumeric());assert!('K'.is_alphanumeric());assert!('و'.is_alphanumeric());assert!('藏'.is_alphanumeric());

Returnstrue if thischar has the general category for control codes.

Control codes (code points with the general category ofCc) are described in Chapter 4(Character Properties) of theUnicode Standard and specified in theUnicode CharacterDatabaseUnicodeData.txt.

§Examples

Basic usage:

// U+009C, STRING TERMINATORassert!('œ'.is_control());assert!(!'q'.is_control());

Returnstrue if thischar has one of the general categories for numbers.

The general categories for numbers (Nd for decimal digits,Nl for letter-like numericcharacters, andNo for other numeric characters) are specified in theUnicode CharacterDatabaseUnicodeData.txt.

This method doesn’t cover everything that could be considered a number, e.g. ideographic numbers like ‘三’.If you want everything including characters with overlapping purposes then you might want to usea unicode or language-processing library that exposes the appropriate character properties insteadof looking at the unicode categories.

If you want to parse ASCII decimal digits (0-9) or ASCII base-N, useis_ascii_digit oris_digit instead.

§Examples

Basic usage:

assert!('٣'.is_numeric());assert!('7'.is_numeric());assert!('৬'.is_numeric());assert!('¾'.is_numeric());assert!('①'.is_numeric());assert!(!'K'.is_numeric());assert!(!'و'.is_numeric());assert!(!'藏'.is_numeric());assert!(!'三'.is_numeric());

Returns an iterator that yields the lowercase mapping of thischar as one or morechars.

If thischar does not have a lowercase mapping, the iterator yields the samechar.

If thischar has a one-to-one lowercase mapping given by theUnicode CharacterDatabaseUnicodeData.txt, the iterator yields thatchar.

If thischar requires special considerations (e.g. multiplechars) the iterator yieldsthechar(s) given bySpecialCasing.txt.

This operation performs an unconditional mapping without tailoring. That is, the conversionis independent of context and language.

In theUnicode Standard, Chapter 4 (Character Properties) discusses case mapping ingeneral and Chapter 3 (Conformance) discusses the default algorithm for case conversion.

§Examples

As an iterator:

forcin'İ'.to_lowercase() {print!("{c}");}println!();

Usingprintln! directly:

println!("{}",'İ'.to_lowercase());

Both are equivalent to:

println!("i\u{307}");

Usingto_string:

assert_eq!('C'.to_lowercase().to_string(),"c");// Sometimes the result is more than one character:assert_eq!('İ'.to_lowercase().to_string(),"i\u{307}");// Characters that do not have both uppercase and lowercase// convert into themselves.assert_eq!('山'.to_lowercase().to_string(),"山");

Returns an iterator that yields the uppercase mapping of thischar as one or morechars.

If thischar does not have an uppercase mapping, the iterator yields the samechar.

If thischar has a one-to-one uppercase mapping given by theUnicode CharacterDatabaseUnicodeData.txt, the iterator yields thatchar.

If thischar requires special considerations (e.g. multiplechars) the iterator yieldsthechar(s) given bySpecialCasing.txt.

This operation performs an unconditional mapping without tailoring. That is, the conversionis independent of context and language.

In theUnicode Standard, Chapter 4 (Character Properties) discusses case mapping ingeneral and Chapter 3 (Conformance) discusses the default algorithm for case conversion.

§Examples

As an iterator:

forcin'ß'.to_uppercase() {print!("{c}");}println!();

Usingprintln! directly:

println!("{}",'ß'.to_uppercase());

Both are equivalent to:

println!("SS");

Usingto_string:

assert_eq!('c'.to_uppercase().to_string(),"C");// Sometimes the result is more than one character:assert_eq!('ß'.to_uppercase().to_string(),"SS");// Characters that do not have both uppercase and lowercase// convert into themselves.assert_eq!('山'.to_uppercase().to_string(),"山");

§Note on locale

In Turkish, the equivalent of ‘i’ in Latin has five forms instead of two:

• ‘Dotless’: I / ı, sometimes written ï
• ‘Dotted’: İ / i

Note that the lowercase dotted ‘i’ is the same as the Latin. Therefore:

letupper_i ='i'.to_uppercase().to_string();

The value ofupper_i here relies on the language of the text: if we’reinen-US, it should be"I", but if we’re intr_TR, it shouldbe"İ".to_uppercase() does not take this into account, and so:

letupper_i ='i'.to_uppercase().to_string();assert_eq!(upper_i,"I");

holds across languages.

Checks if the value is within the ASCII range.

§Examples

letascii ='a';letnon_ascii ='❤';assert!(ascii.is_ascii());assert!(!non_ascii.is_ascii());

ReturnsSome if the value is within the ASCII range,orNone if it’s not.

This is preferred toSelf::is_ascii when you’re passing the valuealong to something else that can takeascii::Char rather thanneeding to check again for itself whether the value is in ASCII.

Converts this char into anASCII character, withoutchecking whether it is valid.

§Safety

This char must be within the ASCII range, or else this is UB.

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

ASCII letters ‘a’ to ‘z’ are mapped to ‘A’ to ‘Z’,but non-ASCII letters are unchanged.

To uppercase the value in-place, usemake_ascii_uppercase().

To uppercase ASCII characters in addition to non-ASCII characters, useto_uppercase().

§Examples

letascii ='a';letnon_ascii ='❤';assert_eq!('A', ascii.to_ascii_uppercase());assert_eq!('❤', non_ascii.to_ascii_uppercase());

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

ASCII letters ‘A’ to ‘Z’ are mapped to ‘a’ to ‘z’,but non-ASCII letters are unchanged.

To lowercase the value in-place, usemake_ascii_lowercase().

To lowercase ASCII characters in addition to non-ASCII characters, useto_lowercase().

§Examples

letascii ='A';letnon_ascii ='❤';assert_eq!('a', ascii.to_ascii_lowercase());assert_eq!('❤', non_ascii.to_ascii_lowercase());

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

Equivalent toto_ascii_lowercase(a) ==to_ascii_lowercase(b).

§Examples

letupper_a ='A';letlower_a ='a';letlower_z ='z';assert!(upper_a.eq_ignore_ascii_case(&lower_a));assert!(upper_a.eq_ignore_ascii_case(&upper_a));assert!(!upper_a.eq_ignore_ascii_case(&lower_z));

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

ASCII letters ‘a’ to ‘z’ are mapped to ‘A’ to ‘Z’,but non-ASCII letters are unchanged.

To return a new uppercased value without modifying the existing one, useto_ascii_uppercase().

§Examples

letmutascii ='a';ascii.make_ascii_uppercase();assert_eq!('A', ascii);

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

ASCII letters ‘A’ to ‘Z’ are mapped to ‘a’ to ‘z’,but non-ASCII letters are unchanged.

To return a new lowercased value without modifying the existing one, useto_ascii_lowercase().

§Examples

letmutascii ='A';ascii.make_ascii_lowercase();assert_eq!('a', ascii);

Checks if the value is an ASCII alphabetic character:

• U+0041 ‘A’ ..= U+005A ‘Z’, or
• U+0061 ‘a’ ..= U+007A ‘z’.

§Examples

letuppercase_a ='A';letuppercase_g ='G';leta ='a';letg ='g';letzero ='0';letpercent ='%';letspace =' ';letlf ='\n';letesc ='\x1b';assert!(uppercase_a.is_ascii_alphabetic());assert!(uppercase_g.is_ascii_alphabetic());assert!(a.is_ascii_alphabetic());assert!(g.is_ascii_alphabetic());assert!(!zero.is_ascii_alphabetic());assert!(!percent.is_ascii_alphabetic());assert!(!space.is_ascii_alphabetic());assert!(!lf.is_ascii_alphabetic());assert!(!esc.is_ascii_alphabetic());

Checks if the value is an ASCII uppercase character:U+0041 ‘A’ ..= U+005A ‘Z’.

§Examples

letuppercase_a ='A';letuppercase_g ='G';leta ='a';letg ='g';letzero ='0';letpercent ='%';letspace =' ';letlf ='\n';letesc ='\x1b';assert!(uppercase_a.is_ascii_uppercase());assert!(uppercase_g.is_ascii_uppercase());assert!(!a.is_ascii_uppercase());assert!(!g.is_ascii_uppercase());assert!(!zero.is_ascii_uppercase());assert!(!percent.is_ascii_uppercase());assert!(!space.is_ascii_uppercase());assert!(!lf.is_ascii_uppercase());assert!(!esc.is_ascii_uppercase());

Checks if the value is an ASCII lowercase character:U+0061 ‘a’ ..= U+007A ‘z’.

§Examples

letuppercase_a ='A';letuppercase_g ='G';leta ='a';letg ='g';letzero ='0';letpercent ='%';letspace =' ';letlf ='\n';letesc ='\x1b';assert!(!uppercase_a.is_ascii_lowercase());assert!(!uppercase_g.is_ascii_lowercase());assert!(a.is_ascii_lowercase());assert!(g.is_ascii_lowercase());assert!(!zero.is_ascii_lowercase());assert!(!percent.is_ascii_lowercase());assert!(!space.is_ascii_lowercase());assert!(!lf.is_ascii_lowercase());assert!(!esc.is_ascii_lowercase());

Checks if the value is an ASCII alphanumeric character:

• U+0041 ‘A’ ..= U+005A ‘Z’, or
• U+0061 ‘a’ ..= U+007A ‘z’, or
• U+0030 ‘0’ ..= U+0039 ‘9’.

§Examples

letuppercase_a ='A';letuppercase_g ='G';leta ='a';letg ='g';letzero ='0';letpercent ='%';letspace =' ';letlf ='\n';letesc ='\x1b';assert!(uppercase_a.is_ascii_alphanumeric());assert!(uppercase_g.is_ascii_alphanumeric());assert!(a.is_ascii_alphanumeric());assert!(g.is_ascii_alphanumeric());assert!(zero.is_ascii_alphanumeric());assert!(!percent.is_ascii_alphanumeric());assert!(!space.is_ascii_alphanumeric());assert!(!lf.is_ascii_alphanumeric());assert!(!esc.is_ascii_alphanumeric());

Checks if the value is an ASCII decimal digit:U+0030 ‘0’ ..= U+0039 ‘9’.

§Examples

letuppercase_a ='A';letuppercase_g ='G';leta ='a';letg ='g';letzero ='0';letpercent ='%';letspace =' ';letlf ='\n';letesc ='\x1b';assert!(!uppercase_a.is_ascii_digit());assert!(!uppercase_g.is_ascii_digit());assert!(!a.is_ascii_digit());assert!(!g.is_ascii_digit());assert!(zero.is_ascii_digit());assert!(!percent.is_ascii_digit());assert!(!space.is_ascii_digit());assert!(!lf.is_ascii_digit());assert!(!esc.is_ascii_digit());

Checks if the value is an ASCII octal digit:U+0030 ‘0’ ..= U+0037 ‘7’.

§Examples

#![feature(is_ascii_octdigit)]letuppercase_a ='A';leta ='a';letzero ='0';letseven ='7';letnine ='9';letpercent ='%';letlf ='\n';assert!(!uppercase_a.is_ascii_octdigit());assert!(!a.is_ascii_octdigit());assert!(zero.is_ascii_octdigit());assert!(seven.is_ascii_octdigit());assert!(!nine.is_ascii_octdigit());assert!(!percent.is_ascii_octdigit());assert!(!lf.is_ascii_octdigit());

Checks if the value is an ASCII hexadecimal digit:

• U+0030 ‘0’ ..= U+0039 ‘9’, or
• U+0041 ‘A’ ..= U+0046 ‘F’, or
• U+0061 ‘a’ ..= U+0066 ‘f’.

§Examples

letuppercase_a ='A';letuppercase_g ='G';leta ='a';letg ='g';letzero ='0';letpercent ='%';letspace =' ';letlf ='\n';letesc ='\x1b';assert!(uppercase_a.is_ascii_hexdigit());assert!(!uppercase_g.is_ascii_hexdigit());assert!(a.is_ascii_hexdigit());assert!(!g.is_ascii_hexdigit());assert!(zero.is_ascii_hexdigit());assert!(!percent.is_ascii_hexdigit());assert!(!space.is_ascii_hexdigit());assert!(!lf.is_ascii_hexdigit());assert!(!esc.is_ascii_hexdigit());

Checks if the value is an ASCII punctuation character:

• U+0021 ..= U+002F! " # $ % & ' ( ) * + , - . /, or
• U+003A ..= U+0040: ; < = > ? @, or
• U+005B ..= U+0060[ \ ] ^ _ `, or
• U+007B ..= U+007E{ | } ~

§Examples

letuppercase_a ='A';letuppercase_g ='G';leta ='a';letg ='g';letzero ='0';letpercent ='%';letspace =' ';letlf ='\n';letesc ='\x1b';assert!(!uppercase_a.is_ascii_punctuation());assert!(!uppercase_g.is_ascii_punctuation());assert!(!a.is_ascii_punctuation());assert!(!g.is_ascii_punctuation());assert!(!zero.is_ascii_punctuation());assert!(percent.is_ascii_punctuation());assert!(!space.is_ascii_punctuation());assert!(!lf.is_ascii_punctuation());assert!(!esc.is_ascii_punctuation());

Checks if the value is an ASCII graphic character:U+0021 ‘!’ ..= U+007E ‘~’.

§Examples

letuppercase_a ='A';letuppercase_g ='G';leta ='a';letg ='g';letzero ='0';letpercent ='%';letspace =' ';letlf ='\n';letesc ='\x1b';assert!(uppercase_a.is_ascii_graphic());assert!(uppercase_g.is_ascii_graphic());assert!(a.is_ascii_graphic());assert!(g.is_ascii_graphic());assert!(zero.is_ascii_graphic());assert!(percent.is_ascii_graphic());assert!(!space.is_ascii_graphic());assert!(!lf.is_ascii_graphic());assert!(!esc.is_ascii_graphic());

Checks if the value is an ASCII whitespace character:U+0020 SPACE, U+0009 HORIZONTAL TAB, U+000A LINE FEED,U+000C FORM FEED, or U+000D CARRIAGE RETURN.

Rust uses the WhatWG Infra Standard’sdefinition of ASCIIwhitespace. There are several other definitions inwide use. For instance,the POSIX locale includesU+000B 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 considersonlySPACE, HORIZONTAL TAB, and LINE FEED as whitespace.

If you are writing a program that will process an existingfile format, check what that format’s definition of whitespace isbefore using this function.

§Examples

letuppercase_a ='A';letuppercase_g ='G';leta ='a';letg ='g';letzero ='0';letpercent ='%';letspace =' ';letlf ='\n';letesc ='\x1b';assert!(!uppercase_a.is_ascii_whitespace());assert!(!uppercase_g.is_ascii_whitespace());assert!(!a.is_ascii_whitespace());assert!(!g.is_ascii_whitespace());assert!(!zero.is_ascii_whitespace());assert!(!percent.is_ascii_whitespace());assert!(space.is_ascii_whitespace());assert!(lf.is_ascii_whitespace());assert!(!esc.is_ascii_whitespace());

Checks if the value is an ASCII control character:U+0000 NUL ..= U+001F UNIT SEPARATOR, or U+007F DELETE.Note that most ASCII whitespace characters are controlcharacters, but SPACE is not.

§Examples

letuppercase_a ='A';letuppercase_g ='G';leta ='a';letg ='g';letzero ='0';letpercent ='%';letspace =' ';letlf ='\n';letesc ='\x1b';assert!(!uppercase_a.is_ascii_control());assert!(!uppercase_g.is_ascii_control());assert!(!a.is_ascii_control());assert!(!g.is_ascii_control());assert!(!zero.is_ascii_control());assert!(!percent.is_ascii_control());assert!(!space.is_ascii_control());assert!(lf.is_ascii_control());assert!(esc.is_ascii_control());

Returns the default value of\x00

Allocates an ownedString from a single character.

§Example

letc: char ='a';lets: String = String::from(c);assert_eq!("a",&s[..]);

Converts achar into au128.

§Examples

letc ='⚙';letu = u128::from(c);assert!(16== size_of_val(&u))

Converts achar into au32.

§Examples

letc ='c';letu = u32::from(c);assert!(4== size_of_val(&u))

Converts achar into au64.

§Examples

letc ='👤';letu = u64::from(c);assert!(8== size_of_val(&u))

Converts au8 into achar.

§Examples

letu =32asu8;letc = char::from(u);assert!(4== size_of_val(&c))

Tries to convert achar into au16.

§Examples

lettrans_rights ='⚧';// U+26A7letninjas ='🥷';// U+1F977assert_eq!(u16::try_from(trans_rights),Ok(0x26A7_u16));assert!(u16::try_from(ninjas).is_err());

Tries to convert achar into au8.

§Examples

leta ='ÿ';// U+00FFletb ='Ā';// U+0100assert_eq!(u8::try_from(a),Ok(0xFF_u8));assert!(u8::try_from(b).is_err());

Returns the argument unchanged.

CallsU::from(self).

That is, this conversion is whatever the implementation ofFrom<T> for U chooses to do.