Rust CEL表达式解析库cel-parser的使用指南

简介

cel-parser是一个Rust实现的通用表达式语言(CEL)解析和评估库。CEL(Common Expression Language)是一种非图灵完备的表达式语言，最初由Google开发，用于安全地评估表达式。

主要特性

• 高性能的CEL表达式解析
• 安全的表达式评估
• 支持自定义变量和函数
• 轻量级且无依赖

安装

在Cargo.toml中添加依赖：

[dependencies]
cel-parser = "0.3"

基本使用

1. 简单表达式求值

use cel_parser::Expression;

fn main() {
    // 解析简单数学表达式
    let expr = Expression::parse("1 + 2 * 3").unwrap();
    // 评估表达式(空上下文)
    let result = expr.eval(&()).unwrap();
    println!("Result: {:?}", result); // 输出: Result: Value::Int64(7)
}

2. 使用变量

use cel_parser::{Expression, Value, Map};
use std::collections::HashMap;

fn main() {
    // 创建变量映射
    let mut vars: HashMap<String, Value> = HashMap::new();
    vars.insert("x".to_string(), Value::Int64(10));
    vars.insert("y".to_string(), Value::Int64(20));
    
    // 解析带变量的表达式
    let expr = Expression::parse("x + y").unwrap();
    // 使用变量上下文评估
    let result = expr.eval(&vars).unwrap();
    println!("Result: {:?}", result); // 输出: Result: Value::Int64(30)
}

3. 使用函数

use cel_parser::{Expression, Value, Function};
use std::collections::HashMap;

// 自定义double函数
fn double(args: &[Value]) -> Result<Value, String> {
    if let Value::Int64(num) = args[0] {
        Ok(Value::Int64(num * 2))
    } else {
        Err("Expected integer".to_string())
    }
}

fn main() {
    // 创建函数映射
    let mut funcs: HashMap<String, Function> = HashMap::new();
    funcs.insert("double".to_string(), double);
    
    // 解析带函数调用的表达式
    let expr = Expression::parse("double(5)").unwrap();
    // 使用函数上下文评估
    let result = expr.eval_with_functions(&(), &funcs).unwrap();
    println!("Result: {:?}", result); // 输出: Result: Value::Int64(10)
}

高级用法

1. 复杂表达式

use cel_parser::{Expression, Value, Map};
use std::collections::HashMap;

fn main() {
    // 创建包含字符串和数字的变量
    let mut vars: HashMap<String, Value> = HashMap::new();
    vars.insert("name".to_string(), Value::String("Alice".to_string()));
    vars.insert("age".to_string(), Value::Int64(30));
    
    // 解析逻辑表达式
    let expr = Expression::parse("name == 'Alice' && age >= 18").unwrap();
    let result = expr.eval(&vars).unwrap();
    println!("Is Alice an adult? {:?}", result); // 输出: Is Alice an adult? Value::Bool(true)
}

2. 列表和映射操作

use cel_parser::{Expression, Value, Map};
use std::collections::HashMap;

fn main() {
    // 创建包含列表的变量
    let mut vars: HashMap<String, Value> = HashMap::new();
    vars.insert("scores".to_string(), Value::List(vec![
        Value::Int64(85),
        Value::Int64(90),
        Value::Int64(78)
    ]));
    
    // 解析列表过滤表达式
    let expr = Expression::parse("scores.filter(x, x > 80).size()").unwrap();
    let result = expr.eval(&vars).unwrap();
    println!("Number of scores > 80: {:?}", result); // 输出: Number of scores > 80: Value::Int64(2)
}

错误处理

use cel_parser::Expression;

fn main() {
    // 处理解析错误
    match Expression::parse("invalid expression") {
        Ok(expr) => {
            // 处理评估错误
            match expr.eval(&()) {
                Ok(result) => println!("Result: {:?}", result),
                Err(e) => println!("Evaluation error: {}", e),
            }
        }
        Err(e) => println!("Parse error: {}", e),
    }
}

性能提示

1. 对于重复使用的表达式，先解析并保存Expression对象
2. 尽可能重用变量和函数映射
3. 简单的数学运算比字符串操作更快

cel-parser提供了一种安全高效的方式来在Rust应用中评估表达式，特别适合配置、规则引擎等场景。

完整示例

下面是一个整合了变量、函数和错误处理的完整示例：

use cel_parser::{Expression, Value, Function};
use std::collections::HashMap;

// 自定义乘法函数
fn multiply(args: &[Value]) -> Result<Value, String> {
    if args.len() != 2 {
        return Err("Expected 2 arguments".to_string());
    }
    
    match (&args[0], &args[1]) {
        (Value::Int64(a), Value::Int64(b)) => Ok(Value::Int64(a * b)),
        _ => Err("Expected integers".to_string()),
    }
}

fn main() {
    // 设置变量
    let mut vars: HashMap<String, Value> = HashMap::new();
    vars.insert("price".to_string(), Value::Int64(100));
    vars.insert("quantity".to_string(), Value::Int64(3));
    vars.insert("discount".to_string(), Value::Float(0.1));
    
    // 设置函数
    let mut funcs: HashMap<String, Function> = HashMap::new();
    funcs.insert("multiply".to_string(), multiply);
    
    // 解析复杂表达式
    let expr = match Expression::parse("multiply(price, quantity) * (1 - discount)") {
        Ok(e) => e,
        Err(e) => {
            println!("Parse error: {}", e);
            return;
        }
    };
    
    // 评估表达式
    match expr.eval_with_functions(&vars, &funcs) {
        Ok(result) => {
            println!("Final price: {:?}", result);
            // 输出: Final price: Value::Float(270.0)
        },
        Err(e) => println!("Evaluation error: {}", e),
    }
}

这个示例展示了：

1. 自定义函数的实现
2. 多种变量类型的处理(整数和浮点数)
3. 复杂的数学表达式
4. 全面的错误处理
5. 变量和函数的联合使用