Struct PrefixExpr 

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

Prefix unary operator expression.

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

Allows zero or more prefix operators before an operand. Multiple prefix operators are applied right-to-left (innermost first). For example, --x is parsed as -(-x) (two negations).

Type Parameters

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

Examples

unsynn! {
    type Number = LiteralInteger;
}

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

// Limit prefix depth
type LimitedPrefix = PrefixExpr<Minus, Number, 3>;  // Max 3 prefix operators

Fields

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

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

operand: Operand

The operand that the operators apply to

Implementations

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

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

Create a new PrefixExpr with the given operators and operand.

Trait Implementations

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

where Operator: Clone, Operand: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

where Operator: Debug, Operand: Debug,

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

Formats the value using the given formatter.

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

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

fn parser( tokens: &mut TokenIter, ) -> Result<PrefixExpr<Operator, Operand, 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<Operator, Operand, const MAX: usize> ToTokens for PrefixExpr<Operator, Operand, MAX>

where Operator: ToTokens, Operand: 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.