Project: An Expression Interpreter

Collect the characters first: let chars: Vec<char> = src.chars().collect(); and walk them with an index i.

For a number: remember start = i, advance while digits, then chars[start..i].iter().collect::<String>() and parse it.

For single-character tokens, match c { '+' | '-' | '*' | '/' | '%' => Token::Op(c), '(' => Token::LParen, ... } and advance by one.

use std::io;

#[derive(Debug, Clone, PartialEq)]
enum Token {
    Num(i64),
    Ident(String),
    Op(char),
    LParen,
    RParen,
    Let,
    Assign,
}

fn tokenize(src: &str) -> Result<Vec<Token>, String> {
    let chars: Vec<char> = src.chars().collect();
    let mut tokens = Vec::new();
    let mut i = 0;
    while i < chars.len() {
        let c = chars[i];
        if c.is_whitespace() {
            i += 1;
        } else if c.is_ascii_digit() {
            let start = i;
            while i < chars.len() && chars[i].is_ascii_digit() {
                i += 1;
            }
            let text: String = chars[start..i].iter().collect();
            let n = text.parse().map_err(|_| format!("number too large: {text}"))?;
            tokens.push(Token::Num(n));
        } else if c.is_ascii_alphabetic() || c == '_' {
            let start = i;
            while i < chars.len() && (chars[i].is_ascii_alphanumeric() || chars[i] == '_') {
                i += 1;
            }
            let word: String = chars[start..i].iter().collect();
            tokens.push(if word == "let" { Token::Let } else { Token::Ident(word) });
        } else {
            tokens.push(match c {
                '+' | '-' | '*' | '/' | '%' => Token::Op(c),
                '(' => Token::LParen,
                ')' => Token::RParen,
                '=' => Token::Assign,
                _ => return Err(format!("unexpected character '{c}'")),
            });
            i += 1;
        }
    }
    Ok(tokens)
}

fn main() {
    for line in io::stdin().lines() {
        let line = line.unwrap();
        match tokenize(&line) {
            Ok(tokens) => println!("{:?}", tokens),
            Err(e) => println!("error: {e}"),
        }
    }
}

expr: let mut left = self.term()?; while let Some(Token::Op(op @ ('+' | '-'))) = self.peek() { let op = *op; self.pos += 1; let right = self.term()?; left = Expr::Bin(Box::new(left), op, Box::new(right)); } Ok(left). term is the same with *, /, % and factor.

factor: match self.next() { Some(Token::Op('-')) => Ok(Expr::Neg(Box::new(self.factor()?))), Some(Token::Num(n)) => ..., Some(Token::LParen) => ..., _ => Err(...) }.

eval: recurse with ?; use checked_add, checked_sub, checked_mul, checked_div, checked_rem, checked_neg and turn None into overflow; check for a zero divisor first.

use std::collections::HashMap;
use std::io;

#[derive(Debug, Clone, PartialEq)]
enum Token {
    Num(i64),
    Ident(String),
    Op(char),
    LParen,
    RParen,
    Let,
    Assign,
}

fn tokenize(src: &str) -> Result<Vec<Token>, String> {
    let chars: Vec<char> = src.chars().collect();
    let mut tokens = Vec::new();
    let mut i = 0;
    while i < chars.len() {
        let c = chars[i];
        if c.is_whitespace() {
            i += 1;
        } else if c.is_ascii_digit() {
            let start = i;
            while i < chars.len() && chars[i].is_ascii_digit() {
                i += 1;
            }
            let text: String = chars[start..i].iter().collect();
            let n = text.parse().map_err(|_| format!("number too large: {text}"))?;
            tokens.push(Token::Num(n));
        } else if c.is_ascii_alphabetic() || c == '_' {
            let start = i;
            while i < chars.len() && (chars[i].is_ascii_alphanumeric() || chars[i] == '_') {
                i += 1;
            }
            let word: String = chars[start..i].iter().collect();
            tokens.push(if word == "let" { Token::Let } else { Token::Ident(word) });
        } else {
            tokens.push(match c {
                '+' | '-' | '*' | '/' | '%' => Token::Op(c),
                '(' => Token::LParen,
                ')' => Token::RParen,
                '=' => Token::Assign,
                _ => return Err(format!("unexpected character '{c}'")),
            });
            i += 1;
        }
    }
    Ok(tokens)
}

#[derive(Debug)]
enum Expr {
    Num(i64),
    Var(String),
    Neg(Box<Expr>),
    Bin(Box<Expr>, char, Box<Expr>),
}

struct Parser {
    tokens: Vec<Token>,
    pos: usize,
}

impl Parser {
    fn peek(&self) -> Option<&Token> {
        self.tokens.get(self.pos)
    }

    fn next(&mut self) -> Option<Token> {
        let t = self.tokens.get(self.pos).cloned();
        self.pos += 1;
        t
    }

    // expr := term (('+' | '-') term)*
    fn expr(&mut self) -> Result<Expr, String> {
        let mut left = self.term()?;
        while let Some(Token::Op(op @ ('+' | '-'))) = self.peek() {
            let op = *op;
            self.pos += 1;
            let right = self.term()?;
            left = Expr::Bin(Box::new(left), op, Box::new(right));
        }
        Ok(left)
    }

    // term := factor (('*' | '/' | '%') factor)*
    fn term(&mut self) -> Result<Expr, String> {
        let mut left = self.factor()?;
        while let Some(Token::Op(op @ ('*' | '/' | '%'))) = self.peek() {
            let op = *op;
            self.pos += 1;
            let right = self.factor()?;
            left = Expr::Bin(Box::new(left), op, Box::new(right));
        }
        Ok(left)
    }

    // factor := '-' factor | NUMBER | IDENT | '(' expr ')'
    fn factor(&mut self) -> Result<Expr, String> {
        match self.next() {
            Some(Token::Op('-')) => Ok(Expr::Neg(Box::new(self.factor()?))),
            Some(Token::Num(n)) => Ok(Expr::Num(n)),
            Some(Token::Ident(name)) => Ok(Expr::Var(name)),
            Some(Token::LParen) => {
                let e = self.expr()?;
                match self.next() {
                    Some(Token::RParen) => Ok(e),
                    _ => Err(String::from("expected ')'")),
                }
            }
            _ => Err(String::from("expected a number, variable or '('")),
        }
    }
}

fn eval(e: &Expr, env: &HashMap<String, i64>) -> Result<i64, String> {
    match e {
        Expr::Num(n) => Ok(*n),
        Expr::Var(name) => env.get(name).copied().ok_or(format!("unknown variable '{name}'")),
        Expr::Neg(inner) => eval(inner, env)?.checked_neg().ok_or(String::from("overflow")),
        Expr::Bin(l, op, r) => {
            let (a, b) = (eval(l, env)?, eval(r, env)?);
            let result = match op {
                '+' => a.checked_add(b),
                '-' => a.checked_sub(b),
                '*' => a.checked_mul(b),
                _ if b == 0 => return Err(String::from("division by zero")),
                '/' => a.checked_div(b),
                _ => a.checked_rem(b),
            };
            result.ok_or(String::from("overflow"))
        }
    }
}

fn run_line(line: &str, env: &mut HashMap<String, i64>) -> Result<String, String> {
    let tokens = tokenize(line)?;
    let (name, expr_tokens) = match tokens.as_slice() {
        [Token::Let, Token::Ident(name), Token::Assign, rest @ ..] => (Some(name.clone()), rest.to_vec()),
        [Token::Let, ..] => return Err(String::from("expected: let NAME = EXPRESSION")),
        _ => (None, tokens),
    };
    let mut parser = Parser { tokens: expr_tokens, pos: 0 };
    let expr = parser.expr()?;
    if parser.pos < parser.tokens.len() {
        return Err(String::from("unexpected input after expression"));
    }
    let value = eval(&expr, env)?;
    match name {
        Some(n) => {
            env.insert(n.clone(), value);
            Ok(format!("{n} = {value}"))
        }
        None => Ok(value.to_string()),
    }
}

fn main() {
    let mut env = HashMap::new();
    for line in io::stdin().lines() {
        let line = line.unwrap();
        if line.trim().is_empty() {
            continue;
        }
        match run_line(&line, &mut env) {
            Ok(out) => println!("{out}"),
            Err(e) => println!("error: {e}"),
        }
    }
}