Enum Punctuation 

pub enum Punctuation {
    Eq(Eq),
    Lt(Lt),
    Le(Le),
    EqEq(EqEq),
    Ne(Ne),
    Ge(Ge),
    Gt(Gt),
    AndAnd(AndAnd),
    OrOr(OrOr),
    Not(Not),
    Tilde(Tilde),
    Plus(Plus),
    Minus(Minus),
    Star(Star),
    Slash(Slash),
    Percent(Percent),
    Caret(Caret),
    And(And),
    Or(Or),
    Shl(Shl),
    Shr(Shr),
    PlusEq(PlusEq),
    MinusEq(MinusEq),
    StarEq(StarEq),
    SlashEq(SlashEq),
    PercentEq(PercentEq),
    CaretEq(CaretEq),
    AndEq(AndEq),
    OrEq(OrEq),
    ShlEq(ShlEq),
    ShrEq(ShrEq),
    At(At),
    Dot(Dot),
    DotDot(DotDot),
    DotDotDot(DotDotDot),
    DotDotEq(DotDotEq),
    Comma(Comma),
    Semi(Semi),
    Colon(Colon),
    PathSep(PathSep),
    RArrow(RArrow),
    LArrow(LArrow),
    FatArrow(FatArrow),
    Pound(Pound),
    Dollar(Dollar),
    Question(Question),
    Underscore(Underscore),
    ParenOpen(ParenOpen),
    ParenClose(ParenClose),
    BracketOpen(BracketOpen),
    BracketClose(BracketClose),
    BracesOpen(BracesOpen),
    BracesClose(BracesClose),
}

Punctuation

Variants

Eq(Eq)

Lt(Lt)

Le(Le)

EqEq(EqEq)

Ne(Ne)

Ge(Ge)

Gt(Gt)

AndAnd(AndAnd)

OrOr(OrOr)

Not(Not)

Tilde(Tilde)

Plus(Plus)

Minus(Minus)

Star(Star)

Slash(Slash)

Percent(Percent)

Caret(Caret)

And(And)

Or(Or)

Shl(Shl)

Shr(Shr)

PlusEq(PlusEq)

MinusEq(MinusEq)

StarEq(StarEq)

SlashEq(SlashEq)

PercentEq(PercentEq)

CaretEq(CaretEq)

AndEq(AndEq)

OrEq(OrEq)

ShlEq(ShlEq)

ShrEq(ShrEq)

At(At)

Dot(Dot)

DotDot(DotDot)

DotDotDot(DotDotDot)

DotDotEq(DotDotEq)

Comma(Comma)

Semi(Semi)

Colon(Colon)

PathSep(PathSep)

RArrow(RArrow)

LArrow(LArrow)

FatArrow(FatArrow)

Pound(Pound)

Dollar(Dollar)

Question(Question)

Underscore(Underscore)

ParenOpen(ParenOpen)

ParenClose(ParenClose)

BracketOpen(BracketOpen)

BracketClose(BracketClose)

BracesOpen(BracesOpen)

BracesClose(BracesClose)

Trait Implementations

impl Clone for Punctuation

fn clone(&self) -> Punctuation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Punctuation

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Punctuation

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Format<WhitespaceConfig, ()> for Punctuation

fn format( &mut self, ctx: &mut Context<'_>, prefix_ws: WhitespaceConfig, args: (), ) -> FormatOutput

Formats this type.

impl Formattable for Punctuation

fn with_prefix_ws<WITH_PREFIX_WS_O>( &mut self, ctx: &mut Context<'_>, f: &mut impl FnMut(&mut Whitespace, &mut Context<'_>) -> WITH_PREFIX_WS_O, ) -> Result<WITH_PREFIX_WS_O, ControlFlow<()>>

Accesses the prefix whitespace of this type.

fn with_strings<WITH_STRINGS_O>( &mut self, ctx: &mut Context<'_>, exclude_prefix_ws: bool, f: &mut impl FnMut(&mut AstStr, &mut Context<'_>) -> ControlFlow<WITH_STRINGS_O>, ) -> ControlFlow<WITH_STRINGS_O, bool>

Iterates over all strings in this type.

fn format_output(&mut self, ctx: &mut Context<'_>) -> FormatOutput

Returns the formatting output for this type, without formatting it.

fn prefix_ws_is_pure(&mut self, ctx: &mut Context<'_>) -> Option<bool>

Returns if the prefix whitespace is pure.

fn prefix_ws_join_prefix( &mut self, ctx: &mut Context<'_>, ws: Whitespace, ) -> Result<(), Whitespace>

Joins a string as a prefix onto the prefix whitespace of this type.

impl Parse for Punctuation

type Error = PunctuationError

Error type

fn parse_from(parser: &mut Parser) -> Result<Self, Self::Error>

Parses this type from input, mutating it in-place.

fn name() -> Option<impl Display>

A name for this type.

impl PartialEq for Punctuation

fn eq(&self, other: &Punctuation) -> 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 Print for Punctuation

fn print(&self, f: &mut PrintFmt)

Prints this type onto a writer

fn print_non_ws(&self, f: &mut PrintFmt)

Prints this type onto a writer excluding whitespace

fn print_to(&self, p: impl FnOnce(&Self, &mut PrintFmt)) -> PrintOutput

Prints this type using p as the printer function and returns the output

impl Serialize for Punctuation

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Punctuation

impl StructuralPartialEq for Punctuation