如何指定“`IntoIterator`”中“the”的类型？

Question

我有以下代码：

struct Container<T>(T);

struct MyStruct<T> {
    entries: Vec<T>,
}

impl<'a, T> IntoIterator for &'a MyStruct<Container<T>> {
    type Item = &'a Container<T>;
    type IntoIter = std::slice::Iter<'a, Container<T>>;

    fn into_iter(self) -> Self::IntoIter {
        let entries = &self.entries;
        entries.into_iter()
    }
}

fn main() {
    let my_struct: MyStruct<Container<usize>> = MyStruct {
        entries: vec![
            Container(0),
            Container(1),
            Container(2),
            Container(3),
            Container(4),
        ],
    };
    
    for c in my_struct.into_iter() {
        println!("{}", c.0);
        // I want c to be usize not Container<usize>.
        println!("{}", c); 
    }
}

我希望从into_iter()获得的迭代器生成Container的内部值。

我试过这样做：

impl<'a, T> IntoIterator for &'a MyStruct<Container<T>> {
    type Item = &'a T;
    type IntoIter = std::slice::Iter<'a, T>;

    fn into_iter(self) -> Self::IntoIter {
        let entries = &self.entries;
        
        // Map to the inner value.
        entries.into_iter().map(|c| c.0)
    }
}

但是，它没有使用下面的错误进行编译：

error[E0308]: mismatched types
  --> src/main.rs:25:9
   |
21 |     fn into_iter(self) -> Self::IntoIter {
   |                           -------------- expected `std::slice::Iter<'_, T>` because of return type
...
25 |         entries.into_iter().map(|c| c.0)
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected struct `std::slice::Iter`, found struct `Map`
   |
   = note: expected struct `std::slice::Iter<'_, T>`
              found struct `Map<std::slice::Iter<'_, Container<T>>, [closure@src/main.rs:25:33: 25:40]>`

如果我遵循这些建议，我就会发现越来越复杂的错误。

生锈操场代码

Answer 1

这样做是可行的：

struct Container<T>(T);

struct MyStruct<T> {
    entries: Vec<T>,
}

impl<T> IntoIterator for MyStruct<Container<T>> {
    type Item = T;
    type IntoIter = std::iter::Map<std::vec::IntoIter<Container<T>>, fn(Container<T>) -> T>;

    fn into_iter(self) -> Self::IntoIter {
        self.entries.into_iter().map(|c| c.0)
    }
}

fn main() {
    let my_struct: MyStruct<Container<usize>> = MyStruct {
        entries: vec![Container(0), Container(1), Container(2), Container(3)],
    };

    for c in my_struct.into_iter() {
        println!("{}", c);
    }
}

Answer 2

您可以实现Deref，然后只需要添加一些星星(*)就足够了：

use std::ops::Deref;

struct Container<T>(T);

impl<T> Deref for Container<T> {
    type Target = T;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

struct MyStruct<T> {
    entries: Vec<T>,
}

impl<T> Deref for MyStruct<T> {
    type Target = Vec<T>;
    fn deref(&self) -> &Self::Target {
        &self.entries
    }
}

fn main() {
    let my_struct: MyStruct<Container<usize>> = MyStruct {
        entries: vec![Container(0), Container(1), Container(2), Container(3)],
    };

    for c in my_struct.iter() {
        println!("{}", c.0);
        println!("{}", **c);
    }
}