Struct proclet::Op

pub struct Op<S: Span> { /* private fields */ }

An operator. These can be parsed from tokens, and can also be used as parsers to parse one specific operator.

Implementations

impl<S: Span> Op<S>

pub fn new(str: impl Into<Cow<'static, str>>) -> Self

Create a new operator. str can’t be empty.

pub const fn new_static(str: &'static str) -> Self

Create a new operator (const). str can’t be empty.

pub fn with_span(str: impl Into<Cow<'static, str>>, span: S) -> Self

Create a new operator with one specific span used for the whole operator. str can’t be empty.

pub fn with_spans(str: impl Into<Cow<'static, str>>, spans: Vec<S>) -> Self

Create a new operator with a specific span for each character of the op. The length of spans must be the same as the number of characters in str. str can’t be empty.

pub fn as_str(&self) -> &str

Get this op as a string.

pub fn puncts(&self) -> Puncts<'_, S::Punct>

Get an iterator over the Puncts that make up this op.

pub fn spans(&self) -> Option<&[S]>

Get the spans of this op, or None if the default span is used.

pub fn set_spans(&mut self, spans: &[S])

Set the spans of this op. The lengths of spans must be the same as the number of characters in the string representation of this op.

pub fn span(&self) -> Option<S>

Get the span of this op. If the op has more than one span, this will currently return the first span. This may change in the future if proc-macro* exposes the ability to merge spans.

pub fn set_span(&mut self, span: S)

Set a single span for this op.

impl<S: SpanExt> Op<S>

pub fn split( &self, parser: &OpParser<S::Punct, impl MatchOpFn> ) -> ParseOps<S, Puncts<'_, S::Punct>, impl MatchOpFn>

Split this op using the provided OpParser.

Trait Implementations

impl<S: Clone + Span> Clone for Op<S>

fn clone(&self) -> Op<S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: Debug + Span> Debug for Op<S>

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

Formats the value using the given formatter.

impl<S: Span> From<&'static str> for Op<S>

fn from(value: &'static str) -> Self

Converts to this type from the input type.

impl<S: SpanExt> IntoIterator for Op<S>

type Item = <S as ProcMacro>::Punct

The type of the elements being iterated over.

type IntoIter = Puncts<'static, <S as ProcMacro>::Punct>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: TokenTreeExt> IntoTokens<T> for Op<T::Span>

fn into_tokens(self) -> impl Iterator<Item = T>

Convert this object into an iterator of tokens representing the object.

impl<S: SpanExt> Parse<<S as ProcMacro>::TokenTree> for Op<S>

fn parse(buf: &mut &TokenBuf<S::TokenTree>) -> Result<Self, Error<S>>

Generic op parser. This doesn’t check against valid ops.

fn parse_all(buf: &mut &TokenBuf<T>) -> Result<Self, Error<T::Span>>

Parse a value from a TokenBuf buffer, but return an error if there’s any tokens left in the buffer after parsing.

impl<T: TokenTreeExt> Parser<T> for Op<T::Span>

type Output<'p, 'b> = Op<<T as ProcMacro>::Span> where Self: 'p

The output type of this parser.

fn parse<'p, 'b>( &'p self, buf: &mut &'b TokenBuf<T> ) -> Result<Self::Output<'p, 'b>, Error<T::Span>>

Parse a value from a TokenBuf using this parser.

fn parse_all<'p, 'b>( &'p self, buf: &mut &'b TokenBuf<T> ) -> Result<Self::Output<'p, 'b>, Error<T::Span>>

Parse a value from a TokenBuf buffer, but return an error if there’s any tokens left in the buffer after parsing.

fn optional(self) -> Optional<Self>

where Self: Sized,

Wrap this parser in Optional to make it always succeed and return an option.

impl<S: SpanExt> ToTokenStream<<S as ProcMacro>::TokenStream> for Op<S>

fn extend_token_stream(&self, token_stream: &mut S::TokenStream)

Extend the given TokenStream with a representation of this object.

fn into_token_stream(self) -> T

where Self: Sized,

Make a new TokenStream with a representation of this object.

fn to_token_stream(&self) -> T

Make a new TokenStream with a representation of this object.