comparing different methods of iterating slices of vectors with enumerate

gistfile1.txt

#![feature(test)]

extern crate test;

pub fn foo_a(out: &mut Vec<usize>, inx: &[usize], base: usize) {
    for i in 1..base {
        out[i] = *inx.get(i).unwrap_or(&0);
    }
}

pub fn foo_b(out: &mut Vec<usize>, inx: &[usize], base: usize) {
    for (i, item) in out.iter_mut().enumerate().take(base).skip(1) {
        *item = *inx.get(i).unwrap_or(&0);
    }
}

pub fn foo_c(out: &mut Vec<usize>, inx: &[usize], base: usize) {
    for (i, item) in out[..base].iter_mut().enumerate().skip(1) {
        *item = *inx.get(i).unwrap_or(&0);
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use test::{Bencher, black_box};

    use crate::foo_c;

    #[bench]
    fn bench_a(b: &mut Bencher) {
        let c = 10000;
        let mut a = vec![1; c];
        let inx = vec![2; c];

        b.iter(|| {
            foo_a(&mut a, &inx, c);
            black_box(&a);
        });

        print!("{:?}", a.iter().sum::<usize>());
    }

    #[bench]
    fn bench_b(b: &mut Bencher) {
        let c = 10000;
        let mut a = vec![1; c];
        let inx = vec![2; c];

        b.iter(|| {
            foo_b(&mut a, &inx, c);
            black_box(&a);
        });

        print!("{:?}", a.iter().sum::<usize>());
    }

    #[bench]
    fn bench_c(b: &mut Bencher) {
        let c = 10000;
        let mut a = vec![1; c];
        let inx = vec![2; c];

        b.iter(|| {
            foo_c(&mut a, &inx, c);
            black_box(&a);
        });

        print!("{:?}", a.iter().sum::<usize>());
    }
}

fn main() {
    println!("Hello, world!");
}