实现具有内部可变性的索引

Question

考虑一下，为了简单起见，我想实现一个具有 n 个连续元素 0,1,...,n-1 的可索引向量 v，即 v[i] = i。这个向量应该是按需填充的，也就是说，如果使用 v[i] 并且当前向量包含 n

下面的代码可以正常工作。

struct LazyVector {
    data: Vec<usize>
}

impl LazyVector {
    fn new() -> LazyVector {
        LazyVector{
            data: vec![] 
        }
    }
    fn get(&mut self, i:usize) -> &usize {
        for x in self.data.len()..=i {
            self.data.push(i);
        }
        &self.data[i]
    }
}


pub fn main() {
    let mut v = LazyVector::new();
    println!("v[5]={}",v.get(5)); // prints v[5]=5
}

但是，上面的代码只是我尝试实现的实际结构的模型。除此之外，（1）我希望能够使用索引运算符，（2）尽管在访问位置时实际上可能会修改向量，但我希望这对用户是透明的，即也就是说，即使我对 v 有不可变引用，我也希望能够索引任何位置。不可变引用是首选，以防止其他不需要的修改。

要求 (1) 可以通过实现 Index trait 来实现，就像这样

impl std::ops::Index<usize> for LazyVector {
    type Output = usize;
    fn index(&self, i: usize) -> &Self::Output {
        self.get(i)
    }
}

但是，这不会编译，因为我们需要一个可变引用才能调用 LazyVector::get。由于要求 (2)，我们不想让这个引用可变，即使我们这样做了，我们也不能这样做，因为它会违反 Index trait 的接口。我认为这可以通过 RefCell 智能指针实现内部可变性模式（如 The Rust Book 的第 15 章）。所以我想出了类似的东西

struct LazyVector {
    data: std::cell::RefCell<Vec<usize>>
}

impl LazyVector {
    fn new() -> LazyVector {
        LazyVector{
            data: std::cell::RefCell::new(vec![]) 
        }
    }

    fn get(&self, i:usize) -> &usize {
        let mut mutref = self.data.borrow_mut();
        for x in mutref.len()..=i {
            mutref.push(x)
        }
        &self.data.borrow()[i] // error: cannot return value referencing a temporary value
    }
}

但这不起作用，因为它试图返回一个引用借用（）返回的 Ref 结构的值，该结构在 LazyVector::get 的末尾超出范围。最后，为了避免这种情况，我做了类似的事情

struct LazyVector {
    data: std::cell::RefCell<Vec<usize>>
}


impl LazyVector {
    fn new() -> LazyVector {
        LazyVector{
            data: std::cell::RefCell::new(vec![]) 
        }
    }

    fn get(&self, i:usize) -> &usize {
        let mut mutref = self.data.borrow_mut();
        for x in mutref.len()..=i {
            mutref.push(x)
        }
        unsafe { // Argh!
            let ptr = self.data.as_ptr();
            &std::ops::Deref::deref(&*ptr)[i]
        }
    }
}


impl std::ops::Index<usize> for LazyVector {
    type Output = usize;
    fn index(&self, i: usize) -> &Self::Output {
        self.get(i)
    }
}

pub fn main() {
    let v = LazyVector::new();    // Unmutable!
    println!("v[5]={}",v.get(5)); // prints v[5]=5
}

现在它可以按要求工作，但作为新手，我不太确定 unsafe 块！我想我正在用一个安全的界面有效地包装它，但我不确定。所以我的问题是这是否可行，或者是否有更好、完全安全的方法来实现这一目标。

感谢您的帮助。

Answer 1

编辑由于您提供了有关您的目标的更多信息（对位于磁盘上的大文件块的延迟访问），我更新了我的答案。

您可以使用（如您尝试的那样）单元格。我引用doc：

由于细胞类型在原本不允许的情况下启用突变，因此在某些情况下内部可变性可能是合适的，甚至必须使用，例如[...] 逻辑不可变方法的实现细节。 [...]

这是完成这项工作的一段代码（请注意，这与您编写的内容非常接近）：

use std::cell::RefCell;
use std::ops::Index;

// This is your file
const DATA: &str = "Rust. A language empowering everyone to build reliable and efficient software.";

#[derive(Debug)]
struct LazyVector<'a, 'b> {
    ref_v: RefCell<&'a mut Vec<&'b str>>
}

impl<'a, 'b> LazyVector<'a, 'b> {
    fn new(v: &'a mut Vec<&'b str>) -> LazyVector<'a, 'b> {
        LazyVector {
            ref_v: RefCell::new(v)
        }
    }

    /// get or load a chunk of two letters
    fn get_or_load(&self, i: usize) -> &'b str {
        let mut v = self.ref_v.borrow_mut();
        for k in v.len()..=i {
            v.push(&DATA[k * 2..k * 2 + 2]);
        }
        v[i]
    }
}

impl<'a, 'b> Index<usize> for LazyVector<'a, 'b> {
    type Output = str;
    fn index(&self, i: usize) -> &Self::Output {
        self.get_or_load(i)
    }
}

pub fn main() {
    let mut v = vec![];
    let lv = LazyVector::new(&mut v);
    println!("v[5]={}", &lv[5]); // v[5]=ng
    println!("{:?}", lv); // LazyVector { ref_v: RefCell { value: ["Ru", "st", ". ", "A ", "la", "ng"] } }
    println!("v[10]={}", &lv[10]); // v[10]=ow
    println!("{:?}", lv); // LazyVector { ref_v: RefCell { value: ["Ru", "st", ". ", "A ", "la", "ng", "ua", "ge", " e", "mp", "ow"] } }
}

与您的尝试的主要区别在于底层Vec 是一个外部可变向量，而LazyVector 在此向量上仅获得一个（可变）引用。 RwLock 应该是处理并发访问的方式。

但是，我不推荐该解决方案：

首先，您的底层Vec 将迅速增长并变得与磁盘上的文件一样大。因此，您将需要一个地图而不是矢量，并将该地图中的块数保持在给定边界之下。如果您要求一个不在内存中的块，您必须选择一个要删除的块。这只是Paging，操作系统通常比你更擅长这个游戏（见page replacement algorithm）。正如我在评论中所写，memory mapped files（在“繁重”进程的情况下可能是shared memory）会更有效：操作系统处理文件的延迟加载和只读数据的共享。 R. Sedgewick 在Algorithms in C 第一版第 13 章“更简单的方法”一节中的评论解释了为什么对大文件（比内存大）进行排序可能比想象的更容易：

在良好的虚拟内存系统中，程序员可以处理大量数据，让系统负责确保在需要时将寻址数据从外部存储传输到内部存储。

其次，请看下面我之前的回答。

以前的答案

我曾经用 Java 编写过这种向量。用例是表示一个非常稀疏的网格（许多 只有几个单元格宽的行，但网格应该有 1024 的宽度）。避免 为了必须在需要时手动添加单元格，我创建了一个“列表”，大致完成了您尝试实现的目标（但只有一个默认值）。

起初，我让我的列表实现了List 接口，但我很快意识到我必须编写很多无用（而且速度很慢）的代码才能不破坏Liskov substitution principle。更糟糕的是，某些方法的行为对通常的列表具有误导性（ArrayList、LinkedList、...）。

您似乎处于相同的情况：您希望您的 LazyVector 看起来像通常的 Vec，这就是您想要实现 Index 和可能 IndexMut 特征的原因。但是您正在寻找解决方法来实现这一点（例如，unsafe 代码以匹配特征方法签名）。

我的建议是：不要试图让LazyVector 看起来像一个普通的向量，但要明确LazyVector 不是一个普通的向量。这是Principle of least astonishment。例如。用get_or_extend 替换get（预计只能由用户善意地读取数据），这清楚地表明要么你得到一些东西，要么你创造它。 如果你添加一个get_or_extend_mut 函数，你得到的东西不是很吸引人，但高效且可预测：

impl LazyVector {
    fn new() -> LazyVector { ... }

    fn get_or_extend(&mut self, i: usize) -> &usize { ... }

    fn get_or_extend_mut(&mut self, i: usize) -> &mut usize { ... }
}