【Rust】関数の「事前パース」で電卓を高速化！AST管理とデバッグ出力の実装 #5

#[derive(Debug, Clone)]
pub struct ParsedFunction {
    pub args: Vec<String>,     // 引数名リスト
    pub ast: Expr,             // 解析済みの式(ここは ast、以前はtomlのままだった)
    pub memoize: bool,         // メモ化フラグ(キャッシュ用）
    pub max_depth: usize,      // 再帰制限 (スタックオーバーフロー対策)
}

#[derive(Debug, Clone)]
pub struct Definitions {
    pub constants: HashMap<String, f64>,
    pub functions: HashMap<String, FunctionDef>,      // 生の定義
    pub parsed_functions: HashMap<String, ParsedFunction>, // 新規追加：解析済みAST
}

fn pre_parse_functions(&mut self) {
    let mut parsed_map = std::collections::HashMap::new();

    for (name, def) in &self.definitions.functions {
        let (expr_str, args, memoize, max_depth) = match def {
            defs::FunctionDef::Simple(s) => (s.clone(), vec![], false, 32),
            defs::FunctionDef::Complex { args, expr, memoize, max_depth } => {
                (expr.clone(), args.clone(), *memoize, *max_depth)
            }
        };

        // ここで前回作った Parser を利用
        let mut lexer = lexer::Lexer::new(&expr_str);
        if let Ok(tokens) = lexer.tokenize() {
            let mut parser = parser::Parser::new(tokens);
            if let Ok(ast) = parser.parse() {
                parsed_map.insert(name.clone(), defs::ParsedFunction {
                    args, ast, memoize, max_depth,
                });
            }
        }
    }
    self.definitions.parsed_functions = parsed_map;
}

pub fn evaluate_simple(expr: &Expr) -> String {
    match expr {
        Expr::Number(n) => n.to_string(),
        Expr::BinaryOp { left, op, right } => {
            format!("({} {:?} {})", evaluate_simple(left), op, evaluate_simple(right))
        }
        Expr::FunctionCall { name, args } => {
            let parsed_args: Vec<String> = args.iter().map(|a| evaluate_simple(a)).collect();
            format!("{}({})", name, parsed_args.join(", "))
        }
        // ...
    }
}

 1 + 1      → (1 Add 1)
 1 + 2*2    → (1 Add (2 Mul 2))
 3/2 + 4/5  → ((3 Div 2) Add (4 Div 5))
 2^3^2      → (2 Pow (3 Pow 2)) 　　　//右結合
conv(32,3)  → OK :conv(32,3) (Defined)

# toml内でのfibの定義
fib = { args = ["n"], expr = "if(n < 2, n, fib(n-1) + fib(n-2))", memoize = true, max_depth = 20 }