Trait Parse 

pub trait Parse<'a>: Sized {
    // Required method
    fn parse<I>(p: &mut Parser<'a, I>) -> Result<Self>
       where I: Iterator<Item = Cursor> + Clone;

    // Provided method
    fn try_parse<I>(p: &mut Parser<'a, I>) -> Result<Self>
       where I: Iterator<Item = Cursor> + Clone { ... }
}

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<I>(p: &mut Parser<'a, I>) -> Result<Self>

where I: Iterator<Item = Cursor> + Clone,

Provided Methods

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

where I: Iterator<Item = Cursor> + Clone,

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

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<Iter>(p: &mut Parser<'a, Iter>) -> Result<Self>

where Iter: Iterator<Item = Cursor> + Clone,

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<Iter>(p: &mut Parser<'a, Iter>) -> Result<Self>

where Iter: Iterator<Item = Cursor> + Clone,

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<Iter>(p: &mut Parser<'a, Iter>) -> Result<Self>

where Iter: Iterator<Item = Cursor> + Clone,

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<Iter>(p: &mut Parser<'a, Iter>) -> Result<Self>

where Iter: Iterator<Item = Cursor> + Clone,

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<Iter>(p: &mut Parser<'a, Iter>) -> Result<Self>

where Iter: Iterator<Item = Cursor> + Clone,

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<Iter>(p: &mut Parser<'a, Iter>) -> Result<Self>

where Iter: Iterator<Item = Cursor> + Clone,

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<Iter>(p: &mut Parser<'a, Iter>) -> Result<Self>

where Iter: Iterator<Item = Cursor> + Clone,

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<Iter>(p: &mut Parser<'a, Iter>) -> Result<Self>

where Iter: Iterator<Item = Cursor> + Clone,

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<Iter>(p: &mut Parser<'a, Iter>) -> Result<Self>

where Iter: Iterator<Item = Cursor> + Clone,

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

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

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

where Iter: Iterator<Item = Cursor> + Clone,

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

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

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

where Iter: Iterator<Item = Cursor> + Clone,

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

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

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

where Iter: Iterator<Item = Cursor> + Clone,

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

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

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

where Iter: Iterator<Item = Cursor> + Clone,

Implementors

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, 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> 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> Parse<'a> for Optionals2<A, B>

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

impl<'a, D, M> Parse<'a> for NoBlockAllowed<D, M>

impl<'a, D, M> Parse<'a> for UnknownRuleBlock<'a, D, M>

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

where D: DeclarationValue<'a, M>, R: Parse<'a> + NodeWithMetadata<M> + RuleVariants<'a, DeclarationValue = D, Metadata = M>, M: NodeMetadata,

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

where D: DeclarationValue<'a, M>, R: NodeWithMetadata<M> + Parse<'a>, M: NodeMetadata, Declaration<'a, D, M>: Parse<'a>,

impl<'a, Left: Parse<'a> + Peek<'a>, Right: Parse<'a>> Parse<'a> for Either<Left, Right>

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

where D: DeclarationValue<'a, M>, P: Parse<'a>, R: Parse<'a> + NodeWithMetadata<M> + RuleVariants<'a, DeclarationValue = D, Metadata = M>, M: NodeMetadata,

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

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

where R: Parse<'a> + NodeWithMetadata<M>, M: NodeMetadata,

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

impl<'a, T: Parse<'a>> Parse<'a> for BumpBox<'a, T>

impl<'a, V, M> Parse<'a> for Declaration<'a, V, M>

where V: DeclarationValue<'a, M>, M: NodeMetadata,

impl<'a, V, M> Parse<'a> for DeclarationList<'a, V, M>

where V: DeclarationValue<'a, M>, M: NodeMetadata,

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

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

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

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

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

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

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

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

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

impl<'a> Parse<'a> for BangEqual

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a> Parse<'a> for css_parse::token_macros::delim::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 LessThanEqual

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

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

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

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

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

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

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

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

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

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

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 SimpleBlock<'a>

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

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

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

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

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

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

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

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

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

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