main-bench.rs

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

use std::iter::FromIterator;

#[cfg(test)]
use test::Bencher;

fn from_iter_with_scan_with_freevar<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((), |_, 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_scan_passing_state<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_a: Result<Vec<u8>, _> = from_iter_with_scan_passing_state("1,2,3".split(",").map(|x| x.parse()));
    let two_b: Result<Vec<u8>, _> = from_iter_with_scan_with_freevar("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_a);
    println!("{:?}", two_b);
    println!("{:?}", three);

    let one: Result<Vec<u8>, _> = FromIterator::from_iter("1,a,3".split(",").map(|x| x.parse()));
    let two_a: Result<Vec<u8>, _> = from_iter_with_scan_passing_state("1,a,3".split(",").map(|x| x.parse()));
    let two_b: Result<Vec<u8>, _> = from_iter_with_scan_with_freevar("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_a);
    println!("{:?}", two_b);
    println!("{:?}", three);
}

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

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

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

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