Vec::extend generates suboptimal code with .map

[arielb1]

Meta

$ rustc -V
rustc 1.14.0-nightly (a3bc191b5 2016-10-10)

STR

#![crate_type="rlib"]
#![feature(test)]

extern crate test;

pub fn example_slow(l: &[(u32, u32)]) -> Vec<u32> {
    let mut result = Vec::with_capacity(l.len());
    result.extend(l.iter().map(|x| x.0));
    result
}

pub fn example_fast(l: &[(u32, u32)]) -> Vec<u32> {
    let mut result = Vec::with_capacity(l.len());
    for i in 0..l.len() {
        unsafe {
            *result.get_unchecked_mut(i) = l[i].0;
            result.set_len(i);
        }
    }
    result
}

#[bench]
fn bench_slow(b: &mut test::Bencher) {
    let data = [(0, 0); 16384];
    b.iter(|| {
        test::black_box(example_slow(test::black_box(&data)));
    });
}

#[bench]
fn bench_fast(b: &mut test::Bencher) {
    let data = [(0, 0); 16384];
    b.iter(|| {
        test::black_box(example_fast(test::black_box(&data)));
    });
}

Expected result

Both cases take the same amount of time

Actual result

$ ./slo-and-fast --bench

running 2 tests
test bench_fast ... bench:       7,490 ns/iter (+/- 271)
test bench_slow ... bench:      11,247 ns/iter (+/- 1,735)

test result: ok. 0 passed; 0 failed; 0 ignored; 2 measured

[arielb1]

cc @bluss

[bluss]

It's not better with a regular (non-mapped) iterator. Only exception is the slice iterator, which is special cased. Reverse slice iterator is just as slow.