集合中的 Rust 返回对象，其生存期短于集合本身

问：

我正在尝试使用.这个想法是，我有一个包装字节引用的结构，在创建新对象时，我检查它包装的字节是否已经在使用中，如果是，则重用现有的堆分配字节。HashSet

#![feature(new_uninit)]

#[derive(Debug, Clone)]
pub struct ObjStorageT {
    /// Tab for unique storage
    pub tab_: std::collections::HashSet<Box<[u8]>>,
}

impl ObjStorageT {
    /// Create new byte storage
    pub fn new() -> Self {
        return ObjStorageT {
            tab_: std::collections::HashSet::<Box<[u8]>>::new(),
        };
    }

    /// Get existing bytes from storage or new new bytes if they don't exist.
    pub fn getBytes(&mut self, bytes: &[u8]) -> &[u8] {
        if !self.tab_.contains(bytes) {
            let mut new_bytes_base: Box<[std::mem::MaybeUninit<u8>]> =
                Box::new_uninit_slice(bytes.len());
            for i in 0..bytes.len() {
                new_bytes_base[i].write(bytes[i]);
            }
            self.tab_.insert(unsafe { new_bytes_base.assume_init() });
        }
        let existing_bytes: Option<&Box<[u8]>> = self.tab_.get(bytes);
        return existing_bytes.unwrap();
    }
}

/// Get storage for ir constants
pub fn globalStorage() -> &'static mut ObjStorageT {
    static mut GLBStorageOnce: bool = false;
    static mut GLBStorage: std::mem::MaybeUninit<ObjStorageT> = std::mem::MaybeUninit::uninit();
    #[allow(unsafe_code)]
    unsafe {
        if !GLBStorageOnce {
            GLBStorageOnce = true;
            GLBStorage.write(ObjStorageT::new());
        }
        return GLBStorage.assume_init_mut();
    }
}

#[derive(Debug, Copy, Clone)]
pub struct BytesWrapperT<'a> {
    bytes_: &'a [u8],
}

impl BytesWrapperT<'_> {
    /// New new constant w/ global obj storage
    pub fn new<'a, 'b>(store_: &'a mut ObjStorageT, bytes: &[u8]) -> BytesWrapperT<'a> {
        let new_bytes = store_.getBytes(bytes);
        return BytesWrapperT { bytes_: new_bytes };
    }

    /// New new constant w/ global obj storage
    pub fn newGlobal<'g>(bytes: &[u8]) -> BytesWrapperT<'g> {
        let new_bytes = globalStorage().getBytes(bytes);
        return BytesWrapperT { bytes_: new_bytes };
    }

    pub fn isZeros(self) -> bool {
        return self.bytes_.into_iter().all(|x| *x == 0);
    }
}

// Doesn't Compile
fn main() {
    let mut store: ObjStorageT = ObjStorageT::new();
    let mut arr0: [u8; 64] = [0; 64];

    let bw0 = BytesWrapperT::new(&mut store, &arr0);
    assert!(bw0.isZeros());

    arr0[0] = 1;
    let bw1 = BytesWrapperT::new(&mut store, &arr0);
    assert!(!bw1.isZeros());
    assert!(bw0.isZeros());
}

问题是这段代码无法编译，因为两者都借用了，即：&mut storebw0bw1

74 |     let bw0 = BytesWrapperT::new(&mut store, &arr0);
   |                                  ---------- first mutable borrow occurs here
...
78 |     let bw1 = BytesWrapperT::new(&mut store, &arr0);
   |                                  ^^^^^^^^^^ second mutable borrow occurs here
79 |     assert!(!bw1.isZeros());
80 |     assert!(bw0.isZeros());
   |             --- first borrow later used here

操场

我认为问题在于，在返回的生命周期中，与传入存储的生命周期相同，但我无法弄清楚如何获取它，以便我只能返回新的生命周期，而不要求它像 （只有 req 持续时间不超过 ）。BytesWrapperT::newBytesWrapperT<'a>store_: &'a mut ObjStorageTByteWrapperTObjStorageTObjStorageT

我尝试将实现更改为：

impl<'a, 'b> BytesWrapperT<'b> {
    /// New new constant w/ global obj storage
    pub fn new(store_: &'a mut ObjStorageT, bytes: &[u8]) -> BytesWrapperT<'b> {
        let new_bytes = store_.getBytes(bytes);
        return BytesWrapperT { bytes_: new_bytes };
    }
// ...
}

Playground，但这不起作用，因为 的返回生存期不匹配。ObjStorageT::getBytes

我能够使用全局静态变量（参见 Playground）编译代码，但说实话，从生命周期的角度来看，我真的不明白这可以是什么工作，但接受参数的那个却没有。&mut store_

任何帮助

1. 弄清楚如何配置我可以重用的生存期 s.t 和&mut store
2. 为什么静态版本可以工作

将不胜感激。

谢谢！

编辑： 原谅样式警告:(