Struct SpannedToken 

pub struct SpannedToken<'s>(pub Token<'s>, pub Span<'s>);

A token and its location in the source code

Tuple Fields

0: Token<'s>

1: Span<'s>

Trait Implementations

impl<'s> Clone for SpannedToken<'s>

fn clone(&self) -> SpannedToken<'s>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'s> Debug for SpannedToken<'s>

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

Formats the value using the given formatter.

impl<'s> Eq for SpannedToken<'s>

impl<'s> From<(Token<'s>, Span<'s>)> for SpannedToken<'s>

fn from(item: (Token<'s>, Span<'s>)) -> Self

Converts to this type from the input type.

impl<'s> Parser<Stateful<TokenSlice<'s, SpannedToken<'s>>, Option<VerboseError<'s>>>, &'s SpannedToken<'s>, ErrMode<VerboseError<'s>>> for Token<'s>

fn parse_next( &mut self, input: &mut Tokens<'s>, ) -> ModalResult<&'s SpannedToken<'s>, VerboseError<'s>>

Take tokens from the Stream, turning it into the output

fn parse( &mut self, input: I, ) -> Result<O, ParseError<I, <E as ParserError<I>>::Inner>>

where Self: Sized, I: Stream + StreamIsPartial, E: ParserError<I>, <E as ParserError<I>>::Inner: ParserError<I>,

Parse all of input, generating O from it

fn parse_peek(&mut self, input: I) -> Result<(I, O), E>

Take tokens from the Stream, turning it into the output

fn by_ref(&mut self) -> ByRef<'_, Self, I, O, E>

where Self: Sized,

Treat &mut Self as a parser

fn value<O2>(self, val: O2) -> Value<Self, I, O, O2, E>

where Self: Sized, O2: Clone,

Produce the provided value

fn default_value<O2>(self) -> DefaultValue<Self, I, O, O2, E>

where Self: Sized, O2: Default,

Produce a type’s default value

fn void(self) -> Void<Self, I, O, E>

where Self: Sized,

Discards the output of the Parser

fn output_into<O2>(self) -> OutputInto<Self, I, O, O2, E>

where Self: Sized, O: Into<O2>,

Convert the parser’s output to another type using std::convert::From

fn take(self) -> Take<Self, I, O, E>

where Self: Sized, I: Stream,

Produce the consumed input as produced value.

fn with_taken(self) -> WithTaken<Self, I, O, E>

where Self: Sized, I: Stream,

Produce the consumed input with the output

fn span(self) -> Span<Self, I, O, E>

where Self: Sized, I: Stream + Location,

Produce the location of the consumed input as produced value.

fn with_span(self) -> WithSpan<Self, I, O, E>

where Self: Sized, I: Stream + Location,

Produce the location of consumed input with the output

fn map<G, O2>(self, map: G) -> Map<Self, G, I, O, O2, E>

where G: FnMut(O) -> O2, Self: Sized,

Maps a function over the output of a parser

fn try_map<G, O2, E2>(self, map: G) -> TryMap<Self, G, I, O, O2, E, E2>

where Self: Sized, G: FnMut(O) -> Result<O2, E2>, I: Stream, E: FromExternalError<I, E2> + ParserError<I>,

Applies a function returning a Result over the output of a parser.

fn verify_map<G, O2>(self, map: G) -> VerifyMap<Self, G, I, O, O2, E>

where Self: Sized, G: FnMut(O) -> Option<O2>, I: Stream, E: ParserError<I>,

Apply both Parser::verify and Parser::map.

fn flat_map<G, H, O2>(self, map: G) -> FlatMap<Self, G, H, I, O, O2, E>

where Self: Sized, G: FnMut(O) -> H, H: Parser<I, O2, E>,

Creates a parser from the output of this one

fn parse_to<O2>(self) -> ParseTo<Self, I, O, O2, E>

where Self: Sized, I: Stream, O: ParseSlice<O2>, E: ParserError<I>,

Apply std::str::FromStr to the output of the parser

fn verify<G, O2>(self, filter: G) -> Verify<Self, G, I, O, O2, E>

where Self: Sized, G: FnMut(&O2) -> bool, I: Stream, O: Borrow<O2>, E: ParserError<I>, O2: ?Sized,

Returns the output of the child parser if it satisfies a verification function.

fn context<C>(self, context: C) -> Context<Self, I, O, E, C>

where Self: Sized, I: Stream, E: AddContext<I, C> + ParserError<I>, C: Clone + Debug,

If parsing fails, add context to the error

fn context_with<F, C, FI>( self, context: F, ) -> ContextWith<Self, I, O, E, F, C, FI>

where Self: Sized, I: Stream, E: AddContext<I, C> + ParserError<I>, F: Fn() -> FI + Clone, C: Debug, FI: Iterator<Item = C>,

If parsing fails, dynamically add context to the error

fn map_err<G, E2>(self, map: G) -> MapErr<Self, G, I, O, E, E2>

where G: FnMut(E) -> E2, Self: Sized,

Maps a function over the error of a parser

fn complete_err(self) -> CompleteErr<Self, I, O, E>

where Self: Sized,

Transforms Incomplete into Backtrack

fn err_into<E2>(self) -> ErrInto<Self, I, O, E, E2>

where Self: Sized, E: Into<E2>,

Convert the parser’s error to another type using std::convert::From

impl<'s> PartialEq for SpannedToken<'s>

fn eq(&self, other: &SpannedToken<'s>) -> 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<'s> PartialEq<Token<'s>> for SpannedToken<'s>

fn eq(&self, other: &Token<'_>) -> 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<'s> StructuralPartialEq for SpannedToken<'s>