如何修复Rust代码以避免生成多余的OR运算符？

现有一段Rust代码，运行后生成的字符串为 A = 1 AND (B = 2 OR C = 3 OR D = 4 OR )，但实际需要的是 A = 1 AND (B = 2 OR C = 3 OR D = 4)。无法修改数据部分，不清楚如何避免最后出现的多余"OR"，需要修复代码。

enum Token {
    Str(&'static str),
    Value(&'static str),
    StartGroup(&'static str),
    EndGroup,
}

fn main() {
    let data: Vec<Vec<Token>> = vec![
        vec![Token::Str("A = "), Token::Value("1")],
        vec![Token::Str(" AND ("), Token::StartGroup(" OR ")],
        vec![Token::Str("B = "), Token::Value("2")],
        vec![Token::Str("C = "), Token::Value("3")],
        vec![Token::Str("D = "), Token::Value("4")],
        vec![Token::EndGroup, Token::Str(")")],
    ];

    let result = construct_string(data);

    assert_eq!("A = 1 AND (B = 2 OR C = 3 OR D = 4)", result);
}

fn construct_string(tokens: Vec<Vec<Token>>) -> String {
    let mut result = String::new();

    let mut current = String::new();
    let mut next = String::new();

    for token in tokens {
        for part in token {
            match part {
                Token::Str(str) => {
                    result.push_str(str);
                }
                Token::Value(val) => {
                    result.push_str(val);
                }
                Token::StartGroup(group) => {
                    next = group.to_string();
                }
                Token::EndGroup => {
                    current = String::new();
                    next = String::new();
                }
            }
        }

        if !current.is_empty() {
            result.push_str(&current);
        }

        current = next.to_string();
    }

    result
}

问题根源是原代码会在每一组token处理后无条件追加current，包括最后一组（EndGroup组）之前的current仍是"OR "，导致末尾冗余。可以通过区分分组状态，集中处理分组内元素的方式解决：

修改construct_string函数如下：

fn construct_string(tokens: Vec<Vec<Token>>) -> String {
    let mut result = String::new();
    // 标记是否处于分组中，同时存储分组分隔符
    let mut group_separator: Option<String> = None;
    // 存储分组内的所有子项
    let mut group_items = Vec::new();

    for token in tokens {
        let mut segment = String::new();
        for part in token {
            match part {
                Token::Str(s) => segment.push_str(s),
                Token::Value(v) => segment.push_str(v),
                Token::StartGroup(sep) => {
                    // 进入分组：先把当前片段追加到结果，记录分隔符
                    result.push_str(&segment);
                    segment.clear();
                    group_separator = Some(sep.to_string());
                }
                Token::EndGroup => {
                    // 结束分组：用分隔符拼接所有子项，追加到结果
                    if !group_items.is_empty() {
                        result.push_str(&group_items.join(&group_separator.unwrap_or_default()));
                    }
                    group_items.clear();
                    group_separator = None;
                }
            }
        }

        match group_separator {
            Some(_) => group_items.push(segment), // 分组内的子项暂存
            None => result.push_str(&segment),    // 非分组内容直接追加
        }
    }

    result
}

修复逻辑说明 #

1. 新增group_separator和group_items，分别跟踪分组状态、分隔符，以及分组内的子元素；
2. 遇到StartGroup时，切换到分组模式，后续的token组内容都存入group_items；
3. 遇到EndGroup时，用分隔符将group_items中的元素拼接后再追加到结果，避免末尾多余分隔符；
4. 非分组模式下，仍直接将token组内容追加到结果，不改变原有逻辑。

内容的提问来源于stack exchange，提问作者Fred Hors