如何使用&HashSet<&T>作为IntoIterator<Item = &T>？

Question

我有一个函数，它接受&T的集合(由IntoIterator表示)，并要求每个元素都是唯一的。

fn foo<'a, 'b, T: std::fmt::Debug, I>(elements: &'b I)
where
    &'b I: IntoIterator<Item = &'a T>,
    T: 'a,
    'b: 'a,

我还想编写一个包装器函数，即使元素不是唯一的，它也可以工作，方法是首先使用HashSet删除重复的元素。

我尝试了以下实现：

use std::collections::HashSet;

fn wrap<'a, 'b, T: std::fmt::Debug + Eq + std::hash::Hash, J>(elements: &'b J)
where
    &'b J: IntoIterator<Item = &'a T>,
    T: 'a,
    'b: 'a,
{
    let hashset: HashSet<&T> = elements.into_iter().into_iter().collect();
    foo(&hashset);
}

游乐场

然而，编译器似乎不满意我的假设，即HashSet<&T>实现IntoIterator<Item = &'a T>

error[E0308]: mismatched types
  --> src/lib.rs:10:9
   |
10 |     foo(&hashset);
   |         ^^^^^^^^ expected type parameter, found struct `std::collections::HashSet`
   |
   = note: expected type `&J`
              found type `&std::collections::HashSet<&T>`
   = help: type parameters must be constrained to match other types
   = note: for more information, visit https://doc.rust-lang.org/book/ch10-02-traits.html#traits-as-parameters

我知道我可以通过克隆所有输入元素来使用HashSet<T>，但我希望避免不必要的复制和内存使用。

Answer 1

如果您有一个&HashSet<&T>，并且需要一个可以多次处理的&T迭代器(而不是&&T)，那么可以使用Iterator::copied将迭代器的&&T转换为&T

use std::{collections::HashSet, fmt::Debug, hash::Hash, marker::PhantomData};

struct Collection<T> {
    item: PhantomData<T>,
}

impl<T> Collection<T>
where
    T: Debug,
{
    fn foo<'a, I>(elements: I) -> Self
    where
        I: IntoIterator<Item = &'a T> + Clone,
        T: 'a,
    {
        for element in elements.clone() {
            println!("{:?}", element);
        }
        for element in elements {
            println!("{:?}", element);
        }
        Self { item: PhantomData }
    }
}

impl<T> Collection<T>
where
    T: Debug + Eq + Hash,
{
    fn wrap<'a, I>(elements: I) -> Self
    where
        I: IntoIterator<Item = &'a T>,
        T: 'a,
    {
        let set: HashSet<_> = elements.into_iter().collect();
        Self::foo(set.iter().copied())
    }
}

#[derive(Debug, Hash, PartialEq, Eq)]
struct Foo(i32);

fn main() {
    let v = vec![Foo(1), Foo(2), Foo(4)];
    Collection::<Foo>::wrap(&v);
}

另请参阅：

• 在Rust中多次使用相同的迭代器
• 克隆迭代器是否复制整个基础向量？
• 为什么克隆我的定制类型会导致&T而不是T？

注意，这个答案的其余部分假设一个名为Collection<T>的结构是T类型值的集合。“任择议定书”澄清说，这不是事实。

正如后面的例子所示，这不是您的问题。可以归结为：

struct Collection<T>(T);

impl<T> Collection<T> {
    fn new(value: &T) -> Self {
        Collection(value)
    }
}

您正在对类型(&T)进行引用，并试图将其存储到需要T的地方；这些类型不同，并将生成错误。您使用PhantomData是出于某种原因，并通过迭代器接受引用，但问题是相同的。

事实上，PhantomData使问题变得更难理解，因为您只需要编造一些不起作用的值。例如，这里从来没有任何类型的字符串，但是我们“成功地”创建了结构：

use std::marker::PhantomData;

struct Collection<T>(PhantomData<T>);

impl Collection<String> {
    fn new<T>(value: &T) -> Self {
        Collection(PhantomData)
    }
}

最终，您的wrap函数也没有意义：

impl<T: Eq + Hash> Collection<T> {
    fn wrap<I>(elements: I) -> Self
    where
        I: IntoIterator<Item = T>,

这相当于

impl<T: Eq + Hash> Collection<T> {
    fn wrap<I>(elements: I) -> Collection<T>
    where
        I: IntoIterator<Item = T>,

这意味着，给定元素T的迭代器，您将返回这些元素的集合。但是，您可以将它们放入HashMap中，并在引用上迭代，从而生成&T。因此，此函数签名不能正确。

您很可能希望接受一个拥有价值的迭代器，而不是：

use std::{collections::HashSet, fmt::Debug, hash::Hash};

struct Collection<T> {
    item: T,
}

impl<T> Collection<T> {
    fn foo<I>(elements: I) -> Self
    where
        I: IntoIterator<Item = T>,
        for<'a> &'a I: IntoIterator<Item = &'a T>,
        T: Debug,
    {
        for element in &elements {
            println!("{:?}", element);
        }
        for element in &elements {
            println!("{:?}", element);
        }

        Self {
            item: elements.into_iter().next().unwrap(),
        }
    }
}

impl<T> Collection<T>
where
    T: Eq + Hash,
{
    fn wrap<I>(elements: I) -> Self
    where
        I: IntoIterator<Item = T>,
        T: Debug,
    {
        let s: HashSet<_> = elements.into_iter().collect();
        Self::foo(s)
    }
}

#[derive(Debug, Hash, PartialEq, Eq)]
struct Foo(i32);

fn main() {
    let v = vec![Foo(1), Foo(2), Foo(4)];
    let c = Collection::wrap(v);
    println!("{:?}", c.item)
}

这里，我们直接在泛型迭代器类型上放置一个特征绑定，在对迭代器的引用上放置第二个较高级别的特征绑定。这允许我们将对迭代器的引用用作迭代器本身。

另请参阅：

• 一个人是如何在锈病中一般地复制一个值的？
• 是否有任何方法返回对函数中创建的变量的引用？
• 如果引用中的一个是本地引用，如何在类型约束中编写引用的生存期？

Answer 2

Shepmaster指出，在我的代码中存在许多正交问题，但是要解决使用HashSet<&T>作为IntoIterator<Item=&T>的问题，我发现解决这个问题的一种方法是使用包装器结构：

struct Helper<T, D: Deref<Target = T>>(HashSet<D>);

struct HelperIter<'a, T, D: Deref<Target = T>>(std::collections::hash_set::Iter<'a, D>);

impl<'a, T, D: Deref<Target = T>> Iterator for HelperIter<'a, T, D>
where
    T: 'a,
{
    type Item = &'a T;
    fn next(&mut self) -> Option<Self::Item> {
        self.0.next().map(|x| x.deref())
    }
}

impl<'a, T, D: Deref<Target = T>> IntoIterator for &'a Helper<T, D> {
    type Item = &'a T;
    type IntoIter = HelperIter<'a, T, D>;
    fn into_iter(self) -> Self::IntoIter {
        HelperIter((&self.0).into_iter())
    }
}

其用途如下：

struct Collection<T> {
    item: PhantomData<T>,
}

impl<T: Debug> Collection<T> {
    fn foo<I>(elements: I) -> Self
    where
        I: IntoIterator + Copy,
        I::Item: Deref<Target = T>,
    {
        for element in elements {
            println!("{:?}", *element);
        }
        for element in elements {
            println!("{:?}", *element);
        }
        return Self { item: PhantomData };
    }
}

impl<T: Debug + Eq + Hash> Collection<T> {
    fn wrap<I>(elements: I) -> Self
    where
        I: IntoIterator + Copy,
        I::Item: Deref<Target = T> + Eq + Hash,
    {
        let helper = Helper(elements.into_iter().collect());
        Self::foo(&helper);
        return Self { item: PhantomData };
    }
}

fn main() {
    let v = vec![Foo(1), Foo(2), Foo(4)];
    Collection::<Foo>::wrap(&v);
}

我猜其中的一些可能比需要的要复杂，但我不知道怎么做。

满操场