feat: update lexer type definitions in examples for consistency

Author: Wybxc

parse-it-codegen/src/parser/frontend.rs

@@ -42,21 +42,11 @@ impl ParserMod {
             parsers.push(parser);
         }
 
-        let mut items = self.items;
-        if !items.iter().any(|item| match item {
-            syn::Item::Type(ty) => ty.ident == "Lexer",
-            _ => false,
-        }) {
-            items.push(syn::parse_quote! {
-                type Lexer = #crate_name::CharLexer;
-            });
-        }
-
         let middle = Middle {
             attrs: self.attrs,
             crate_name,
             mod_name: self.mod_name,
-            items,
+            items: self.items,
             parsers,
             debug: self.config.debug,
         };

parse-it/examples/brainfuck.rs

@@ -18,6 +18,8 @@ parse_it::parse_it! {
     mod parse {
         use super::Instr;
 
+        type Lexer = parse_it::CharLexer;
+
         pub Brainfuck -> Vec<Instr> {
             Primitive* => self,
         }

parse-it/examples/calc.rs

@@ -3,6 +3,8 @@ use parse_it::ParseIt;
 parse_it::parse_it! {
     #[parser]
     mod parse {
+        type Lexer = parse_it::CharLexer;
+
         Digit -> char {
             @['0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'] => self
         }

parse-it/examples/json.rs

@@ -20,6 +20,7 @@ parse_it::parse_it! {
             Number(f64),
             String(String),
             Keyword,
+            Punct,
         }
 
         pub Initial -> Token {
@@ -33,12 +34,12 @@ parse_it::parse_it! {
             "true" => Token::Keyword,
             "false" => Token::Keyword,
             "null" => Token::Keyword,
-            r"\[" => Token::Keyword,
-            r"\]" => Token::Keyword,
-            r"\{" => Token::Keyword,
-            r"\}" => Token::Keyword,
-            r"," => Token::Keyword,
-            r":" => Token::Keyword,
+            r"\[" => Token::Punct,
+            r"\]" => Token::Punct,
+            r"\{" => Token::Punct,
+            r"\}" => Token::Punct,
+            r"," => Token::Punct,
+            r":" => Token::Punct,
         }
 
         Number -> f64 {
@@ -65,7 +66,7 @@ parse_it::parse_it! {
         use super::JsonValue;
         use super::lex::Token;
 
-        type Lexer = super::Debug;
+        type Lexer = super::lex::Initial;
 
         Object -> JsonValue {
             '{' '}' => JsonValue::Object(HashMap::new()),
@@ -84,38 +85,21 @@ parse_it::parse_it! {
         }
 
         Key -> String {
-            Token::String(buf) => buf.clone()
+            Token::String(buf) => buf
         }
 
         pub Value -> JsonValue {
             Token::Number(i) => JsonValue::Number(i),
-            Token::String(buf) => JsonValue::String(buf.clone()),
-            "true" => JsonValue::Boolean(true),
-            "false" => JsonValue::Boolean(false),
-            "null" => JsonValue::Null,
+            Token::String(buf) => JsonValue::String(buf),
+            &Token::Keyword "true" => JsonValue::Boolean(true),
+            &Token::Keyword "false" => JsonValue::Boolean(false),
+            &Token::Keyword "null" => JsonValue::Null,
             Object => self,
             Array => self,
         }
     }
 }
 
-#[derive(Clone)]
-pub struct Debug;
-
-impl parse_it::LexIt for Debug {
-    type Token<'a> = lex::Token;
-
-    fn new() -> Self {
-        Self
-    }
-
-    fn next<'a>(&self, lexbuf: &mut parse_it::LexerState<'a>) -> Option<Self::Token<'a>> {
-        let result = lex::Initial.next(lexbuf);
-        eprintln!("Lexing: {:?} at {:?}", result, lexbuf.span());
-        result
-    }
-}
-
 fn main() {
     let input = r#"{"name": "Alice", "age": 30, "is_student": false, "courses": ["Math", "Science"], "address": null}"#;