noa_parser::recognizer

Function recognize

Source 
pub fn recognize<'a, T, V, R: Recognizable<'a, T, V>>(
    recognizable: R,
    scanner: &mut Scanner<'a, T>,
) -> ParseResult<V>
Expand description

Recognize an object for the given scanner.

§Type Parameters

  • V - The type of the object to recognize
  • R - The type of the recognizable object

§Arguments

  • recognizable - The recognizable object to use for recognition
  • scanner - The scanner to recognize the object for

§Returns

  • Ok(V) if the object was recognized,
  • Err(ParseError) if an error occurred

This function calls the recognize method of the recognizable object and returns its result. If the recognizable object was not recognized, an Err(ParseError::UnexpectedToken) is returned. If the scanner is at the end of its input and the recognizable object is longer than the remaining input, an Err(ParseError::UnexpectedEndOfInput) is returned.

Examples found in repository?
examples/addition.rs (line 32)
31    fn accept(scanner: &mut Scanner<u8>) -> ParseResult<Self> {
32        let raw_data = recognize(TokenNumber, scanner)?;
33        let str_data = std::str::from_utf8(raw_data)?;
34        let result = str_data.parse::<usize>()?;
35        Ok(Number(result))
36    }
More examples
Hide additional examples
examples/turbofish_data_visitor.rs (line 18)
16    fn accept(scanner: &mut Scanner<'a, u8>) -> ParseResult<Self> {
17        // recognize the turbofish operator start "::<".
18        recognize(Token::Colon, scanner)?;
19        recognize(Token::Colon, scanner)?;
20        recognize(Token::LessThan, scanner)?;
21        Ok(TurbofishStartTokens)
22    }
23}
24
25// Implement the `Visitor` trait for the turbofish operator.
26impl<'a> Visitor<'a, u8> for Turbofish {
27    fn accept(scanner: &mut noa_parser::scanner::Scanner<u8>) -> ParseResult<Self> {
28        // recognize the turbofish operator start "::<".
29        TurbofishStartTokens::accept(scanner)?;
30        // recognize the number
31        let number = Number::accept(scanner)?.0;
32        // recognize the turbofish operator end ">"
33        recognize(Token::GreaterThan, scanner)?;
34        Ok(Turbofish(number))
35    }
examples/turbofish_data.rs (line 15)
13    fn accept(scanner: &mut noa_parser::scanner::Scanner<u8>) -> ParseResult<Self> {
14        // recognize the turbofish operator start "::<".
15        recognize(Token::Colon, scanner)?;
16        recognize(Token::Colon, scanner)?;
17        recognize(Token::LessThan, scanner)?;
18        // recognize the number
19        let number = Number::accept(scanner)?.0;
20        // recognize the turbofish operator end ">"
21        recognize(Token::GreaterThan, scanner)?;
22        Ok(Turbofish(number))
23    }
examples/colors.rs (line 36)
34    fn accept(scanner: &mut Scanner<u8>) -> ParseResult<Self> {
35        // recognize the rgb color start "("
36        recognize(Token::OpenParen, scanner)?;
37        // recognize the red number
38        let red = Number::accept(scanner)?.0;
39        // recognize the comma
40        recognize(Token::Comma, scanner)?;
41        recognize(Token::Whitespace, scanner)?;
42        // recognize the green number
43        let green = Number::accept(scanner)?.0;
44        // recognize the comma
45        recognize(Token::Comma, scanner)?;
46        recognize(Token::Whitespace, scanner)?;
47        // recognize the blue number
48        let blue = Number::accept(scanner)?.0;
49        // recognize the rgb color end ")"
50        recognize(Token::CloseParen, scanner)?;
51        Ok(TupleColor(red, green, blue))
52    }
53}
54
55impl<'a> Visitor<'a, u8> for RgbColor {
56    fn accept(scanner: &mut Scanner<u8>) -> ParseResult<Self> {
57        let prefix = DataString::<&str>::accept(scanner)?.0;
58
59        if prefix != "rgb" {
60            return Err(UnexpectedToken);
61        }
62
63        // recognize the rgb color start "("
64        recognize(Token::OpenParen, scanner)?;
65        // recognize the red number
66        let red = Number::accept(scanner)?.0;
67        // recognize the comma
68        recognize(Token::Comma, scanner)?;
69        recognize(Token::Whitespace, scanner)?;
70        // recognize the green number
71        let green = Number::accept(scanner)?.0;
72        // recognize the comma
73        recognize(Token::Comma, scanner)?;
74        recognize(Token::Whitespace, scanner)?;
75        // recognize the blue number
76        let blue = Number::accept(scanner)?.0;
77        // recognize the rgb color end ")"
78        recognize(Token::CloseParen, scanner)?;
79        Ok(RgbColor(red, green, blue))
80    }
81}
82
83impl<'a> Visitor<'a, u8> for HexColor {
84    fn accept(scanner: &mut Scanner<u8>) -> ParseResult<Self> {
85        recognize(Token::Sharp, scanner)?;
86        let content = DataString::<&str>::accept(scanner)?.0;
87        let (red, green, blue) = (
88            u8::from_str_radix(&content[0..2], 16)?,
89            u8::from_str_radix(&content[2..4], 16)?,
90            u8::from_str_radix(&content[4..6], 16)?,
91        );
92        Ok(HexColor(red, green, blue))
93    }