Struct UnitParen 

pub struct UnitParen {
    pub open: LParenTok,
    pub close: RParenTok,
}

Unparse for an EMPTY group used as an ordinary field rather than as the target of a #[group(self.x)] — PatBot::Unit { paren: ParenGroup<()> } and its three siblings, which spell () with nothing inside.

syan core has a generic Parse for Group<T, O, C> but no generic Unparse: the only Unparse for Group<..> impls there are the proc_macro2 ones, where a delimited group is a single TokenTree rather than three atoms. A #[group(..)] holder never needs it (it is emitted through GroupUnparse::unparse_group), so the gap only shows up for a holder standing alone as a field, where #[derive(Unparse)] synthesizes an ordinary FieldTy: Unparse<Atom> predicate.

Hence a local node rather than an impl Unparse<Atom> for ParenGroup<()>: Atom is syan::span::WithSpan<Token, Span>, an alias for a FOREIGN type, so nothing in that impl would be local and the orphan rule rejects it (E0117). The fields keep Group’s open/close names, the derived Parse is the same two-token sequence Group’s generic Parse produces, and the delimiters emit in source order, so parse . unparse still round-trips.

Fields

open: LParenTok

close: RParenTok

Trait Implementations

impl Clone for UnitParen

fn clone(&self) -> UnitParen

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for UnitParen

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

Formats the value using the given formatter.

impl<__SyanMacro_Atom> Parse<__SyanMacro_Atom> for UnitParen

where __SyanMacro_Atom: Spanned + Clone, LParenTok: Parse<__SyanMacro_Atom>, RParenTok: Parse<__SyanMacro_Atom>,

type Error = ParseError<<__SyanMacro_Atom as Spanned>::Span>

Every error must be convertible to the universal one, so a field’s failure can become the enclosing type’s failure with no per-field where-predicate. Stating it HERE rather than at each derived impl is what keeps it out of the obligation graph: a per-field <FieldTy as Parse<Atom>>::Error: Into<…> predicate re-creates a projection cycle on a recursive field (E0275), which decycle’s bound-peeling does not break.

fn parse_stream<__SyanMacro_S: ParseStream<Atom = __SyanMacro_Atom>>( __syan_stream: &mut __SyanMacro_S, ) -> Result<Self, Self::Error>

Parse from a reborrowable stream.

fn parse(stream: impl IntoParseStream<Atom = Atom>) -> Result<Self, Self::Error>

Parse from anything that can become a stream — String, TokenStream, an existing stream.

fn attempt(self) -> Attempt<Self>

Wrap this value in Attempt, the atomic-parse marker: parsing an Attempt<Self> parses Self but rewinds the stream on failure (it requires Atom: Clone). This is the value constructor; value.attempt() is sugar for Attempt(value).

impl PartialEq for UnitParen

fn eq(&self, other: &UnitParen) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Spanned for UnitParen

type Span = Span

fn span(&self) -> Span

impl StructuralPartialEq for UnitParen

impl<__SyanMacro_Atom> Unparse<__SyanMacro_Atom> for UnitParen

where LParenTok: Unparse<__SyanMacro_Atom>, RParenTok: Unparse<__SyanMacro_Atom>,

fn unparse<__Syan_Emitter: Emitter<__SyanMacro_Atom>>( &self, __syan_sink: &mut __Syan_Emitter, ) -> Result<(), <__Syan_Emitter as Emitter<__SyanMacro_Atom>>::Error>