Rust中如何解决递归函数返回数据的生命周期E0515报错问题

问题本质 #

你当前的写法确实存在生命周期风险：你在函数内创建的局部变量expanded会在当前栈帧销毁时被释放，你将它的引用传给递归调用后，递归返回的&str会被标记为和这个局部变量同生命周期，自然无法被上层调用者使用。
你直接返回Ok(expanded)没问题的核心原因是：expanded里存储的所有&str的生命周期要么来自入参symbols的'a，要么来自user_ops的'a，本身都是和函数入参绑定的长生命周期，没有引用当前栈帧的局部数据。问题出在递归调用时，你把存储这些长生命周期&str的容器本身的生命周期和局部栈帧绑定了，导致编译器误判了内部元素的生命周期。

解决方案1：返回所有权（推荐，代码最简洁） #

直接修改返回值为Result<Vec<String>, Error>，把所有引用转成拥有所有权的字符串，完全规避生命周期问题，同时可以保留你用AsRef兼容多种入参的设计：

fn expand_symbols<T: AsRef<str>>(
    symbols: &[T],
    ops: &HashMap<String, String>,
    user_ops: &HashMap<String, String>,
) -> Result<Vec<String>, Error> {
    if symbols.iter().all(|x| ops.get(x.as_ref()).is_some()) {
        let symbols = symbols.iter().map(|x| x.as_ref().to_string()).collect();
        return Ok(symbols);
    }

    let mut expanded = Vec::new();
    for s in symbols {
        let s = s.as_ref();
        if ops.contains_key(s) || s.parse::<i32>().is_ok() {
            expanded.push(s.to_string());
        } else {
            let resolved = user_ops
                .get(s)
                .ok_or(Error::Bad)?
                .split_ascii_whitespace()
                .map(|s| s.to_string());
            expanded.extend(resolved);
        }
    }
    expand_symbols(&expanded, ops, user_ops)
}

这个方案的额外拷贝开销在绝大多数业务场景下可以忽略，而且代码没有额外复杂度。

解决方案2：零拷贝递归（无额外拷贝，保留引用返回） #

如果你确实需要零开销的引用返回，可以调整递归结构，把结果容器从最外层传入，避免每一层递归创建的局部容器绑定生命周期：

// 内部递归辅助函数
fn expand_symbols_inner<'a, T: AsRef<str>>(
    symbols: &'a [T],
    ops: &HashMap<String, String>,
    user_ops: &'a HashMap<String, String>,
    result: &mut Vec<&'a str>,
) -> Result<(), Error> {
    for s in symbols {
        let s = s.as_ref();
        if ops.contains_key(s) || s.parse::<i32>().is_ok() {
            result.push(s);
        } else {
            let resolved = user_ops
                .get(s)
                .ok_or(Error::Bad)?
                .split_ascii_whitespace()
                .collect::<Vec<_>>();
            // 递归展开子项，直接写入同一个结果容器
            expand_symbols_inner(&resolved, ops, user_ops, result)?;
        }
    }
    Ok(())
}

// 对外暴露的入口函数，保留原来的入参兼容设计
fn expand_symbols<'a, T: AsRef<str>>(
    symbols: &'a [T],
    ops: &HashMap<String, String>,
    user_ops: &'a HashMap<String, String>,
) -> Result<Vec<&'a str>, Error> {
    let mut result = Vec::new();
    expand_symbols_inner(symbols, ops, user_ops, &mut result)?;
    Ok(result)
}

这个方案完全没有字符串拷贝，也保留了你原来用AsRef兼容Vec<String>和Vec<&str>入参的设计，不需要放弃原来的接口设计。

补充说明 #

你不需要放弃AsRef的入参设计，两种方案都可以兼容多种入参类型，只需要根据你的性能需求选择对应方案即可。

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