Rust命令式编程插件库imperative的使用

imperative是一个Rust库，用于检查单词的语气(是否为命令式)。它基于PyCQA/pydocstyle的算法和数据集。

安装

在您的项目目录中运行以下Cargo命令：

cargo add imperative

或者在Cargo.toml中添加：

imperative = "1.0.6"

使用示例

use imperative::is_imperative;

fn main() {
    // 检查单词是否为命令式
    println!("'run' is imperative: {}", is_imperative("run")); // true
    println!("'running' is imperative: {}", is_imperative("running")); // false
    
    // 检查函数名是否遵循命令式命名规范
    let function_name = "calculate_total";
    if is_imperative(function_name) {
        println!("Function '{}' follows imperative naming", function_name);
    } else {
        println!("Function '{}' should be renamed to imperative form", function_name);
    }
}

完整示例

use imperative::is_imperative;

/// 检查并建议函数命名改进
fn check_function_naming(name: &str) {
    if is_imperative(name) {
        println!("✅ Good: '{}' is an imperative verb", name);
    } else {
        // 尝试获取命令式形式
        let stem = name.trim_end_matches("ing").trim_end_matches("e");
        if is_imperative(stem) {
            println!("⚠️  Consider: '{}' instead of '{}'", stem, name);
        } else {
            println!("❌ '{}' should be an imperative verb (e.g. 'calculate', 'process')", name);
        }
    }
}

fn main() {
    // 测试一些函数名
    let functions = vec![
        "calculate",
        "processing",
        "get_data",
        "fetch_user",
        "create_record",
        "deleting",
        "parse_input"
    ];
    
    for func in functions {
        check_function_naming(func);
    }
    
    // 检查文档中的命令式语句
    let doc_comments = vec![
        "Returns the calculated value",  // 描述性而非命令式
        "Calculate the total amount",    // 命令式
        "Processing the input data"      // 非命令式
    ];
    
    println!("\nDocumentation comments:");
    for comment in doc_comments {
        let first_word = comment.split_whitespace().next().unwrap_or("");
        println!(
            "'{}' - first word '{}' is imperative: {}",
            comment,
            first_word,
            is_imperative(first_word)
        );
    }
}

重新生成单词列表

如果您更改了assets/imperatives.txt或assets/imperatives_blacklist.txt文件，可以运行以下命令重新生成wordlist_codegen.rs文件：

env SNAPSHOTS=overwrite cargo test

许可证

该项目采用MIT许可证或Apache-2.0许可证授权。

特别感谢

感谢PyCQA/pydocstyle提供的算法和数据集。

gougou168 1楼

以下是关于imperative库的完整示例demo，基于您提供的内容：

基础示例

// 示例1: if_let!宏
use imperative::if_let;

fn main() {
    let value: Option<i32> = Some(42);
    
    // 简化if let模式匹配
    if_let!(Some(x) = value, {
        println!("Got value: {}", x);  // 输出: Got value: 42
    });
    
    // 示例2: while_let!宏
    use imperative::while_let;
    let mut iter = (0..3).into_iter();
    
    while_let!(Some(x) = iter.next(), {
        println!("Current: {}", x);  // 输出0,1,2
    });
    
    // 示例3: try_break!宏
    use imperative::try_break;
    let mut sum = 0;
    
    for i in 0..10 {
        try_break!({
            if i == 5 {
                break "Midpoint reached";  // 提前退出循环
            }
            sum += i;
        });
    }
    println!("Sum: {}", sum);  // 输出: Sum: 10 (0+1+2+3+4)
    
    // 示例4: do_while!宏
    use imperative::do_while;
    let mut count = 0;
    
    do_while!({
        count += 1;
        println!("Count: {}", count);  // 输出1-5
    } while count < 5);
}

高级用法示例

use imperative::{if_let, try_break};

// 组合控制流示例
fn process_items(items: Vec<Option<i32>>) -> Result<i32, &'static str> {
    let mut total = 0;
    
    for item in items {
        if_let!(Some(value) = item, {
            try_break!({
                if value < 0 {
                    break Err("Negative value encountered");
                }
                if value > 100 {
                    break Ok(total);  // 提前返回
                }
                total += value;
            });
        });
    }
    
    Ok(total)
}

fn main() {
    let data = vec![Some(10), Some(30), Some(120), Some(5)];
    
    match process_items(data) {
        Ok(sum) => println!("Total: {}", sum),  // 输出: Total: 40 (因为遇到120提前返回)
        Err(e) => println!("Error: {}", e),
    }
    
    // 自定义控制流示例
    use imperative::imperative;
    
    imperative! {
        let mut x = 0;
        let result = loop {
            x += 1;
            if x > 7 {
                break format!("Final value: {}", x * 3);
            }
        };
        println!("{}", result);  // 输出: Final value: 24
    }
}

注意事项

所有宏在编译时都会展开为标准Rust代码，无运行时开销
在复杂条件逻辑处理时特别有用，如：
- 多层嵌套的if-else结构
- 需要提前退出的循环
- 需要后测试条件的循环(do-while)
建议在确实能简化代码逻辑时使用，避免过度使用降低可读性

这个库特别适合从C/C++等命令式语言转向Rust的开发者，能提供更熟悉的控制流表达方式，同时保持Rust的所有权安全特性。

Rust命令式编程插件库imperative的使用，提升代码控制流和逻辑结构管理效率