Ok, so this is the full implementation so far, am I missing something?

```
use std::fmt::{self, Display, Formatter};
use std::str::CharIndices;

#[derive(Debug, PartialEq, Clone)]
pub enum Token {
 // Literals
 Number(f64),
 String(String),
 Boolean(bool),

 // Identifiers
 Identifier(String),

 // Operators
 Plus,
 Minus,
 Star,
 Slash,
 // Add other operators as needed

 // Keywords
 If,
 Else,
 While,
 For,
 Function,
 Class,
 Import,
 Return,
 // Add other keywords as needed

 // Delimiters and other tokens
 LParen,
 RParen,
 LBrace,
 RBrace,
 Comma,
 Colon,
 Semicolon,
 Equals,
 Arrow,
}

impl Display for Token {
 fn fmt(&self, f: &mut Formatter) -> fmt::Result {
 match self {
 Token::Number(num) => write!(f, "{}", num),
 Token::String(s) => write!(f, "\"{}\"", s),
 Token::Boolean(b) => write!(f, "{}", b),
 Token::Identifier(ident) => write!(f, "{}", ident),
 Token::If => write!(f, "if"),
 Token::Else => write!(f, "else"),
 Token::While => write!(f, "while"),
 Token::For => write!(f, "for"),
 Token::Function => write!(f, "function"),
 Token::Class => write!(f, "class"),
 Token::Import => write!(f, "import"),
 Token::Return => write!(f, "return"),
 Token::Plus => write!(f, "+"),
 Token::Minus => write!(f, "-"),
 Token::Star => write!(f, "\*"),
 Token::Slash => write!(f, "/"),
 Token::LParen => write!(f, "("),
 Token::RParen => write!(f, ")"),
 Token::LBrace => write!(f, "{{"),
 Token::RBrace => write!(f, "}}"),
 Token::Comma => write!(f, ","),
 Token::Colon => write!(f, ":"),
 Token::Semicolon => write!(f, ";"),
 Token::Equals => write!(f, "="),
 Token::Arrow => write!(f, "->"),
 }
 }
}

pub struct Tokenizer<'a> {
 input: &'a str,
 chars: CharIndices<'a>,
}

impl<'a> Tokenizer<'a> {
 pub fn new(input: &'a str) -> Self {
 Tokenizer {
 input,
 chars: input.char\_indices(),
 }
 }

 fn next\_char(&mut self) -> Option<(usize, char)> {
 self.chars.next()
 }

 fn peek\_char(&mut self) -> Option {
 self.chars.clone().next().map(|(\_, c)| c)
 }

 fn skip\_whitespace(&mut self) {
 while let Some((\_, c)) = self.next\_char() {
 if !c.is\_whitespace() {
 break;
 }
 }
 }

 fn parse\_number(&mut self, start\_idx: usize) -> Option {
 let mut end\_idx = start\_idx;
 let mut decimal\_point\_found = false;

 while let Some((idx, c)) = self.next\_char() {
 if c == '.' {
 if decimal\_point\_found {
 // We've already seen a decimal point, so this is an invalid number.
 return None;
 }
 decimal\_point\_found = true;
 } else if !c.is\_digit(10) {
 break;
 }
 end\_idx = idx + 1;
 }

 let number\_str = &self.input[start\_idx..end\_idx];
 let number = number\_str.parse::().ok()?;

 Some(Token::Number(number))
 }

 fn parse\_string(&mut self) -> Option {
 let mut string = String::new();
 let mut escaped = false;

 while let Some((\_, c)) = self.next\_char() {
 if escaped {
 string.push(c);
 escaped = false;
 } else if c == '\\' {
 escaped = true;
 } else if c == '"' {
 return Some(Token::String(string));
 } else {
 string.push(c);
 }
 }

 None
 }

 fn parse\_boolean(&mut self) -> Option {
 if self.input.starts\_with("true") {
 self.input = &self.input[4..];
 Some(Token::Boolean(true))
 } else if self.input.starts\_with("false") {
 self.input = &self.input[5..];
 Some(Token::Boolean(false))
 } else {
 None
 }
 }

 fn parse\_identifier(&mut self) -> Option {
 let start\_idx = self.chars.clone().next().unwrap().0;
 let end\_idx = self.input[start\_idx..]
 .find(|c: char| !c.is\_alphanumeric() && c != '\_')
 .map(|pos| start\_idx + pos)
 .unwrap\_or\_else(|| self.input.len());

 let identifier = self.input[start\_idx..end\_idx].to\_owned();
 self.input = &self.input[end\_idx..];

 Some(Token::Identifier(identifier))
 }

 fn parse\_operator(&mut self) -> Option {
 let token = match self.input.chars().next()? {
 '+' => Token::Plus,
 '-' => Token::Minus,
 '\*' => Token::Star,
 '/' => Token::Slash,
 // Add other operators as needed
 \_ => return None,
 };

 let token\_len = token.to\_string().len();
 self.input = &self.input[token\_len..];
 Some(token)
 }

 fn parse\_keyword(&mut self) -> Option {
 let token = match &\*self.input {
 \_ if self.input.starts\_with("if") => Token::If,
 \_ if self.input.starts\_with("else") => Token::Else,
 \_ if self.input.starts\_with("while") => Token::While,
 \_ if self.input.starts\_with("for") => Token::For,
 \_ if self.input.starts\_with("function") => Token::Function,
 \_ if self.input.starts\_with("class") => Token::Class,
 \_ if self.input.starts\_with("import") => Token::Import,
 \_ if self.input.starts\_with("return") => Token::Return,
 // Add other keywords as needed
 \_ => return None,
 };

 let token\_len = token.to\_string().len();
 self.input = &self.input[token\_len..];
 Some(token)
 }

 fn parse\_delimiter(&mut self) -> Option {
 let token = match self.input.chars().next()? {
 '(' => Token::LParen,
 ')' => Token::RParen,
 '{' => Token::LBrace,
 '}' => Token::RBrace,
 ',' => Token::Comma,
 ':' => Token::Colon,
 ';' => Token::Semicolon,
 '=' => Token::Equals,
 '>' if self.input.starts\_with("->") => Token::Arrow,
 \_ => return None,
 };

 let token\_len = token.to\_string().len();
 self.input = &self.input[token\_len..];
 Some(token)
 }

 pub fn next\_token(&mut self) -> Option {
 self.skip\_whitespace();
 let (idx, c) = self.next\_char()?;

 let token = if c.is\_digit(10) {
 self.parse\_number(idx)
 } else if c == '\"' {
 self.parse\_string()
 } else if c.is\_alphabetic() {
 let token = self.parse\_identifier()?;
 self.parse\_keyword().or(Some(token))
 } else {
 self.parse\_operator().or\_else(|| self.parse\_delimiter())
 };

 token
 }
}
```
이게 지금까지 구현된 전체 내용인데 제가 놓친 게 있나요?```사용 std::fmt::{self, Display, Formatter};사용 std::str::CharIndices;#[derive(Debug, PartialEq, Clone)]]pub 열거형 토큰 { // 리터럴 Number(f64), String(String), Boolean(bool), // 식별자 식별자(문자열), // 연산자 플러스, Minus, Star, 슬래시, // 필요에 따라 다른 연산자 추가 // 키워드 If, Else, While, For, 함수, Class, Import, Return, // 필요에 따라 다른 키워드 추가 // 구분자 및 기타 토큰 LParen, RParen, LBrace, RBrace, 쉼표, 콜론, 세미콜론, 등호, 화살표,}토큰에 대한 임포트 표시 { fn fmt(&self, f: &mut 포맷터) -> fmt::결과 { 일치 자체 { Token::Number(num) => write!(f, "{}", num), Token::String(s) => write!(f, "\"{}\"", s), Token::Boolean(b) => write!(f, "{}", b), Token::Identifier(ident) => write!(f, "{}", ident), Token::If => write!(f, "if"), Token::Else => write!(f, "else"), Token::While => write!(f, "while"), Token::For => write!(f, "for"), Token::Function => write!(f, "function"), Token::Class => write!(f, "class"), Token::Import => write!(f, "import"), Token::Return => write!(f, "return"), Token::Plus => write!(f, "+"), Token::Minus => write!(f, "-"), Token::Star => write!(f, "\*"), Token::슬래시 => write!(f, "/"), Token::LParen => write!(f, "("), Token::RParen => write!(f, ")"), Token::LBrace => write!(f, "{{"), Token::RBrace => write!(f, "}}"), Token::Comma => write!(f, ","), Token::콜론 => write!(f, ":"), Token::세미콜론 => write!(f, ";"), Token::Equals => write!(f, "="), Token::Arrow => write!(f, "->"), } }}pub 구조체 Tokenizer<'a> { 입력: &'a str, chars: CharIndices<'a>,}impl<'a> Tokenizer<'a> { pub fn new(입력: &'a 문자열) -> Self { 토큰화기 { input, 문자: input.char\_indices(), } } fn next\_char(&mut self) -> Option<(usize, char)> { self.chars.next() } fn peek\_char(&mut self) -> Option { self.chars.clone().next().map(|(\_, c)| c) } fn skip\_whitespace(&mut self) { while let Some((\_, c)) = self.next\_char() { if !c.is\_whitespace() { break; } } } fn parse\_number(&mut self, start\_idx: usize) -> Option { let mut end\_idx = start\_idx; let mut decimal\_point\_found = false; while let Some((idx, c)) = self.next\_char() { if c == '.' { if decimal\_point\_found { // 이미 소수점을 보았으므로 유효하지 않은 숫자입니다. 반환 None; } decimal\_point\_found = true; } else if !c.is\_digit(10) { break; } END\_IDX = IDX + 1; } let number\_str = &self.input[start\_idx..end\_idx]; let number = number\_str.parse::().ok()? 일부(토큰::숫자(숫자)) } fn parse\_string(&mut self) -> Option { let mut string = String::new(); let mut 이스케이프 = false; while let Some((\_, c)) = self.next\_char() { if escaped { string.push(c); escaped = false; } else if c == '\\' { escaped = true; } else if c == '"' { 반환 일부(토큰::문자열(문자열)); } else { string.push(c); } } None } fn parse\_boolean(&mut self) -> Option { if self.input.starts\_with("true") { self.input = &self.input[4..]; 일부(토큰::부울(true)) } else if self.input.starts\_with("false") { self.input = &self.input[5..]; 일부(토큰::부울(거짓)) } else { None } } fn parse\_identifier(&mut self) -> Option { let start\_idx = self.chars.clone().next().unwrap().0; let end\_idx = self.input[start\_idx...] .find(|c: char| !c.is\_alphanumeric() && c != '\_') .map(|pos| start\_idx + pos) .unwrap\_or\_else(|| self.input.len()); let identifier = self.input[start\_idx..end\_idx].to\_owned(); self.input = &self.input[end\_idx..]; 일부(토큰::식별자(식별자)) } fn parse\_operator(&mut self) -> Option { let token = match self.input.chars().next()? { '+' => Token::Plus, '-' => Token::Minus, '\*' => Token::Star, '/' => Token::Slash, // 필요에 따라 다른 연산자 추가 \_ => None을 반환합니다, }; let token\_len = token.to\_string().len(); self.input = &self.input[token\_len..]; 일부(토큰) } fn parse\_keyword(&mut self) -> Option { let token = match &\*self.input { \_ if self.input.starts\_with("if") => Token::If, \_ if self.input.starts\_with("else") => Token::Else, \_ if self.input.starts\_with("while") => Token::While, \_ if self.input.starts\_with("for") => Token::For, \_ if self.input.starts\_with("function") => Token::Function, \_ if self.input.starts\_with("class") => Token::Class, \_ if self.input.starts\_with("import") => Token::Import, \_ if self.input.starts\_with("return") => Token::Return, // 필요에 따라 다른 키워드 추가 \_ => 반환 없음, }; let token\_len = token.to\_string().len(); self.input = &self.input[token\_len..]; 일부(토큰) } fn parse\_delimiter(&mut self) -> Option { let token = match self.input.chars().next()? { '(' => Token::LParen, ')' => Token::RParen, '{' => Token::LBrace, '}' => Token::RBrace, ',' => Token::Comma, ':' => Token::콜론, ';' => Token::세미콜론, '=' => Token::Equals, '>' if self.input.starts\_with