Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://doc.rust-lang.org/nightly/std/ascii/enum.Char.html below:

Char in std::ascii - Rust

#[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,
}

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.

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 strs, not limit yourself to ascii::Chars.

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::Chars 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 strs.

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].

This type is guaranteed to have a size and alignment of 1 byte.

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, as CAPITAL/SMALL suffices in this block.
• DIGITs use a single digit rather than writing out ZERO, ONE, etc.

U+0000 (The default variant)

U+0001

U+0002

U+0003

U+0004

U+0005

U+0006

U+0007

U+0008

U+0009

U+000A

U+000B

U+000C

U+000D

U+000E

U+000F

U+0010

U+0011

U+0012

U+0013

U+0014

U+0015

U+0016

U+0017

U+0018

U+0019

U+001A

U+001B

U+001C

U+001D

U+001E

U+001F

U+0020

U+0021

U+0022

U+0023

U+0024

U+0025

U+0026

U+0027

U+0028

U+0029

U+002A

U+002B

U+002C

U+002D

U+002E

U+002F

U+0030

U+0031

U+0032

U+0033

U+0034

U+0035

U+0036

U+0037

U+0038

U+0039

U+003A

U+003B

U+003C

U+003D

U+003E

U+003F

U+0040

U+0041

U+0042

U+0043

U+0044

U+0045

U+0046

U+0047

U+0048

U+0049

U+004A

U+004B

U+004C

U+004D

U+004E

U+004F

U+0050

U+0051

U+0052

U+0053

U+0054

U+0055

U+0056

U+0057

U+0058

U+0059

U+005A

U+005B

U+005C

U+005D

U+005E

U+005F

U+0060

U+0061

U+0062

U+0063

U+0064

U+0065

U+0066

U+0067

U+0068

U+0069

U+006A

U+006B

U+006C

U+006D

U+006E

U+006F

U+0070

U+0071

U+0072

U+0073

U+0074

U+0075

U+0076

U+0077

U+0078

U+0079

U+007A

U+007B

U+007C

U+007D

U+007E

U+007F

The character with the lowest ASCII code.

The character with the highest ASCII code.

Creates an ASCII character from the byte b, or returns None if it’s too large.

Creates an ASCII character from the byte b, without checking whether it’s valid.

b must be in 0..=127, or else this is UB.

When passed the number 0, 1, …, 9, returns the character '0', '1', …, '9' respectively.

If d >= 10, returns None.

When passed the number 0, 1, …, 9, returns the character '0', '1', …, '9' respectively, without checking that it’s in-range.

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.)

Gets this ASCII character as a byte.

Gets this ASCII character as a char Unicode Scalar Value.

Views this ASCII character as a one-code-unit UTF-8 str.

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.

#![feature(ascii_char, ascii_char_variants)]
use std::ascii;

let lowercase_a = ascii::Char::SmallA;

assert_eq!(
    ascii::Char::CapitalA,
    lowercase_a.to_uppercase(),
);

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.

#![feature(ascii_char, ascii_char_variants)]
use std::ascii;

let uppercase_a = ascii::Char::CapitalA;

assert_eq!(
    ascii::Char::SmallA,
    uppercase_a.to_lowercase(),
);

Checks that two values are a case-insensitive match.

This is equivalent to to_lowercase(a) == to_lowercase(b).

#![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));

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.

#![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);

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.

#![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);

Checks if the value is an alphabetic character:

• 0x41 ‘A’ ..= 0x5A ‘Z’, or
• 0x61 ‘a’ ..= 0x7A ‘z’.

#![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());

Checks if the value is an uppercase character: 0x41 ‘A’ ..= 0x5A ‘Z’.

#![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());

Checks if the value is a lowercase character: 0x61 ‘a’ ..= 0x7A ‘z’.

#![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());

Checks if the value is an alphanumeric character:

• 0x41 ‘A’ ..= 0x5A ‘Z’, or
• 0x61 ‘a’ ..= 0x7A ‘z’, or
• 0x30 ‘0’ ..= 0x39 ‘9’.

#![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());

Checks if the value is a decimal digit: 0x30 ‘0’ ..= 0x39 ‘9’.

#![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());

Checks if the value is an octal digit: 0x30 ‘0’ ..= 0x37 ‘7’.

#![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());

Checks if the value is a hexadecimal digit:

• 0x30 ‘0’ ..= 0x39 ‘9’, or
• 0x41 ‘A’ ..= 0x46 ‘F’, or
• 0x61 ‘a’ ..= 0x66 ‘f’.

#![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());

Checks if the value is a punctuation character:

• 0x21 ..= 0x2F ! " # $ % & ' ( ) * + , - . /, or
• 0x3A ..= 0x40 : ; < = > ? @, or
• 0x5B ..= 0x60 [ \ ] ^ _ `, or
• 0x7B ..= 0x7E { | } ~

#![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());

Checks if the value is a graphic character: 0x21 ‘!’ ..= 0x7E ‘~’.

#![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());

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.

#![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());

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.

#![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());

Returns an iterator that produces an escaped version of a character.

The behavior is identical to ascii::escape_default.

#![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());

Returns the default value of Null

Extends a collection with the contents of an iterator.

Extends a collection with exactly one element.

Reserves capacity in a collection for the given number of additional elements.

Extends a collection with the contents of an iterator.

Extends a collection with exactly one element.

Reserves capacity in a collection for the given number of additional elements.

Converts to this type from the input type.

Converts to this type from the input type.

Converts to this type from the input type.

Converts to this type from the input type.

Converts to this type from the input type.

Converts to this type from the input type.

Tests for self and other values to be equal, and is used by ==.

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

This method returns an ordering between

and

values if one exists.

Tests less than (for

and

) and is used by the

operator.

Tests less than or equal to (for

and

) and is used by the

operator.

Tests greater than (for

and

) and is used by the

operator.

Tests greater than or equal to (for

and

) and is used by the

operator.

Returns the value that would be obtained by taking the

of

times.

Returns the value that would be obtained by taking the

of

times.

Returns the value that would be obtained by taking the

of

times.

Returns the value that would be obtained by taking the

of

times.

Returns the value that would be obtained by taking the

of

times.

Returns the value that would be obtained by taking the

of

times.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4