使用带矢量的 map

虽然向量最适合程序编程，但是我想在它们上面使用一个 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)。还有别的办法吗？

82141 次浏览
小开
最佳答案

Rust likes to be more general than that; mapping is done over iterators, rather than over solely vectors or slices.

A couple of demonstrations:

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() is probably the most magic part of it, and allows you to collect all the elements of the iterator into a large variety of different types, as shown by the implementors of FromIterator. For example, an iterator of Ts can be collected to Vec<T>, of chars can be collected to a String, of (K, V) pairs to a HashMap<K, V>, and so forth.

This way of working with iterators also means that you often won’t even need to create intermediate vectors where in other languages or with other techniques you would; this is more efficient and typically just as natural.

小开

As pointed out by bluss, you can also use the mutable iterator to mutate the value in place, without changing the type:

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

The function Vec::map_in_place was deprecated in Rust 1.3 and is no longer present in Rust 1.4.

Chris Morgan's answer is the best solution 99% of the time. However, there is a specialized function called Vec::map_in_place. This has the benefit of not requiring any additional memory allocations, but it requires that the input and output type are the same size (thanks Levans) and is currently unstable:

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

An example:

#![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);
}

提交答案