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

Question

我正在尝试学习 Rust，并且像我之前的许多人一样着手编写一个 Fibonacci 序列迭代器进行练习。我的第一遍使用u32s 并且工作正常，所以我决定尝试编写一个通用版本。这是我的结果：

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 s 获得一个新的T。

这样，剩下的唯一问题就是改变值，这可以使用swap 来完成。

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