一个函数可以同时接受 IntoIterator<T> 和 IntoIterator<&T> 吗？

Question

我想要一个带有两个参数的函数，这两个参数都可以变成Foo 的迭代器。问题是我想接受IntoIterator<Foo> 和IntoIterator<&Foo> 的东西。重要的是Foo 是Copy，所以我可以从它的引用中廉价地创建一个拥有的副本。

我目前的解决方案是：

use std::borrow::Cow;
use std::iter::IntoIterator;

fn main() {
    let foos = [Foo {}, Foo {}, Foo {}];
    let references = || foos.iter();
    let owned = || foos.iter().cloned();
    bar(references(), references());
    bar(references(), owned());
    bar(owned(), references());
    bar(owned(), owned());
}

#[derive(Copy, Clone)]
struct Foo {
    // code ommitted here
}

impl<'a> From<Foo> for Cow<'a, Foo> {
    fn from(foo: Foo) -> Self {
        Self::Owned(foo)
    }
}

impl<'a> From<&'a Foo> for Cow<'a, Foo> {
    fn from(foo: &'a Foo) -> Self {
        Self::Borrowed(foo)
    }
}

fn bar<'a, AIter, A, BIter, B>(alpha_iter: AIter, beta_iter: BIter)
  where 
    AIter: IntoIterator<Item=A>,
    A: Into<Cow<'a, Foo>>,
    BIter: IntoIterator<Item=B>,
    B: Into<Cow<'a, Foo>>
{
    for (alpha, beta) in alpha_iter.into_iter().zip(beta_iter.into_iter()) {
       some_foo_specific_thing(*alpha.into(), *beta.into());
    }
}

fn some_foo_specific_thing(alpha: Foo, beta: Foo) {
    // code ommitted here
}

^playground

有没有办法在更少的行/没有Cow 的情况下做到这一点？

Answer 1

首先，您不需要在这里完全绑定IntoIterator。 Iterator<Item = Foo> 就够了。

use std::borrow::Cow;
use std::iter::IntoIterator;

fn main() {
    let foos = [Foo {}, Foo {}, Foo {}];
    let references = || foos.iter(); // it is iterator itself
    let owned = || foos.iter().cloned(); // it is iterator itself
    bar(references(), references());
    bar(references(), owned());
    bar(owned(), references());
    bar(owned(), owned());
}

fn bar<'a, AIter, A, BIter, B>(alpha_iter: AIter, beta_iter: BIter)
  where 
    AIter: Iterator<Item = A>,
    A: Into<Cow<'a, Foo>>,
    BIter: Iterator<Item = B>,
    B: Into<Cow<'a, Foo>>
{
    for (alpha, beta) in alpha_iter.zip(beta_iter) {
       some_foo_specific_thing(*alpha.into(), *beta.into());
    }
}

其次，我认为最好使用Borrow trait：

fn bar<'a, AIter, A, BIter, B>(alpha_iter: AIter, beta_iter: BIter)
  where 
    AIter: Iterator<Item = A>,
    A: std::borrow::Borrow<Foo> + Copy,
    BIter: Iterator<Item = B>,
    B: std::borrow::Borrow<Foo> + Copy,
{
    let alpha_iter = alpha_iter.map(|item| *item.borrow()); // here we  get a reference to an item and then make a copy to own it
    let beta_iter = beta_iter.map(|item| *item.borrow()); // here we  get a reference to an item and then make a copy to own it
    
    for (alpha, beta) in alpha_iter.zip(beta_iter) {
       some_foo_specific_thing(alpha, beta);
    }
}