Как правильно вернуть ссылку на значение из родственной связанной функции?

Question

Представьте себе крошечную карту, в которой хранятся 3 значения, первые два - для известных ключей.Я хотел бы реализовать итератор для этой карты, но я сталкиваюсь с проблемами при жизни.Как правильно вернуть ссылку на значение из родственной связанной функции (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

Похоже, что с этого времени (Rust 1.29) единственный разумный способ - поместить K::zero() внутрь TinyMap.Спасибо @SvenMarnach за подтверждение моих подозрений.

Answer 2

Невозможно сделать это с чертой Iterator из-за времени жизни собственной ссылки (которая исключена из вашего кода, но может быть явно написана так):

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

Так как 's не появляется в возвращаемом значении функции (и не может появляться там, потому что Self::Item не может использовать параметры типа функции), вывод не может содержать ссылку на любой изпеременные-члены итератора.

Это механика ошибки, теперь вот почему part:

Рассмотрим функцию, которая включает ссылку на член self,со всеми правильно установленными временами жизни:

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

Точно так же, как вы пытаетесь вернуть &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 no-no!Но если бы я попытался реализовать итератор с типом Item, который заимствовал сам итератор, то Iterator::collect() было бы невозможно, потому что он пытается вытащить более одного элемента одновременно!

Так что нет,итератор не может вернуть элемент, который занимает его содержимое.Это явная и намеренная часть контракта на черты для итераторов.