Collections 是否可以收集迭代器以向后填充集合？

是否可以收集迭代器，使其向后填充集合，例如在

向量中使用
向前推

可以收集到一个
Vec
中，然后将其反转，但由于数据结构明确支持此功能，似乎不需要这样做。如果可能的话，我希望避免为

循环编写显式的

是否可以收集迭代器以使其向后填充集合，例如在
VecDeque
中使用
push_front

是的。您可以使用
for_each
对迭代器进行迭代，并按如下方式填充
向量：

让mut my_deque:VecDeque=VecDeque:：new（）；
（1..4）.对于每个（| x | my|u deque.向前推（x））；


您可以使用该方法反转迭代器。之后，您可以调用
for_each
以相反的顺序对其进行迭代，也可以直接将其收集到
Vec
，因为它已被反转

fn main（）{
让我的迭代器=vec！[1,2,3]进入iter（）；
让reversed_iterator=my_iterator.rev（）；
反转的迭代器。对于每个（{}，x}）的迭代器（{}，x））；
}

或者更习惯地说，您可以在
for
循环中直接反转它：

（1..4.rev（）中的i的
{
打印！（“{}”，i）；
}

您的输出将是：

321

是的，有可能：

use std::collections::VecDeque;

fn main() {
    let v: VecDeque<_> = (0..=2).collect_rev();
    assert_eq!(v, [2, 1, 0]);

    let v: Vec<_> = (0..=2).collect_rev();
    assert_eq!(v, [2, 1, 0]);
}

使用std:：collections:：VecDeque；
fn main（）{
设v:VecDeque=（0..=2）.collect_rev（）；
断言（v[2,1,0]）；
设v:Vec=（0..=2）；
断言（v[2,1,0]）；
}

您只需要一点胶水代码：

trait CollectRev: Iterator {
    fn collect_rev<B>(self) -> B
    where
        B: FromIteratorRev<Self::Item>,
        Self: Sized,
    {
        B::from_iter_rev(self)
    }
}

impl<I: Iterator> CollectRev for I {}

trait FromIteratorRev<T> {
    fn from_iter_rev(iter: impl IntoIterator<Item = T>) -> Self;
}

trait-collectorrev:Iterator{
fn收集版本（自）->B
哪里
B:Fromorrev，
自我：大小，
{
B：：来自iter修订版（自我）
}
}
I{}的impl CollectRev
奥列夫的特点{
fn来自iter修订版（iter:impl INTO迭代器）->Self；
}

并针对各种类型有效地实施：

impl<T> FromIteratorRev<T> for VecDeque<T> {
    fn from_iter_rev(iter: impl IntoIterator<Item = T>) -> Self {
        let mut v = Self::new();
        for i in iter {
            v.push_front(i);
        }
        v
    }
}

impl<T> FromIteratorRev<T> for Vec<T> {
    fn from_iter_rev(iter: impl IntoIterator<Item = T>) -> Self {
        let mut v: Self = iter.into_iter().collect();
        v.reverse();
        v
    }
}

impl fromteratorrev for VecDeque{
fn来自iter修订版（iter:impl INTO迭代器）->Self{
让mut v=Self:：new（）；
国际热核聚变实验堆{
v、 向前推（i）；
}
v
}
}
针对Vec的impl FROMITERATOR REV{
fn来自iter修订版（iter:impl INTO迭代器）->Self{
让mut v:Self=iter.into_iter（）.collect（）；
v、 反向（）；
v
}
}

我希望避免为
循环编写显式的

必须有人编写代码。
可以调用
for_each
进行迭代，或者更惯用地说，在
for
循环中使用它。从OP中直接解决这一点可能是值得的：向后填充集合，例如在
向量中使用
push_front
。对，用于循环。正如我所说，我希望避免这种情况。@Listerone
push\u front
是一种副作用，您希望应用于迭代器的每个元素。无论是
for_each（）
还是
for
，都必须有一个调用它的循环。对于学习Rust或F#等混合范式语言的人来说，循环本质上是一件坏事，这是一个常见的误解。如果有像
map
这样的函数可以更好地表达程序的语义，那么您应该使用它；但是，如果您真正要做的是“对集合中的每个元素执行一个副作用”，那么循环就没有什么问题。使用