Struct Acceptor

pub struct Acceptor<'a, 'b, T, V> { /* private fields */ }

A type that wraps a Scanner and holds a successfully accepted value.

When a value is successfully accepted, the Acceptor stores the value in its data field and returns itself. If a value is not accepted, the Acceptor rewinds the scanner to the previous position and returns itself.

Type Parameters

• T - The type of the data to scan.
• V - The type of the value to accept.
• 'a - The lifetime of the data to scan.
• 'b - The lifetime of the acceptor.

Implementations

impl<'a, 'b, T, V> Acceptor<'a, 'b, T, V>

pub fn new(scanner: &'b mut Scanner<'a, T>) -> Acceptor<'a, 'b, T, V>

Create a new acceptor.

Arguments

• scanner - The scanner to use when consuming input.

Returns

A new acceptor that uses the given scanner.

Examples found in repository

examples/colors.rs (line 102)

    fn accept(scanner: &mut Scanner<u8>) -> ParseResult<Self> {
        let color = Acceptor::new(scanner)
            .try_or(ColorInternal::Hex)?
            .try_or(ColorInternal::Rgb)?
            .try_or(ColorInternal::Tuple)?
            .finish()
            .ok_or(UnexpectedToken)?;
        Ok(color.into())
    }

examples/expression.rs (line 179)

    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())
            }
        }
    }

impl<'a, T, V> Acceptor<'a, '_, T, V>

pub fn try_or<U: Visitor<'a, T>, F>(self, transformer: F) -> ParseResult<Self>

where F: Fn(U) -> V,

Attempt to accept a U using the given transformer, and rewind the scanner and return the current acceptor if it fails.

Arguments

• transformer - A function that takes a U and returns a ParseResult<V>.

Returns

If the U is successfully accepted and the transformer returns Ok, returns the current acceptor with the resulting value in data. If the U is not successfully accepted, returns the current acceptor with the current position of the scanner rewound to the position at which the U was attempted, and data is left None.

Examples found in repository

examples/colors.rs (line 103)

    fn accept(scanner: &mut Scanner<u8>) -> ParseResult<Self> {
        let color = Acceptor::new(scanner)
            .try_or(ColorInternal::Hex)?
            .try_or(ColorInternal::Rgb)?
            .try_or(ColorInternal::Tuple)?
            .finish()
            .ok_or(UnexpectedToken)?;
        Ok(color.into())
    }

examples/expression.rs (line 180)

    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 finish(self) -> Option<V>

Consume the acceptor and return the V that was accepted if the acceptor was successful.

Returns

If the acceptor was successful (i.e., data is Some), returns the V that was accepted. Otherwise, returns None.

Examples found in repository

examples/colors.rs (line 106)

    fn accept(scanner: &mut Scanner<u8>) -> ParseResult<Self> {
        let color = Acceptor::new(scanner)
            .try_or(ColorInternal::Hex)?
            .try_or(ColorInternal::Rgb)?
            .try_or(ColorInternal::Tuple)?
            .finish()
            .ok_or(UnexpectedToken)?;
        Ok(color.into())
    }

examples/expression.rs (line 182)

    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())
            }
        }
    }

Trait Implementations

impl<'a, 'b, T: Debug, V: Debug> Debug for Acceptor<'a, 'b, T, V>

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

Formats the value using the given formatter.