从可变方法共享引用：Rust非分配算法的惯用实现

Rust不允许多个可变借用的规则我理解，但在实现部分算法时找不到优雅的写法。以下是这类算法的简化版本：Ladder结构体可以生成递增序列的切片，比如[0]、[0, 1]、[0, 1, 2]等：

struct Ladder {
    position: usize,
    data: [u8; 10],
}

impl Ladder {
    fn get_next(&mut self) -> &[u8] {
        self.position += 1;
        &self.data[0..self.position]
    }
    
    fn new() -> Ladder {
        Ladder {
            position: 0,
            data: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
        }
    }
}

我需要多次调用get_next()，收集返回的序列切片后传给闭包处理，且要求算法是非分配式的，不能使用std::Vec。尝试的代码会触发借用检查冲突：

fn test_ladder(consumer: impl Fn(&[&[u8]])) {
    let mut l = Ladder::new();
    let mut steps: [&[u8]; 3] = [&[]; 3];

    steps[0] = l.get_next();
    steps[1] = l.get_next(); // 此处触发可变借用冲突
    steps[2] = l.get_next();

    consumer(&steps);
}

fn main() {
    test_ladder(|steps| {
        for seq in steps {
            println!("{:?}", *seq);
        }
    });
}

请问处理这类问题的Rust惯用方式是什么？

1. 一次性生成所有所需切片 #

既然明确需要收集的切片数量（比如示例中的3个），可以修改Ladder提供批量生成方法，完全规避可变借用冲突：

impl Ladder {
    // 新增批量生成方法，返回指定数量的切片数组
    fn get_steps<const N: usize>(&self) -> [&[u8]; N] {
        (0..N)
            .map(|i| &self.data[0..=i])
            .collect::<Vec<_>>()
            .try_into()
            .unwrap()
    }
}

fn test_ladder(consumer: impl Fn(&[&[u8]])) {
    let l = Ladder::new();
    let steps = l.get_steps::<3>();
    consumer(&steps);
}

这种方式无需修改Ladder内部状态，直接基于初始数据生成所有切片，try_into是编译期转换，无堆分配，完全符合非分配式要求。

2. 让闭包逐次处理切片（无需收集） #

如果不需要同时持有所有切片，调整逻辑让闭包逐个处理每个生成的切片，这是最贴合Rust借用规则的写法：

fn test_ladder(consumer: impl Fn(&[u8])) {
    let mut l = Ladder::new();
    for _ in 0..3 {
        consumer(l.get_next());
    }
}

fn main() {
    test_ladder(|seq| {
        println!("{:?}", seq);
    });
}

每次只持有一个可变借用的结果，处理完就释放，不会产生冲突，代码简洁且安全。

3. 迭代器模式（推荐长期方案） #

Rust中处理序列生成的惯用方式是迭代器，既符合安全规则，又具备灵活性：

impl Ladder {
    fn iter(&self) -> impl Iterator<Item = &[u8]> {
        (1..=self.data.len())
            .map(|len| &self.data[0..len])
    }
}

fn test_ladder(consumer: impl Fn(&[&[u8]])) {
    let l = Ladder::new();
    let steps: [&[u8]; 3] = l.iter().take(3).collect::<Vec<_>>().try_into().unwrap();
    consumer(&steps);
}

迭代器天然适配批量生成、逐个处理等多种场景，无需手动管理借用状态，是最推荐的长期解决方案。

4. 内部暂存切片（进阶unsafe用法） #

如果必须保留get_nextAPI且需同时持有所有切片，可以通过内部暂存+unsafe生命周期转换实现（仅当Ladder的data不会被修改/移动时安全）：

struct Ladder {
    position: usize,
    data: [u8; 10],
    slices: [Option<&'static [u8]>; 10],
}

impl Ladder {
    fn get_next(&mut self) -> &[u8] {
        self.position += 1;
        let slice = &self.data[0..self.position];
        // 转换生命周期为'static，需确保data不会被修改/移动
        let static_slice: &'static [u8] = unsafe { std::mem::transmute(slice) };
        self.slices[self.position - 1] = Some(static_slice);
        slice
    }
    
    fn new() -> Ladder {
        Ladder {
            position: 0,
            data: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
            slices: [None; 10],
        }
    }
    
    fn get_all_slices(&self) -> &[Option<&[u8]>] {
        &self.slices[0..self.position]
    }
}

fn test_ladder(consumer: impl Fn(&[&[u8]])) {
    let mut l = Ladder::new();
    l.get_next();
    l.get_next();
    l.get_next();
    
    let steps: [&[u8]; 3] = l.get_all_slices()
        .iter()
        .map(|opt| opt.unwrap())
        .collect::<Vec<_>>()
        .try_into()
        .unwrap();
    
    consumer(&steps);
}

注意：此方法使用unsafe，属于进阶用法，除非必要不推荐优先使用。

内容的提问来源于stack exchange，提问作者RajV