return 从通用关联函数引用值的合适方法是什么？

Question

想象一个存储 3 个值的小映射，前两个用于已知键。我想为此地图实现一个迭代器，但我运行遇到了生命周期问题。 return 对通用关联函数值的引用的适当方法是什么（下例中的 K::zero()）？仅供参考，我拥有该特征，所以我尝试将其更改为新的 RFC195 关联 const，但没有帮助。

我已将我的问题归结为以下代码：

extern crate num;

use num::*;

pub struct TinyMap<K: Num, V> {
    v0: Option<V>, // value for K::zero()
    v1: Option<V>, // value for K::one()
    k2: K,         // arbitrary K
    v2: Option<V>, // value for k2
}

pub struct Iter<'a, K: 'a + Num, V: 'a> {
    k0: K,
    v0: &'a Option<V>,
    v1: &'a Option<V>,
    k2: &'a K,
    v2: &'a Option<V>,
}

impl<K: Num, V> TinyMap<K, V> {
    pub fn iter(&self) -> Iter<K, V> {
        Iter {
            k0: K::zero(),
            v0: &self.v0,
            v1: &self.v1,
            k2: &self.k2,
            v2: &self.v2,
        }
    }
}

impl<'a, K: 'a + Num, V: 'a> Iterator for Iter<'a, K, V> {
    type Item = (&'a K, &'a V);

    fn next(&mut self) -> Option<(&'a K, &'a V)> {
        if (*self.v0).is_some() {
            // code removed that remembers we did this once.
            return Some((&self.k0, ((*self.v0).as_ref()).unwrap()));
        }
        // if (*self.v1).is_some() {
        //     code removed that remembers we did this once.
        //     return Some((&K::one(), &((*self.v1).unwrap())));
        // }
        None
    }
}

error[E0495]: cannot infer an appropriate lifetime for borrow expression due to conflicting requirements
  --> src/lib.rs:38:26
   |
38 |             return Some((&self.k0, ((*self.v0).as_ref()).unwrap()));
   |                          ^^^^^^^^
   |
note: first, the lifetime cannot outlive the anonymous lifetime #1 defined on the method body at 35:5...
  --> src/lib.rs:35:5
   |
35 | /     fn next(&mut self) -> Option<(&'a K, &'a V)> {
36 | |         if (*self.v0).is_some() {
37 | |             // code removed that remembers we did this once.
38 | |             return Some((&self.k0, ((*self.v0).as_ref()).unwrap()));
...  |
44 | |         None
45 | |     }
   | |_____^
note: ...so that reference does not outlive borrowed content
  --> src/lib.rs:38:26
   |
38 |             return Some((&self.k0, ((*self.v0).as_ref()).unwrap()));
   |                          ^^^^^^^^
note: but, the lifetime must be valid for the lifetime 'a as defined on the impl at 32:6...
  --> src/lib.rs:32:6
   |
32 | impl<'a, K: 'a + Num, V: 'a> Iterator for Iter<'a, K, V> {
   |      ^^
   = note: ...so that the expression is assignable:
           expected std::option::Option<(&'a K, &'a V)>
              found std::option::Option<(&K, &V)>

Answer 1

使用 Iterator 特性不可能做到这一点，因为自引用的生命周期（在您的代码中被删除，但可以明确地写成这样）：

type Item = (&'a K, &'a V);
fn next<'s>(&'s mut self) -> Self::Item;

因为 's 没有出现在函数的 return 值中（也不能出现在那里，因为 Self::Item 不能使用函数的类型参数），不允许输出包含对任何迭代器成员变量的引用。

这就是错误的机制，现在是为什么部分：

考虑一个确实包含对 self 成员的引用的函数，并且所有生命周期都设置正确：

struct SomeMember;
struct SomeObject {
    some_member: SomeMember,
}
impl SomeObject {
    fn some_function<'s>(&'s mut self) -> &'s SomeMember {
        &self.some_member
    }
}

与您尝试 return &self.k 的方式相同，但没有任何其他事情发生，并且生命周期固定，因此它是允许的。但是，如果我尝试这样做：

fn main() {
    let mut some_object = SomeObject{some_member: SomeMember};
    let _item_1 = some_object.some_function();
    let _item_2 = some_object.some_function();
}

error[E0499]: cannot borrow `some_object` as mutable more than once at a time
  --> src/main.rs:15:23
   |
14 |         let _item_1 = some_object.some_function();
   |                       ----------- first mutable borrow occurs here
15 |         let _item_2 = some_object.some_function();
   |                       ^^^^^^^^^^^ second mutable borrow occurs here
16 |     }
   |     - first borrow ends here

不允许第二次调用，因为它借用了 some_object 两次，可变地，经典的 Rust 禁忌！但是，如果我试图用借用迭代器本身的 Item 类型实现一个迭代器，那么 Iterator::collect() 将是不可能的，因为它试图一次拉出多个项目！

所以，不，迭代器不能 return 借用其内容的项目。这是迭代器特征契约的一个明确的、有意的部分。

Answer 2

目前的共识似乎是（Rust 1.29），唯一明智的方法是将 K::zero() 放在 TinyMap 中。感谢@SvenMarnach 证实了我的怀疑。

return 从通用关联函数引用值的合适方法是什么？

What's the appropriate way to return a reference to the value from a generic associated function?

iterator

lifetime

rust