#[derive(Copy, Clone, Debug)]
enum Operator {
    Addition,
    Subtraction,
    Multiplication,
    Division,
}

#[derive(Copy, Clone, Debug)]
enum Position {
    Start,
    Stop,
}

#[derive(Copy, Clone, Debug)]
enum Token {
    Number(f64),
    Operator(Operator),
    Separator(Position),
}

struct Lexer<I: Iterator<Item = char>> {
    iter: std::iter::Peekable<I>,
}

impl<I: Iterator<Item = char>> Lexer<I> {
    fn new(iter: I) -> Self {
        Lexer {
            iter: iter.peekable(),
        }
    }

    fn skip_whitespace(&mut self) {
        while self.iter.peek().map(|c| c.is_whitespace()).unwrap_or(false) {
            self.iter.next();
        }
    }
}

impl<I: Iterator<Item = char>> Iterator for Lexer<I> {
    type Item = Token;

    fn next(&mut self) -> Option<Token> {
        self.skip_whitespace();
        let chr = self.iter.next()?;
        return Some(match chr {
            '+' => Token::Operator(Operator::Addition),
            '-' => Token::Operator(Operator::Subtraction),
            '*' => Token::Operator(Operator::Multiplication),
            '/' => Token::Operator(Operator::Division),
            '(' => Token::Separator(Position::Start),
            ')' => Token::Separator(Position::Stop),
            '0'..='9' => {
                let mut buf = ((chr as u8) - b'0') as f64;
                while let Some('0'..='9') = self.iter.peek() {
                    buf = buf * 10.0 + ((self.iter.next().unwrap() as u8) - b'0') as f64;
                }
                Token::Number(buf)
            }
            _ => panic!("invalid char: {}", chr),
        });
    }
}

fn main() {
    println!("{:?}", Lexer::new("10+20((".chars()).collect::<Vec<_>>());
}