Struct PostfixExpr 

pub struct PostfixExpr<Operand, Operator, const MAX: usize = unsynn::::expressions::PostfixExpr::{constant#0}> {
    pub operand: Operand,
    pub operators: DelimitedVec<Operator, Nothing, Mandatory, 0, MAX>,
}

Postfix unary operator expression.

Parses: Operand Op* (operand, then 0 to MAX operators)

Allows zero or more postfix operators after an operand. Multiple postfix operators are applied left-to-right (leftmost first). For example, x?? is parsed as (x?)? (try operators chain left-to-right).

Type Parameters

• Operand: The type of expression that the operators apply to
• Operator: The postfix operator type (typically an enum of different postfix operations)
• MAX: Maximum number of postfix operators (defaults to usize::MAX for unlimited)

Examples

unsynn! {
    type Number = LiteralInteger;
}

// Parse "5 ! !"
let mut tokens = "5 ! !".to_token_iter();
let expr: PostfixExpr<Number, Bang> = tokens.parse().unwrap();
assert_eq!(expr.operators.len(), 2); // 2 Bang operators

// Limit postfix depth
type LimitedPostfix = PostfixExpr<Number, Bang, 3>;  // Max 3 postfix operators

Fields

operand: Operand

The operand that the operators apply to

operators: DelimitedVec<Operator, Nothing, Mandatory, 0, MAX>

The postfix operators (0 to MAX, applied left-to-right)

Implementations

impl<Operand, Operator, const MAX: usize> PostfixExpr<Operand, Operator, MAX>

pub const fn new( operand: Operand, operators: DelimitedVec<Operator, Nothing, Mandatory, 0, MAX>, ) -> PostfixExpr<Operand, Operator, MAX>

Create a new PostfixExpr with the given operand and operators.

Trait Implementations

impl<Operand, Operator, const MAX: usize> Clone for PostfixExpr<Operand, Operator, MAX>

where Operand: Clone, Operator: Clone,

fn clone(&self) -> PostfixExpr<Operand, Operator, MAX>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Operand, Operator, const MAX: usize> Debug for PostfixExpr<Operand, Operator, MAX>

where Operand: Debug, Operator: Debug,

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

Formats the value using the given formatter.

impl<Operand, Operator, const MAX: usize> Parser for PostfixExpr<Operand, Operator, MAX>

where Operand: Parse + ToTokens, Operator: Parse + ToTokens,

fn parser( tokens: &mut TokenIter, ) -> Result<PostfixExpr<Operand, Operator, MAX>, Error>

The actual parsing function that must be implemented. This mutates the tokens iterator directly. It should not be called from user code except for implementing parsers itself and then only when the rules below are followed.

impl<Operand, Operator, const MAX: usize> ToTokens for PostfixExpr<Operand, Operator, MAX>

where Operand: ToTokens, Operator: ToTokens,

fn to_tokens(&self, tokens: &mut TokenStream)

Write &self to the given TokenStream.

fn to_token_iter(&self) -> TokenIter

Convert &self into a TokenIter object.

fn into_token_iter(self) -> TokenIter

where Self: Sized,

Convert self into a TokenIter object.

fn to_token_stream(&self) -> TokenStream

Convert &self into a TokenStream object.

fn into_token_stream(self) -> TokenStream

where Self: Sized,

Convert self into a TokenStream object.

fn tokens_to_string(&self) -> String

Convert &self into a String object. This is mostly used in the test suite to compare the outputs. When the input is a &str then this parses it and returns a normalized String.