Trait Parse 

pub trait Parse<'a>: Sized {
    // Required method
    fn parse(p: &mut Parser<'a>) -> Result<Self>;

    // Provided method
    fn try_parse(p: &mut Parser<'a>) -> Result<Self> { ... }
}

This trait allows AST nodes to construct themselves from a mutable Parser instance.

Nodes that implement this trait are entitled to consume any number of Cursors from Parser in order to construct themselves. They may also consume some amount of tokens and still return an Err - there is no need to try and reset the Parser state on failure (Parser::try_parse() exists for this reason).

When wanting to parse child nodes, implementations should not call Parse::parse() directly. Instead - call Parser::parse<T>(). Other convenience methods such as Parser::parse_if_peek<T>() and Parser::try_parse<T>() exist.

Any node implementing Parse::parse() gets Parse::try_parse() for free. It’s unlikely that nodes can come up with a more efficient algorithm than the provided one, so it is not worth re-implementing Parse::try_parse().

If a Node can construct itself from a single Cursor it should implement Peek and Parse, where Parse::parse() calls Parser::next() and constructs from the cursor.

Required Methods

fn parse(p: &mut Parser<'a>) -> Result<Self>

Provided Methods

fn try_parse(p: &mut Parser<'a>) -> Result<Self>

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<'a, A, B> Parse<'a> for (A, B)

where A: Parse<'a>, B: Parse<'a>,

fn parse(p: &mut Parser<'a>) -> Result<Self>

impl<'a, A, B, C> Parse<'a> for (A, B, C)

where A: Parse<'a>, B: Parse<'a>, C: Parse<'a>,

fn parse(p: &mut Parser<'a>) -> Result<Self>

impl<'a, A, B, C, D> Parse<'a> for (A, B, C, D)

where A: Parse<'a>, B: Parse<'a>, C: Parse<'a>, D: Parse<'a>,

fn parse(p: &mut Parser<'a>) -> Result<Self>

impl<'a, A, B, C, D, E> Parse<'a> for (A, B, C, D, E)

where A: Parse<'a>, B: Parse<'a>, C: Parse<'a>, D: Parse<'a>, E: Parse<'a>,

fn parse(p: &mut Parser<'a>) -> Result<Self>

impl<'a, A, B, C, D, E, F> Parse<'a> for (A, B, C, D, E, F)

where A: Parse<'a>, B: Parse<'a>, C: Parse<'a>, D: Parse<'a>, E: Parse<'a>, F: Parse<'a>,

fn parse(p: &mut Parser<'a>) -> Result<Self>

impl<'a, A, B, C, D, E, F, G> Parse<'a> for (A, B, C, D, E, F, G)

where A: Parse<'a>, B: Parse<'a>, C: Parse<'a>, D: Parse<'a>, E: Parse<'a>, F: Parse<'a>, G: Parse<'a>,

fn parse(p: &mut Parser<'a>) -> Result<Self>

impl<'a, A, B, C, D, E, F, G, H> Parse<'a> for (A, B, C, D, E, F, G, H)

where A: Parse<'a>, B: Parse<'a>, C: Parse<'a>, D: Parse<'a>, E: Parse<'a>, F: Parse<'a>, G: Parse<'a>, H: Parse<'a>,

fn parse(p: &mut Parser<'a>) -> Result<Self>

impl<'a, A, B, C, D, E, F, G, H, I> Parse<'a> for (A, B, C, D, E, F, G, H, I)

where A: Parse<'a>, B: Parse<'a>, C: Parse<'a>, D: Parse<'a>, E: Parse<'a>, F: Parse<'a>, G: Parse<'a>, H: Parse<'a>, I: Parse<'a>,

fn parse(p: &mut Parser<'a>) -> Result<Self>

impl<'a, A, B, C, D, E, F, G, H, I, J> Parse<'a> for (A, B, C, D, E, F, G, H, I, J)

where A: Parse<'a>, B: Parse<'a>, C: Parse<'a>, D: Parse<'a>, E: Parse<'a>, F: Parse<'a>, G: Parse<'a>, H: Parse<'a>, I: Parse<'a>, J: Parse<'a>,

fn parse(p: &mut Parser<'a>) -> Result<Self>

impl<'a, A, B, C, D, E, F, G, H, I, J, K> Parse<'a> for (A, B, C, D, E, F, G, H, I, J, K)

where A: Parse<'a>, B: Parse<'a>, C: Parse<'a>, D: Parse<'a>, E: Parse<'a>, F: Parse<'a>, G: Parse<'a>, H: Parse<'a>, I: Parse<'a>, J: Parse<'a>, K: Parse<'a>,

fn parse(p: &mut Parser<'a>) -> Result<Self>

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L> Parse<'a> for (A, B, C, D, E, F, G, H, I, J, K, L)

where A: Parse<'a>, B: Parse<'a>, C: Parse<'a>, D: Parse<'a>, E: Parse<'a>, F: Parse<'a>, G: Parse<'a>, H: Parse<'a>, I: Parse<'a>, J: Parse<'a>, K: Parse<'a>, L: Parse<'a>,

fn parse(p: &mut Parser<'a>) -> Result<Self>

impl<'a, T> Parse<'a> for Option<T>

where T: Peek<'a> + Parse<'a>,

fn parse(p: &mut Parser<'a>) -> Result<Self>

impl<'a, T> Parse<'a> for Vec<'a, T>

where T: Peek<'a> + Parse<'a>,

fn parse(p: &mut Parser<'a>) -> Result<Self>

Implementors

impl<'a> Parse<'a> for Comparison

impl<'a> Parse<'a> for ComponentValue<'a>

impl<'a> Parse<'a> for BadDeclaration<'a>

impl<'a> Parse<'a> for BangImportant

impl<'a> Parse<'a> for ComponentValues<'a>

impl<'a> Parse<'a> for FunctionBlock<'a>

impl<'a> Parse<'a> for NoBlockAllowed

impl<'a> Parse<'a> for SimpleBlock<'a>

impl<'a> Parse<'a> for And

impl<'a> Parse<'a> for At

impl<'a> Parse<'a> for Backtick

impl<'a> Parse<'a> for Bang

impl<'a> Parse<'a> for Caret

impl<'a> Parse<'a> for Dash

impl<'a> Parse<'a> for Dollar

impl<'a> Parse<'a> for Dot

impl<'a> Parse<'a> for Eq

impl<'a> Parse<'a> for Gt

impl<'a> Parse<'a> for css_parse::token_macros::delim::Hash

impl<'a> Parse<'a> for Lt

impl<'a> Parse<'a> for Or

impl<'a> Parse<'a> for Percent

impl<'a> Parse<'a> for Plus

impl<'a> Parse<'a> for Question

impl<'a> Parse<'a> for Slash

impl<'a> Parse<'a> for Star

impl<'a> Parse<'a> for Tilde

impl<'a> Parse<'a> for Underscore

impl<'a> Parse<'a> for CaretEqual

impl<'a> Parse<'a> for ColonColon

impl<'a> Parse<'a> for DollarEqual

impl<'a> Parse<'a> for EqualEqual

impl<'a> Parse<'a> for GreaterThanEqual

impl<'a> Parse<'a> for LessThanEqual

impl<'a> Parse<'a> for PipeEqual

impl<'a> Parse<'a> for PipePipe

impl<'a> Parse<'a> for StarEqual

impl<'a> Parse<'a> for StarPipe

impl<'a> Parse<'a> for TildeEqual

impl<'a> Parse<'a> for Any

impl<'a> Parse<'a> for AtKeyword

impl<'a> Parse<'a> for BadString

impl<'a> Parse<'a> for BadUrl

impl<'a> Parse<'a> for CdcOrCdo

impl<'a> Parse<'a> for Colon

impl<'a> Parse<'a> for Comma

impl<'a> Parse<'a> for Comment

impl<'a> Parse<'a> for DashedIdent

impl<'a> Parse<'a> for Delim

impl<'a> Parse<'a> for Dimension

impl<'a> Parse<'a> for Eof

impl<'a> Parse<'a> for Function

impl<'a> Parse<'a> for css_parse::token_macros::Hash

impl<'a> Parse<'a> for Ident

impl<'a> Parse<'a> for LeftCurly

impl<'a> Parse<'a> for LeftParen

impl<'a> Parse<'a> for LeftSquare

impl<'a> Parse<'a> for Number

impl<'a> Parse<'a> for PairWiseEnd

impl<'a> Parse<'a> for PairWiseStart

impl<'a> Parse<'a> for RightCurly

impl<'a> Parse<'a> for RightParen

impl<'a> Parse<'a> for RightSquare

impl<'a> Parse<'a> for Semicolon

impl<'a> Parse<'a> for String

impl<'a> Parse<'a> for Url

impl<'a> Parse<'a> for Whitespace

impl<'a, A, B> Parse<'a> for Optionals2<A, B>

where A: Parse<'a> + Peek<'a>, B: Parse<'a> + Peek<'a>,

impl<'a, A, B, C> Parse<'a> for Optionals3<A, B, C>

where A: Parse<'a> + Peek<'a>, B: Parse<'a> + Peek<'a>, C: Parse<'a> + Peek<'a>,

impl<'a, A, B, C, D> Parse<'a> for Optionals4<A, B, C, D>

where A: Parse<'a> + Peek<'a>, B: Parse<'a> + Peek<'a>, C: Parse<'a> + Peek<'a>, D: Parse<'a> + Peek<'a>,

impl<'a, A, B, C, D, E> Parse<'a> for Optionals5<A, B, C, D, E>

where A: Parse<'a> + Peek<'a>, B: Parse<'a> + Peek<'a>, C: Parse<'a> + Peek<'a>, D: Parse<'a> + Peek<'a>, E: Parse<'a> + Peek<'a>,

impl<'a, D, R> Parse<'a> for Block<'a, D, R>

where D: DeclarationValue<'a>, R: Parse<'a>,

impl<'a, D, R> Parse<'a> for DeclarationRuleList<'a, D, R>

where D: DeclarationValue<'a>, R: Parse<'a>, Declaration<'a, D>: Parse<'a>,

impl<'a, P, D, R> Parse<'a> for QualifiedRule<'a, P, D, R>

where D: DeclarationValue<'a>, P: Parse<'a>, R: Parse<'a>,

A QualifiedRule represents a block with a prelude which may contain other rules. Examples of QualifiedRules are StyleRule, KeyframeRule (no s!).

impl<'a, R: Parse<'a>> Parse<'a> for RuleList<'a, R>

impl<'a, T: Parse<'a> + Peek<'a>, const MIN: usize> Parse<'a> for CommaSeparated<'a, T, MIN>

impl<'a, V: DeclarationValue<'a>> Parse<'a> for Declaration<'a, V>

impl<'a, V: DeclarationValue<'a>> Parse<'a> for DeclarationList<'a, V>