相关疑难解决方法(0)

我有一个为 int 做的函数：

fn some_to_value(src: Option<&int>) -> Option<int> {
    match src {
        Some(x) => Some(*x),
        None => None
    }
}

我想让它通用（并且仍然在调用者级别使用“int”）。如果复制 T 的实例对我来说就可以了。所以我尝试这样做：

fn some_to_value<T>(src: Option<&T>) -> Option<T> {
    match src {
        Some(x) => Some(*x),
        None => None
    }
}

我得到：

error: cannot move out of dereference of `&`-pointer
Some(x) => Some(*x),
                ^~

我不明白为什么它会失败（我是初学者）。

一些上下文：我制作了一个 Option 的副本，因为我意识到在对“HashMap”进行“查找”之后，只要返回“查找”（一个包含对地图的项目）是活着的。

我想做什么:

enum Test {
    Value1,
    Value2,
    Value3
}

fn main() {
    let mut test_vec: Vec<Test> = Vec::new();
    test_vec.push(Test::Value2);

    if let Some(last) = test_vec.last() {
        test_vec.push(*last);
    }
    //Wanted output: vector with [Test::Value2, Test::Value2]
}

我明白,当我打电话时last(),它会返回Option<&Test> 所以它会借用test_vec直到if-let块结束.

我尝试了以下但没有成功:

if let Some(last) = test_vec.last().map(|v| v.clone()) {
    test_vec.push(*last);
}

//and

let last = test_vec.last().unwrap().clone();
test_vec.push(*last);

我正在尝试编写代码来获取某个向量的最后一个元素,并根据该元素执行不同的操作(包括向量的变异).

我试过这样的:

#[derive(Clone, PartialEq)]
enum ParseItem {
    Start,
    End,
}

let mut item_vec = vec![ParseItem::End];
loop {
    let last_item = *item_vec.last().clone().unwrap();
    match last_item {
        ParseItem::End => item_vec.push(ParseItem::Start),
        _ => break,
    }
}

我收到以下错误:

错误:无法移出借来的内容
让last_item =*item_vec.last().clone().unwrap();

我认为通过克隆item_vec.last(),所有权问题将得到解决,但似乎没有.

如果我用这样的整数向量尝试相同的东西:

let mut int_vec = vec![0];
loop {
    let last_int = *int_vec.last().clone().unwrap();
    match last_int {
        0 => int_vec.push(1),
        _ => break,
    }
}

编译器不会抱怨借用.

为什么我的代码无法编译？

我有一个Option包含一些 JSON 的。如果是Some，则必须转换内部 JSON，但如果是None，则必须保留None。

这就是我目前实施的方式：

struct One;
struct Other;

impl One {
    pub fn convert(&self) -> Other {
        Other {}
    }
}

fn example(attr: Option<One>) -> Option<Other> {
    match attr {
        Some(attr) => Some(attr.convert()),
        None => None,
    }
}

我是新来的锈和不完全获得时使用的复杂性match，if let或时使用的?运营商。

我的实现是 Rust 惯用的吗？对我来说似乎比较冗长，而且看起来像一个到处都会出现的模式，所以我可以想象这可以更简洁地处理；是这样吗？