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);
}

playpen

实际上它编译甚至可以工作，但现在我无法理解如何使用我的 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>

但是，该功能使用&[u8]，其生命周期不是'static。

事实上，由于方差，这个具体的例子可能并不完全正确（我想这一辈子的声音是'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
}

混淆使用具有生命周期的特征作为通用参数约束

2 个答案: