Enum regex_syntax::ast::LiteralKind

pub enum LiteralKind {
    Verbatim,
    Meta,
    Superfluous,
    Octal,
    HexFixed(HexLiteralKind),
    HexBrace(HexLiteralKind),
    Special(SpecialLiteralKind),
}

The kind of a single literal expression.

Variants

Verbatim

The literal is written verbatim, e.g., a or ☃.

Meta

The literal is written as an escape because it is otherwise a special regex meta character, e.g., \* or \[.

Superfluous

The literal is written as an escape despite the fact that the escape is unnecessary, e.g., \% or \/.

Octal

The literal is written as an octal escape, e.g., \141.

HexFixed(HexLiteralKind)

The literal is written as a hex code with a fixed number of digits depending on the type of the escape, e.g., \x61 or or \u0061 or \U00000061.

HexBrace(HexLiteralKind)

The literal is written as a hex code with a bracketed number of digits. The only restriction is that the bracketed hex code must refer to a valid Unicode scalar value.

Special(SpecialLiteralKind)

The literal is written as a specially recognized escape, e.g., \f or \n.

Trait Implementations

impl Clone for LiteralKind

fn clone(&self) -> LiteralKind

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for LiteralKind

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

Formats the value using the given formatter.

impl PartialEq<LiteralKind> for LiteralKind

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

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

const fn ne(&self, other: &Rhs) -> bool

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

impl Eq for LiteralKind

impl StructuralEq for LiteralKind

impl StructuralPartialEq for LiteralKind