Struct Peeking 

pub struct Peeking<'a, T, S, E> {
    pub start: S,
    pub end: E,
    pub end_slice: usize,
    pub data: &'a [T],
}

A successful peeking result.

A Peeking contains the start and end results of a successful peek, the length of the end slice, and a reference to the data that was peeked.

Fields

start: S

The start of the match.

end: E

The end of the match.

end_slice: usize

The length of peeked slice.

data: &'a [T]

The data that was peeked.

Implementations

impl<'a, T, S, E> Peeking<'a, T, S, E>

where S: MatchSize, E: MatchSize,

pub fn peeked_slice(&self) -> &'a [T]

Get a slice of the data that was peeked.

Examples found in repository

examples/delimited_group.rs (line 12)

fn main() {
    let data = b"(2 * 3)";
    let mut scanner = noa_parser::scanner::Scanner::new(data);
    let result = peek(GroupKind::Parenthesis, &mut scanner)
        .expect("failed to parse")
        .expect("failed to peek");
    println!(
        "{}",
        String::from_utf8_lossy(result.peeked_slice()) // 2 * 3
    );
}

examples/expression.rs (line 172)

    fn accept(scanner: &mut Scanner<'a, u8>) -> ParseResult<Self> {
        OptionalWhitespaces::accept(scanner)?;
        // Check if there is a parenthesis
        let result = peek(GroupKind::Parenthesis, scanner)?;

        match result {
            Some(peeked) => {
                // Parse the inner expression
                let mut inner_scanner = Scanner::new(peeked.peeked_slice());
                let inner_result = Expression::accept(&mut inner_scanner)?;
                scanner.bump_by(peeked.end_slice);
                Ok(inner_result)
            }
            None => {
                // Parse the reduced expression or the right expression
                let accepted = Acceptor::new(scanner)
                    .try_or(ExpressionInternal::RightExpression)?
                    .try_or(ExpressionInternal::Reducted)?
                    .finish()
                    .ok_or(ParseError::UnexpectedToken)?;

                Ok(accepted.into())
            }
        }
    }

pub fn data(&self) -> &'a [T]

Get the data that was peeked.

Returns a reference to the underlying data that was peeked.

Trait Implementations

impl<'a, T: Debug, S: Debug, E: Debug> Debug for Peeking<'a, T, S, E>

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

Formats the value using the given formatter.

impl<'a, T: PartialEq, S: PartialEq, E: PartialEq> PartialEq for Peeking<'a, T, S, E>

fn eq(&self, other: &Peeking<'a, T, S, E>) -> 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<'a, T, S, E> StructuralPartialEq for Peeking<'a, T, S, E>