rust - 如何在结构的所有生命周期中实现特征？

Question

我将问题简化为此最小的可重现示例(playground):

use std::marker::PhantomData;

pub trait D<'a> {
    type A: A + 'a;
    type B: B + 'a;
}

pub trait A {
    fn a(self);
}

pub trait B {
    fn b(self);
}

pub struct AA {}

impl A for AA {
    fn a() {}
}

pub struct BB<'a> {
    phantom: PhantomData<&'a u8>,
}

impl<'a> B for BB<'a> {
    fn b() {}
}

impl<'a: 'd, 'd> D<'d> for E<'a> {
    type A = AA;
    type B = BB<'a>;
}

#[derive(Clone)]
pub struct E<'a> {
    phantom: PhantomData<&'a u8>,
}

pub struct S<D_T>
where
    D_T: for<'d> D<'d>,
{
    a: D_T,
}

pub enum R<'a> {
    RR(S<E<'a>>),
}

我越来越

error: implementation of `D` is not general enough
  --> src/lib.rs:48:8
   |
3  | / pub trait D<'a> {
4  | |     type A: A + 'a;
5  | |     type B: B + 'a;
6  | | }
   | |_- trait `D` defined here
...
48 |       RR(S<E<'a>>),
   |          ^^^^^^^^ implementation of `D` is not general enough
   |
   = note: `D<'0>` would have to be implemented for the type `E<'a>`, for any lifetime `'0`...
   = note: ...but `D<'_>` is actually implemented for the type `E<'1>`, for some specific lifetime `'1`

我不知道为什么会发生这种情况，但是在这种情况下是否有一种方法可以将 BB与引用一起使用？这里的大部分内容都来自我无法控制的库，因此无法更改它们。

Answer 1

在整个生命周期内，S结构都需要为D实现D_T，其中还包括'static。现在，在枚举S中使用R类型的E，并使用通用生命周期'a。如果'a不是'static，则不可能实现包含非静态引用的struct B的D类型。这根本行不通，需要进行一些更改。
第一种选择是使枚举R在'static中使用E生存期，但这将是不切实际的。
另一个选择是从D_T: for<'d> D<'d>中删除S要求，添加一个额外的生命周期参数，并将幻像数据添加到该结构中。
如果它们都不可行，并且我什么都不丢失，那么不借助运行时检查，并且使BB类型不受生命周期限制(使用引用计数)，您将无能为力。您可能需要使用Rc<BB>作为B，或在Rc<SomeType>内使用BB。前者看起来像这样:

impl<'d> D<'d> for E {
    type A = AA;
    type B = Rc<BB>;
}

#[derive(Clone)]
pub struct E {
    ref_counted: Rc<BB>
}

pub struct BB {

}

impl B for Rc<BB> {
    fn b(mut self) {
        if let Some(bb) = Rc::get_mut(&mut self) {
            //code with BB's MUTABLE REFERENCE
        }
    }
}


pub struct S<D_T>
where
    D_T: for<'d> D<'d>,
{
    a: D_T
}


pub enum R {
    RR(S<E>),
}

B实现使用方法中基础值的可变引用，如果您想使用 ref_counted内部的值，则必须尝试以下操作:

impl B for Rc<BB> {
    fn b(mut self) {
        match Rc::try_unwrap(self) {
            Ok(bb) => {
                //code with BB's VALUE
            },
            Err(bbrc) => {
                //we can not consume the value in self, because
                //there was a reference held somewhere else in the code
                //here lies code with BB's reference counted pointer
            }
        }
    }
}