Struct pear::input::Pear

pub struct Pear<I: Input> {
    pub input: I,
    // some fields omitted
}

Fields

input: I

Implementations

impl<I: Input> Pear<I>

pub fn new<A>(input: A) -> Pear<I> where
    I: From<A>, 

Trait Implementations

impl<I: Debug + Input> Debug for Pear<I>

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

Formats the value using the given formatter.

impl<I: Input> Deref for Pear<I>

type Target = I

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<I: Input> DerefMut for Pear<I>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<I: Input> From<I> for Pear<I>

fn from(input: I) -> Pear<I>

Performs the conversion.

impl<I: Input> Input for Pear<I>

type Token = I::Token

type Slice = I::Slice

type Many = I::Many

type Marker = I::Marker

type Context = I::Context

fn token(&mut self) -> Option<Self::Token>

Returns a copy of the current token, if there is one.

fn slice(&mut self, n: usize) -> Option<Self::Slice>

Returns a copy of the current slice of size n, if there is one.

fn has(&mut self, n: usize) -> bool

Returns true if there are at least n tokens remaining.

fn peek<F>(&mut self, cond: F) -> bool where
    F: FnMut(&Self::Token) -> bool, 

Checks if the current token fulfills cond.

fn peek_slice<F>(&mut self, n: usize, cond: F) -> bool where
    F: FnMut(&Self::Slice) -> bool, 

Checks if the current slice of size n (if any) fulfills cond.

fn eat<F>(&mut self, cond: F) -> Option<Self::Token> where
    F: FnMut(&Self::Token) -> bool, 

Checks if the current token fulfills cond. If so, the token is consumed and returned. Otherwise, returns None.

fn eat_slice<F>(&mut self, n: usize, cond: F) -> Option<Self::Slice> where
    F: FnMut(&Self::Slice) -> bool, 

Checks if the current slice of size n (if any) fulfills cond. If so, the slice is consumed and returned. Otherwise, returns None.

fn take<F>(&mut self, cond: F) -> Self::Many where
    F: FnMut(&Self::Token) -> bool, 

Takes tokens while cond returns true, collecting them into a Self::Many and returning it.

fn skip<F>(&mut self, cond: F) -> usize where
    F: FnMut(&Self::Token) -> bool, 

Skips tokens while cond returns true. Returns the number of skipped tokens.

fn mark(&mut self, info: &ParserInfo) -> Self::Marker

Emits a marker that represents the current parse position.

fn context(&mut self, mark: Self::Marker) -> Self::Context

Returns a context to identify the input spanning from mark until but excluding the current position.

impl<I: Input + Rewind> Rewind for Pear<I>

fn rewind_to(&mut self, marker: Self::Marker)

Resets self to the position identified by marker.