对使用具有生命周期的 trait 作为通用参数约束感到困惑

Question

我正在尝试制作某种解码器，它能够在不实际复制内存的情况下反序列化条目，只需将值映射到某些内存区域即可。这就是我目前设法做的事情（简化为测试用例）：

#![allow(unstable)]
trait CastAbility: Sized { }
impl CastAbility for u64 { }
impl CastAbility for u32 { }
impl CastAbility for u16 { }
impl CastAbility for u8 { }
trait Cast {
    fn cast<'a>(mem: &'a [u8]) -> Result<&'a Self, String>;
}
impl<T> Cast for T where T: CastAbility {
    fn cast<'a>(mem: &'a [u8]) -> Result<&'a T, String> {
        if mem.len() != std::mem::size_of::<T>() { 
            Err("invalid size".to_string())
        } else {
            Ok(unsafe { std::mem::transmute(mem.as_ptr()) })
        }
    }
}
impl Cast for str {
    fn cast<'a>(mem: &'a [u8]) -> Result<&'a str, String> {
        Ok(unsafe { std::mem::transmute(std::raw::Slice { data: mem.as_ptr(), len: mem.len() }) })
    }
}
trait Read<'a> {
    fn read(mem: &'a [u8]) -> Result<Self, String>;
}
#[derive(Show, PartialEq)]
struct U8AndStr<'a> {
    value_u8: &'a u8,
    value_str: &'a str,
}
impl<'a> Read<'a> for U8AndStr<'a> {
    fn read(mem: &'a [u8]) -> Result<U8AndStr, String> {
        Ok(U8AndStr {
            value_u8: try!(Cast::cast(mem.slice(0, 1))),
            value_str: try!(Cast::cast(mem.slice(1, mem.len()))),
        })
    }
}
fn main() {
    let mem: &[u8] = &[0x01, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37];
    let value: U8AndStr = Read::read(mem).unwrap();
    println!("value: {:?}", value);
}

婴儿用围栏

事实上，它可以编译甚至工作，但现在我不明白如何将我的 Read 特征用作通用参数。例如，假设我想将一个值与某个内存区域的解码结果进行比较：

fn compare_to_smth<'a, T>(value: &'a T) -> bool where T: PartialEq+Read<'a> {
    let mem: &[u8] = &[0x01, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37];
    let smth_value: T = Read::read(mem).unwrap();
    smth_value == *value
}
fn main() {
    let value = U8AndStr { value_u8: &1, value_str: "01234567" };
    assert!(compare_to_smth(&value));
}

它以"借用的值寿命不够长"失败，我可以猜到原因：因为 mem 生命周期是函数体，而不是 'a，因为我在输入参数的签名中指定了。所以我尝试使用第二生命参数，如下所示：

fn compare_to_smth<'a, 'b, T>(value: &'a T) -> bool where T: PartialEq+Read<'b> {

但由于显而易见的原因，它也没有奏效。所以我真的不明白如何在不从外部传递内存块的情况下使compare_to_smth工作。是否有任何解决方案，或者我应该以某种方式重构代码？

Answer 1

不幸的是，目前你想做的事情在 Rust 中是无法表达的。

实际起作用Read特征的签名如下（在伪 Rust 中）：

trait<'r> Read for Self<'r> {
    fn read<'a>(mem: &'a [u8]) -> Result<Self<'a>, String>;  // '
}

也就是说，Self在其生存期参数中必须是更高种类的类型。这需要支持更高级的类型，这是 Rust 社区中非常需要的功能，但尚未实现。

原始签名的问题：

trait Read<'a> {
    fn read(mem: &'a [u8]) -> Result<Self, String>;
}

是'a是特征的参数。当此特征用作特征绑定时：

fn compare_to_smth<'a, T>(value: &T) -> bool where T: PartialEq+Read<'a>

这意味着此函数的调用方选择实际生存期参数。例如，调用方可以选择'static：

fn compare_to_smth<T>(value: &T) -> bool where T: PartialEq+Read<'static>

但是，该函数使用生存期不'static &[u8]。

事实上，由于方差的原因，这个具体的例子可能并不完全正确（我想在这里'static这个生命是合理的，但生命本身的方差有点令人困惑，所以我不太确定），但总体思路是相同的：为了使它起作用，Read::read方法在其参数和结果的生命周期中必须是多态的， 但是你还不能写这样的签名。

Answer 2

我认为问题可能更多地在于compare_to_smth的签名。

fn compare_to_smth<'a, T>(value: &'a T) // this implies a T: 'a bound
                       // because otherwise we would not be able to
                       // have a &'a T (references can't live longer
                       // than the thing they reference)

但是在你正在做的函数中：

let smth_value: T = Read::read(mem).unwrap(); 
                                 // give me something of type T that
                                 // lives less than T

我可能是错的，但我不认为这取决于Read的定义以及类型系统在未来会变得多么复杂，因为你在右侧写的任何内容都不会改变你期望在左侧有一个 T 的事实（并且 T 必须比 'a 活得更久）。

一个"足够聪明的编译器"可能能够看到smth_value实际上并没有比'a长寿，并且你正在做的事情是安全的，但总的来说，这是不安全的。我敢肯定，在compare_to_smth中使用不安全的嬗变完全违背了你的目的，但只是为了证明，这是有效的：

fn compare_to_smth<'a, T>(value: &'a T) -> bool
    where T: Read<'a> + PartialEq
{
    let mem: &[u8] = &[0x01, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37];
    let smth_value = <U8AndStr as Read>::read(mem).unwrap();
    let vl: &U8AndStr = unsafe{ std::mem::transmute(value) };
    smth_value == *vl
}