不可变字符串和克隆

Question

我的心态是让我的Strings 不可变，这是一个单一的事实来源。 当我将同样的心态带入 Rust 时，我发现我必须做很多克隆。 由于Strings 没有改变，所有的克隆都是不必要的。 下面有一个例子和link to the relevant playground。

借用似乎不是一种选择，因为我必须处理引用及其生命周期。我的下一个想法是使用类似Rc 或Cow 结构的东西。但是用Rc 之类的东西包裹所有Strings 感觉不自然。在我有限的 Rust 经验中，我从未见过任何暴露的所有权/内存管理结构，即 Rc 和 Cow。我很好奇一个更有经验的 Rust 开发人员会如何处理这样的问题。

在 Rust 中公开所有权/内存管理结构，如 Rc 和 Cow 是否真的很自然？我应该使用切片吗？

use std::collections::HashSet;

#[derive(Debug)]
enum Check {
    Known(String),
    Duplicate(String),
    Missing(String),
    Unknown(String)
}

fn main() {
    let known_values: HashSet<_> = [
        "a".to_string(),
        "b".to_string(),
        "c".to_string()]
            .iter().cloned().collect();

    let provided_values = vec![
        "a".to_string(),
        "b".to_string(),
        "z".to_string(),
        "b".to_string()
    ];

    let mut found = HashSet::new();

    let mut check_values: Vec<_> = provided_values.iter().cloned()
        .map(|v| {
            if known_values.contains(&v) {
                if found.contains(&v) {
                    Check::Duplicate(v)
                } else {
                    found.insert(v.clone());
                    Check::Known(v)
                }
            } else {
                Check::Unknown(v)
            }
        }).collect();

    let missing = known_values.difference(&found);

    check_values = missing
        .cloned()
        .fold(check_values, |mut cv, m| {
            cv.push(Check::Missing(m));
            cv
        });

    println!("check_values: {:#?}", check_values);
}

Answer 1

从我的问题的 cmets 中的讨论来看，示例中所有不可变 Strings 的克隆都是正确的。由于 Rust 通过所有权而不是其他语言的引用来处理内存，因此克隆是必要的。

在最好的情况下，不使用Rc，我可以通过在provided_values 上使用移动语义来减少克隆。

更新：一些有趣的阅读

• https://www.reddit.com/r/rust/comments/5xjl95/rc_or_cloning/
• https://medium.com/swlh/ownership-managing-memory-in-rust-ce7bf3f5c9d5
• How to create a Rust struct with string members?

Cow 在我的示例中不起作用，因为它涉及引用的借用。 Rc 将是我必须使用的。在我的示例中，所有内容都必须转换为Rc，但我可以看到这一切都可以通过封装隐藏起来。

use std::collections::HashSet;
use std::rc::Rc;

#[derive(Debug)]
enum Check {
    Known(Rc<String>),
    Duplicate(Rc<String>),
    Missing(Rc<String>),
    Unknown(Rc<String>)
}

fn main() {
    let known_values: HashSet<_> = [
        Rc::new("a".to_string()),
        Rc::new("b".to_string()),
        Rc::new("c".to_string())]
            .iter().cloned().collect();

    let provided_values = vec![
        Rc::new("a".to_string()),
        Rc::new("b".to_string()),
        Rc::new("z".to_string()),
        Rc::new("b".to_string())
    ];

    let mut found = HashSet::new();

    let mut check_values: Vec<_> = provided_values.iter().cloned()
        .map(|v| {
            if known_values.contains(&v) {
                if found.contains(&v) {
                    Check::Duplicate(v)
                } else {
                    found.insert(v.clone());
                    Check::Known(v)
                }
            } else {
                Check::Unknown(v)
            }
        }).collect();

    let missing = known_values.difference(&found);

    check_values = missing
        .cloned()
        .fold(check_values, |mut cv, m| {
            cv.push(Check::Missing(m));
            cv
        });

    println!("check_values: {:#?}", check_values);
}

Playground