使用带向量的映射

Question

虽然向量最适合程序性编程，但我想对它们使用< code>map函数。以下代码片段有效:

fn map<A, B>(u: &Vec<A>, f: &Fn(&A) -> B) -> Vec<B> {
    let mut res: Vec<B> = Vec::with_capacity(u.len());
    for x in u.iter() {
        res.push(f(x));
    }
    res
}

fn f(x: &i32) -> i32 {
    *x + 1
}

fn main() {
    let u = vec![1, 2, 3];
    let v = map(&u, &f);
    println!("{} {} {}", v[0], v[1], v[2]);
}

为什么标准库中没有这样的函数？（以及 std：：collections：：LinkedList）。有没有其他方法可以处理它？

Answer 1

正如bluss所指出的，您还可以使用可变迭代器就地改变值，而不改变类型:

let mut nums = nums;
for num in &mut nums { *num += 1 }
println!("{:p} - {:?}", &nums, nums);

函数< code>Vec::map_in_place在Rust 1.3中被弃用，在Rust 1.4中不再存在。

Chris Morgan的答案在99%的情况下是最佳解决方案。但是，有一个名为Vec::map_in_place的专门函数。这有一个好处，即不需要任何额外的内存分配，但它要求输入和输出类型大小相同（感谢Levans），并且当前不稳定：

fn map_in_place<U, F>(self, f: F) -> Vec<U> 
    where F: FnMut(T) -> U

一个例子：

#![feature(collections)]

fn main() {
    let nums = vec![1,2,3];
    println!("{:p} - {:?}", &nums, nums);

    let nums = nums.map_in_place(|v| v + 1);
    println!("{:p} - {:?}", &nums, nums);
}

Answer 2

Rust 喜欢比这更通用。映射是通过迭代器完成的，而不仅仅是在向量或切片上完成的。

几个演示：

let u = vec![1, 2, 3];
let v: Vec<_> = u.iter().map(f).collect();

let u = vec![1, 2, 3];
let v = u.iter().map(|&x| x + 1).collect::<Vec<_>>();

<代码>。collect()可能是其中最神奇的部分，它允许您将迭代器的所有元素收集到各种不同的类型中，如< code>FromIterator的实现者所示。例如，可以将< code>T的迭代器收集到< code>Vec中

这种使用迭代器的方式也意味着你通常甚至不需要创建中间向量，而在其他语言或其他技术中，你会这样做。这更有效，通常同样自然。