连接字符串向量的向量

我正在尝试编写一个函数，该函数接收字符串向量的向量并返回连接在一起的所有向量，即它返回字符串向量。

到目前为止我能做的最好的事情如下：

fn concat_vecs(vecs: Vec<Vec<String>>) -> Vec<String> {
    let vals : Vec<&String> = vecs.iter().flat_map(|x| x.into_iter()).collect();
    vals.into_iter().map(|v: &String| v.to_owned()).collect()
}

然而，我对这个结果并不满意，因为看起来我应该能够得到Vec<String>从一开始collect打电话，但不知何故我不知道该怎么做。

我更有兴趣弄清楚why正是返回类型collect is Vec<&String>。我试图从 API 文档和源代码中推断出这一点，但尽管我尽了最大努力，我什至无法理解函数的签名。

那么让我尝试追踪每个表达式的类型：

- vecs.iter(): Iter<T=Vec<String>, Item=Vec<String>>
- vecs.iter().flat_map(): FlatMap<I=Iter<Vec<String>>, U=???, F=FnMut(Vec<String>) -> U, Item=U>
- vecs.iter().flat_map().collect(): (B=??? : FromIterator<U>)
- vals was declared as Vec<&String>, therefore 
      vals == vecs.iter().flat_map().collect(): (B=Vec<&String> : FromIterator<U>). Therefore U=&String.

我假设上面的类型推断器能够弄清楚U=&String根据类型vals。但是，如果我在代码中为表达式提供显式类型，则编译不会出现错误：

fn concat_vecs(vecs: Vec<Vec<String>>) -> Vec<String> {
    let a: Iter<Vec<String>> = vecs.iter();
    let b: FlatMap<Iter<Vec<String>>, Iter<String>, _> = a.flat_map(|x| x.into_iter());
    let c = b.collect();
    print_type_of(&c);
    let vals : Vec<&String> = c;
    vals.into_iter().map(|v: &String| v.to_owned()).collect()
}

清楚地，U=Iter<String>...请帮我清理这个烂摊子。

EDIT:感谢 bluss 的提示，我能够实现一个collect如下：

fn concat_vecs(vecs: Vec<Vec<String>>) -> Vec<String> {
    vecs.into_iter().flat_map(|x| x.into_iter()).collect()
}

我的理解是通过使用into_iter我转让所有权vecs to IntoIter并进一步沿着调用链，这使我能够避免复制 lambda 调用内的数据，因此 - 神奇地 - 类型系统给了我Vec<String>它曾经总是给我Vec<&String>前。虽然看到高级概念如何反映在图书馆的运作中确实非常酷，但我希望我知道这是如何实现的。

EDIT 2:经过费力的猜测过程，查看 API 文档并使用这个方法 https://stackoverflow.com/a/29168659/3646645为了破译这些类型，我对它们进行了完整注释（忽略生命周期）：

fn concat_vecs(vecs: Vec<Vec<String>>) -> Vec<String> {
    let a: Iter<Vec<String>> = vecs.iter();
    let f : &Fn(&Vec<String>) -> Iter<String> = &|x: &Vec<String>| x.into_iter();
    let b: FlatMap<Iter<Vec<String>>, Iter<String>, &Fn(&Vec<String>) -> Iter<String>> = a.flat_map(f);
    let vals : Vec<&String> = b.collect();
    vals.into_iter().map(|v: &String| v.to_owned()).collect()
}

我会想：为什么在外部 vec 上使用 iter() 而在内部 vec 上使用 into_iter() ？使用into_iter()实际上至关重要，这样我们就不必先复制内部向量，然后复制里面的字符串，我们只需获得它们的所有权即可。

我们实际上可以将其写成求和：将向量两两连接起来。由于我们总是重复使用同一累积向量的分配和内容，因此该操作是线性时间的。

为了最大限度地减少增长和重新分配向量所花费的时间，请预先计算所需的空间。

fn concat_vecs(vecs: Vec<Vec<String>>) -> Vec<String> {
    let size = vecs.iter().fold(0, |a, b| a + b.len());
    vecs.into_iter().fold(Vec::with_capacity(size), |mut acc, v| {
        acc.extend(v); acc
    })
}

如果您确实想克隆所有内容，已经有一种方法可以实现，您只需使用vecs.concat() /* -> Vec<String> */

该方法与.flat_map很好，但如果你不想再次克隆字符串，你必须使用.into_iter()在所有级别：（x is Vec<String>).

vecs.into_iter().flat_map(|x| x.into_iter()).collect()

如果您想克隆每个字符串，您可以使用以下命令：（已更改.into_iter() to .iter() since x这里有一个&Vec<String>这两种方法实际上会产生相同的结果！）

vecs.iter().flat_map(|x| x.iter().map(Clone::clone)).collect()