a-results.txt

running 3 tests
test bench_from_iter                 ... bench:       6,991 ns/iter (+/- 941)
test bench_from_iter_with_filter_map ... bench:       8,324 ns/iter (+/- 1,320)
test bench_from_iter_with_scan       ... bench:       7,299 ns/iter (+/- 1,172)

main.rs

#![feature(test)]
extern crate test;

use std::iter::FromIterator;
use test::Bencher;

fn from_iter_with_scan<C, T, E, I>(iter: I) -> Result<C, E>
    where I: Iterator<Item = Result<T, E>>,
          C: FromIterator<T>,
{
    let mut err = None;

    let v = {
        let adapter = iter.scan(&mut err, |err, item| {
            match item {
                Ok(x) => Some(x),
                Err(x) => {
                    **err = Some(x);
                    None
                },
            }
        });

        FromIterator::from_iter(adapter)
    };

    match err {
        Some(err) => Err(err),
        None => Ok(v),
    }
}

fn from_iter_with_filter_map<C, T, E, I>(iter: I) -> Result<C, E>
    where I: Iterator<Item = Result<T, E>>,
          C: FromIterator<T>,
{
    let mut err = None;

    let v = {
        let adapter = iter.filter_map(|item| {
            match item {
                Ok(x) => Some(x),
                Err(x) => {
                    err = Some(x);
                    None
                },
            }
        });

        FromIterator::from_iter(adapter)
    };

    match err {
        Some(err) => Err(err),
        None => Ok(v),
    }
}

fn main() {
    let one: Result<Vec<u8>, _> = FromIterator::from_iter("1,2,3".split(",").map(|x| x.parse()));
    let two: Result<Vec<u8>, _> = from_iter_with_scan("1,2,3".split(",").map(|x| x.parse()));
    let three: Result<Vec<u8>, _> = from_iter_with_filter_map("1,2,3".split(",").map(|x| x.parse()));
    println!("{:?}", one);
    println!("{:?}", two);
    println!("{:?}", three);

    let one: Result<Vec<u8>, _> = FromIterator::from_iter("1,a,3".split(",").map(|x| x.parse()));
    let two: Result<Vec<u8>, _> = from_iter_with_scan("1,a,3".split(",").map(|x| x.parse()));
    let three: Result<Vec<u8>, _> = from_iter_with_filter_map("1,a,3".split(",").map(|x| x.parse()));
    println!("{:?}", one);
    println!("{:?}", two);
    println!("{:?}", three);
}

#[bench]
fn bench_from_iter(b: &mut Bencher) {
    let expected = vec![1; 1000];
    b.iter(|| {
        let v: Vec<Result<isize, String>> = vec![Ok(1); 1000];
        let result: Result<Vec<isize>, String> = FromIterator::from_iter(v.into_iter());
        assert_eq!(result.unwrap(), expected);
    });
}

#[bench]
fn bench_from_iter_with_scan(b: &mut Bencher) {
    let expected = vec![1; 1000];
    b.iter(|| {
        let v: Vec<Result<isize, String>> = vec![Ok(1); 1000];
        let result: Result<Vec<isize>, String> = from_iter_with_scan(v.into_iter());
        assert_eq!(result.unwrap(), expected);
    });
}

#[bench]
fn bench_from_iter_with_filter_map(b: &mut Bencher) {
    let expected = vec![1; 1000];
    b.iter(|| {
        let v: Vec<Result<isize, String>> = vec![Ok(1); 1000];
        let result: Result<Vec<isize>, String> = from_iter_with_filter_map(v.into_iter());
        assert_eq!(result.unwrap(), expected);
    });
}

z-rust-version

rustc 1.6.0-dev (88397e092 2015-12-02)
binary: rustc
commit-hash: 88397e092e01b6043b6f65772710dfe0e59056c5
commit-date: 2015-12-02
host: x86_64-apple-darwin
release: 1.6.0-dev