1.rs

impl<'a> Iterator for Lexer<'a> {
    type Item = Token;

    fn next(&mut self) -> Option<Token> {
        if let Some(ch) = self.chars.next() {
            match ch {
                ch if ch.is_digit(Self::RADIX) => Some(Token::Num(self.read_number(ch))),
                ch if ch.is_alphabetic() => {
                    if let Some(peek_ch) = self.chars.peek() {
                        if peek_ch.is_alphabetic() {
                            return Some(Token::String(self.read_string(ch)));
                        }
                    }
                    Some(Token::Char(ch))
                }
                '\n' | '\0' => Some(Token::Eof),
                ch if ch.is_whitespace() => Some(Token::Sep),
                '.' => Some(Token::Sep),
                ch => Some(Token::Unexpected(ch)),
            }
        } else {
            None
        }
    }
}

2.rs

impl<'a> Iterator for Lexer<'a> {
    type Item = Token;

    fn next(&mut self) -> Option<Token> {
        match (self.chars.next(), self.chars.peek()) {
            (Some(ch), _) if ch.is_digit(Self::RADIX) => {
                let n = self.read_number(ch);
                Some(Token::Num(n))
            }
            (Some('\n'), _) | (Some('\0'), _) => None,
            (Some('.'), _) => Some(Token::Sep),
            (Some(ch), _) if ch.is_whitespace() => Some(Token::Sep),
            (Some(cur_ch), Some(peek_ch)) if cur_ch.is_alphabetic() && peek_ch.is_alphabetic() => {
                let s = self.read_string(cur_ch);
                Some(Token::String(s))
            }
            (Some(ch), _) if ch.is_alphabetic() => Some(Token::Char(ch)),
            (Some(ch), _) => Some(Token::Unexpected(ch)),
            (None, _) => None,
        }
    }
}