Enum regex_syntax::ast::parse::Primitive

enum Primitive {
    Literal(Literal),
    Assertion(Assertion),
    Dot(Span),
    Perl(ClassPerl),
    Unicode(ClassUnicode),
}

A primitive is an expression with no sub-expressions. This includes literals, assertions and non-set character classes. This representation is used as intermediate state in the parser.

This does not include ASCII character classes, since they can only appear within a set character class.

Variants

Literal(Literal)

Assertion(Assertion)

Dot(Span)

Perl(ClassPerl)

Unicode(ClassUnicode)

Implementations

impl Primitive

fn span(&self) -> &Span

Return the span of this primitive.

fn into_ast(self) -> Ast

Convert this primitive into a proper AST.

fn into_class_set_item<P: Borrow<Parser>>( self, p: &ParserI<'_, P>, ) -> Result<ClassSetItem, Error>

Convert this primitive into an item in a character class.

If this primitive is not a legal item (i.e., an assertion or a dot), then return an error.

fn into_class_literal<P: Borrow<Parser>>( self, p: &ParserI<'_, P>, ) -> Result<Literal, Error>

Convert this primitive into a literal in a character class. In particular, literals are the only valid items that can appear in ranges.

If this primitive is not a legal item (i.e., a class, assertion or a dot), then return an error.

Trait Implementations

impl Clone for Primitive

fn clone(&self) -> Primitive

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Primitive

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

Formats the value using the given formatter.

impl PartialEq for Primitive

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

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

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

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

impl Eq for Primitive

impl StructuralPartialEq for Primitive