rust - 如何避免 Rust 中的过度克隆？

Question

我正在尝试学习 Rust，并且像我之前的许多人一样开始编写斐波那契数列迭代器进行练习。我的第一遍使用了 u32 并且运行良好，所以我决定尝试编写一个通用版本。这是我的结果:

use num::Integer;
use std::ops::Add;

pub struct Fibonacci<T: Integer + Add + Clone> {
    nth: T,
    n_plus_one_th: T,
}

impl<T: Integer + Add + Clone> Iterator for Fibonacci<T> {
    type Item = T;
    fn next(&mut self) -> Option<T> {
        let temp = self.nth.clone();
        self.nth = self.n_plus_one_th.clone();
        self.n_plus_one_th = temp.clone() + self.n_plus_one_th.clone();
        Some(temp)
    }
}

impl<T: Integer + Add + Clone> Fibonacci<T> {
    pub fn new() -> Fibonacci<T> {
        Fibonacci {
            nth: T::one(),
            n_plus_one_th: T::one(),
        }
    }
}

我用 u32 和 num::BigUint 测试了它，它工作正常。不过，我担心 next 方法中的所有克隆。特别是，我不明白为什么我需要在添加步骤中进行克隆。

我怀疑有更好的方法可以使用 Rust 的一些更高级的引用概念来编写它，但到目前为止我还没有想出。

Answer 1

解决方案是使用 where像这样的子句:

extern crate num;

use num::One;
use std::ops::Add;

pub struct Fibonacci<T> {
    nth: T,
    n_plus_one_th: T,
}

impl<T> Fibonacci<T>
    where T: One
{
    pub fn new() -> Fibonacci<T> {
        Fibonacci {
            nth: T::one(),
            n_plus_one_th: T::one(),
        }
    }
}

impl<T> Iterator for Fibonacci<T>
    where for<'a> &'a T: Add<&'a T, Output = T>
{
    type Item = T;
    fn next(&mut self) -> Option<T> {
        use std::mem::swap;
        let mut temp = &self.nth + &self.n_plus_one_th;
        swap(&mut self.nth, &mut temp);
        swap(&mut self.n_plus_one_th, &mut self.nth);
        Some(temp)
    }
}

具体来说，for<'a> &'a T: Add<&'a T, Output=T>子句读作“对于任何生命周期 'a，&'a T 必须实现 Add，RHS 为 &'a T 和 Output=T。也就是说，您可以添加两个 &T 以获得新的 T。

有了这个，唯一剩下的问题就是改变周围的值，这可以使用 swap 来完成。 .

我还冒昧地简化了其他地方的约束(您只需要 One，而不是 Integer)。