Trait 方法可以实现返回引用或拥有的值

我正在尝试使用可以实现返回引用或拥有值的方法来定义特征。

就像是：

struct Type;
trait Trait {
    type Value;
    fn f(&self) -> Self::Value;
}
impl Trait for () {
    type Value = Type;
    fn f(&self) -> Self::Value {
        Type
    }
}
impl Trait for (Type,) {
    type Value = &Type; // error[E0106]: missing lifetime specifier
    fn f(&self) -> Self::Value {
        &self.0
    }
}

这段代码不起作用，因为&Type缺少生命周期说明符。我想要&Type拥有相同的寿命&self (i.e. fn f<'a>(&'a self) -> &'a Type），但我不知道如何用 Rust 表达这一点。

我设法找到了几种方法来使这段代码工作，但我不喜欢其中任何一个：

1. 为特征本身添加显式生命周期：

   trait Trait<'a> {
       type Value;
       fn f<'b>(&'b self) -> Self::Value where 'b: 'a;
   }
   impl<'a> Trait<'a> for () {
       type Value = Type;
       fn f<'b>(&'b self) -> Self::Value
           where 'b: 'a
       {
           Type
       }
   }
   impl<'a> Trait<'a> for (Type,) {
       type Value = &'a Type;
       fn f<'b>(&'b self) -> Self::Value
           where 'b: 'a
       {
           &self.0
       }
   }
   

   我不喜欢这个解决方案的是任何使用Trait需要一个明确的生命周期（我认为这本质上不是必需的），而且该特性似乎实现起来不必要地复杂。

2. 返回可能是也可能不是参考的东西 - 比如std::borrow::Cow https://doc.rust-lang.org/std/borrow/enum.Cow.html:

   trait Trait {
       type Value;
       fn f<'a>(&'a self) -> Cow<'a, Self::Value>;
   }
   impl Trait for () {
       type Value = Type;
       fn f<'a>(&'a self) -> Cow<'a, Self::Value> {
           Cow::Owned(Type)
       }
   }
   impl Trait for (Type,) {
       type Value = Type;
       fn f<'a>(&'a self) -> Cow<'a, Self::Value> {
           Cow::Borrowed(&self.0)
       }
   }
   

   我不喜欢这个解决方案的是().f() is a Cow<_>: 我需要打电话().f().into_owned()获得我的Type。这似乎是不必要的（并且在使用时可能会导致一些可以忽略不计的运行时开销Trait作为特征对象）。

   _{Also note that Cow is not good since it requires that Self::Value implements ToOwned https://doc.rust-lang.org/std/borrow/trait.ToOwned.html (thus, practically, Clone https://doc.rust-lang.org/std/clone/trait.Clone.html), which is too strong of a requirement. It's anyways easy to implement an alternative to Cow without such constraints.}

这个问题还有其他解决方案吗？标准/最常见/首选是什么？

这可以通过使用额外的关联对象来选择是返回类型还是引用以及一些元编程魔法来解决。

首先，一些助手类型：

struct Value;
struct Reference;

trait ReturnKind<'a, T: ?Sized + 'a> {
    type Type: ?Sized;
}
impl<'a, T: ?Sized + 'a> ReturnKind<'a, T> for Value {
    type Type = T;
}
impl<'a, T: ?Sized + 'a> ReturnKind<'a, T> for Reference {
    type Type = &'a T;
}

ReturnKind是一个“类型级函数”，它返回T当“输入”是Value, and &T for Reference.

然后是特质：

trait Trait {
    type Value;
    type Return: for<'a> ReturnKind<'a, Self::Value>;

    fn f<'a>(&'a self) -> <Self::Return as ReturnKind<'a, Self::Value>>::Type;
}

我们通过“调用”类型级函数来生成返回类型ReturnKind.

“输入参数”Return需要实现该特征以允许我们编写<Return as ReturnKind<'a, Value>>。虽然我们不知道一生中的自我到底是什么，但我们可以让Return以......为界all可能的终生使用HRTB https://doc.rust-lang.org/nomicon/hrtb.html Return: for<'a> ReturnKind<'a, Value>.

Usage:

impl Trait for () {
    type Value = f64;
    type Return = Value;

    fn f(&self) -> f64 {
        42.0
    }
}

impl Trait for (f64,) {
    type Value = f64;
    type Return = Reference;

    fn f(&self) -> &f64 {
        &self.0
    }
}

fn main() {
    let a: (f64,) = ( ().f(), );
    let b: &f64 = a.f();
    println!("{:?} {:?}", a, b);
    // (42,) 42
}

请注意，上述仅在以下情况下有效Value类型有'static寿命。如果Value其本身的寿命是有限的，这个寿命必须被Trait。自从生锈尚不支持关联的生命周期 https://github.com/rust-lang/rfcs/blob/master/text/0195-associated-items.md#staging，它必须像这样使用Trait<'foo>， 很遗憾：

struct Value;
struct Reference;
struct ExternalReference;

trait ReturnKind<'a, 's, T: ?Sized + 'a + 's> {
    type Type: ?Sized;
}
impl<'a, 's, T: ?Sized + 'a + 's> ReturnKind<'a, 's, T> for Value {
    type Type = T;
}
impl<'a, 's, T: ?Sized + 'a + 's> ReturnKind<'a, 's, T> for Reference {
    type Type = &'a T;
}
impl<'a, 's, T: ?Sized + 'a + 's> ReturnKind<'a, 's, T> for ExternalReference {
    type Type = &'s T;
}

trait Trait<'s> {
    type Value: 's;
    type Return: for<'a> ReturnKind<'a, 's, Self::Value>;

    fn f<'a>(&'a self) -> <Self::Return as ReturnKind<'a, 's, Self::Value>>::Type;
}

impl Trait<'static> for () {
    type Value = f64;
    type Return = Value;

    fn f(&self) -> f64 {
        42.0
    }
}

impl Trait<'static> for (f64,) {
    type Value = f64;
    type Return = Reference;

    fn f(&self) -> &f64 {
        &self.0
    }
}

impl<'a> Trait<'a> for (&'a f64,) {
    type Value = f64;
    type Return = ExternalReference;

    fn f(&self) -> &'a f64 {
        self.0
    }

}

fn main() {
    let a: (f64,) = ( ().f(), );
    let b: &f64 = a.f();
    let c: &f64 = (b,).f();
    println!("{:?} {:?} {:?}", a, b, c);
    // (42,) 42 42
}

但如果特征上有生命周期参数就可以了，那么OP已经提供了一个更简单的解决方案：

trait Trait<'a> {
    type Value;
    fn f<'b>(&'b self) -> Self::Value where 'b: 'a;
}

impl<'a> Trait<'a> for () {
    type Value = f64;
    fn f<'b: 'a>(&'b self) -> Self::Value {
        42.0
    }
}

impl<'a> Trait<'a> for (f64,) {
    type Value = &'a f64;
    fn f<'b: 'a>(&'b self) -> Self::Value {
        &self.0
    }
}
impl<'a, 's> Trait<'s> for (&'a f64,) {
    type Value = &'a f64;
    fn f<'b: 's>(&'b self) -> Self::Value {
        self.0
    }
}

fn main() {
    let a: (f64,) = ( ().f(), );
    let b: &f64 = a.f();
    let c: &f64 = (b,).f();
    println!("{:?} {:?} {:?}", a, b, c);
    // (42,) 42 42
}