rust - 变异和非变异方法链

Question

我有两个函数，我希望在方法链中使用它们。它们基本上做同样的事情，除了其中一个覆盖自身而另一个返回一个克隆。我来自 Ruby，我习惯于在破坏性方法中调用 self.dup.mutable_method。

我相信我有一个用 Rust 制定的解决方案，但我不确定它是否在某个地方进行了额外的分配，我担心它会消耗掉自己。这是音频 DSP 代码，所以我想确保可变方法中没有分配。 (我学习 Rust 三天了，所以我对非泛化 trait impls 感到内疚。)

impl Filter for DVec<f64> {
    fn preemphasis_mut<'a>(&'a mut self, freq: f64, sample_rate: f64) -> &'a mut DVec<f64> {
        let filter = (-2.0 * PI * freq / sample_rate).exp();
        for i in (1..self.len()).rev() {
            self[i] -= self[i-1] * filter;
        };
        self
    }

    fn preemphasis(&self, freq: f64, sample_rate: f64) -> DVec<f64> {
        let mut new = self.clone();
        new.preemphasis_mut(freq, sample_rate);
        new
    }
}


// Ideal code:
let mut sample: DVec<f64> = method_that_loads_sample();
let copy_of_sample = sample.preemphasis(75.0, 44100.0); // this mutates and copies, with one allocation
sample.preemphasis_mut(75.0, 44100.0); // this mutates in-place, with no allocations
copy_of_sample.preemphasis_mut(75.0, 44100.0)
    .preemphasis_mut(150.0, 44100.0); // this mutates twice in a row, with no allocations

Answer 1

我还没有看到任何库在自突变方面遵循类似于 Ruby 的 foo 和 foo! 方法对的任何模式。我认为这主要是因为 Rust 将可变性放在首位，因此“意外”改变某些东西要困难得多。为此，我可能会放弃您的一种方法，并允许用户决定何时应该更改某些内容:

use std::f64::consts::PI;

trait Filter {
    fn preemphasis<'a>(&'a mut self, freq: f64, sample_rate: f64) -> &'a mut Self;
}

impl Filter for Vec<f64> {
    fn preemphasis<'a>(&'a mut self, freq: f64, sample_rate: f64) -> &'a mut Self {
        let filter = (-2.0 * PI * freq / sample_rate).exp();
        for i in (1..self.len()).rev() {
            self[i] -= self[i-1] * filter;
        };
        self
    }
}

fn main() {
    let mut sample = vec![1.0, 2.0];
    // this copies then mutates, with one allocation
    let mut copy_of_sample = sample.clone();
    copy_of_sample
        .preemphasis(75.0, 44100.0); 
    // this mutates in-place, with no allocations
    sample
        .preemphasis(75.0, 44100.0); 
    // this mutates twice in a row, with no allocations
    copy_of_sample
        .preemphasis(75.0, 44100.0)
        .preemphasis(150.0, 44100.0);
}

我认为这里的关键是代码的调用者可以很容易地看到什么时候会发生变异(因为 &mut 引用了 self)。 调用者 还可以确定克隆 发生的时间和地点。