rust - 摆弄生命周期 : sanity check on unsafe reinterpretation of lifetimes

Question

假设您有两个 T 实例集合(此处为简单起见，Vec)，以及一个函数来计算这些集合中的元素是否出现在其中一个或两个中他们:

// With lifetimes not yet annotated
fn comm(left: &Vec<T>, right: &Vec<T>) -> Vec<(Tag, &T)> {}

enum Tag {
    Left,
    Both,
    Right,
}

comm(l,r) 保证在 两种情况下，返回的引用都指向 left 集合的元素T 仅出现在 left 中，and T 出现在两者中。

但是，因为某些 T 可能只出现在 right 中，所以函数的完整签名必须如下所示:

fn comm<'a, 'b, 'c>(left: &'a Vec<T>, right: &'b Vec<T>) -> Vec(Tag, &'c T)
where
  'a: 'c,
  'b: 'c,

---

那么实际的问题是:我知道，在 (tag, &T) 元组之一中返回 comm，如果 tag == Left or tag == Both，那么&T将肯定指向left集合。

使用 mem::transmute 或其他机制获取 comm 返回的引用之一并将其转换为生命周期匹配是否明智、安全和合法left 集合？

例如:

fn last_common<'a, 'b>(left: &'a Vec<T>, right: &'b Vec<T>) -> &'a T {
  let tagged = comm(left, right);
  let (tag, ref_to_T) = boring code that picks one tuple from tagged...
  assert!(matches!(tag, Tag::Left) || matches!(tag, Tag::Both))
  return std::mem::transmute::<&'_ T, &'a T>(ref_to_T);
}

Answer 1

是的，它很好听。事实上，transmute() 的官方文档说它可以用来延长生命周期:

https://doc.rust-lang.org/stable/std/mem/fn.transmute.html#examples

Extending a lifetime, or shortening an invariant lifetime. This is advanced, very unsafe Rust!

struct R<'a>(&'a i32);
unsafe fn extend_lifetime<'b>(r: R<'b>) -> R<'static> {
    std::mem::transmute::<R<'b>, R<'static>>(r)
}

unsafe fn shorten_invariant_lifetime<'b, 'c>(r: &'b mut R<'static>)
                                             -> &'b mut R<'c> {
    std::mem::transmute::<&'b mut R<'static>, &'b mut R<'c>>(r)
}

但我不会推荐它。相反，我建议您使用枚举:

fn comm<'a, 'b, T>(left: &'a Vec<T>, right: &'b Vec<T>) -> Vec<Tag<'a, 'b, T>> {}

enum Tag<'a, 'b, T> {
    Left(&'a T),
    Both(&'a T), // Could be `&'b T`, too.
    Right(&'b T),
}

您还可以使用一种方法来提取生命周期较短的值，例如:

impl<'a, T> Tag<'a, 'a, T> {
    pub fn value(self) -> &'a T {
        let (Self::Left(v) | Self::Right(v) | Self::Both(v)) = self;
        v
    }
}