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

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

#[derive(Debug, Copy, Clone, PartialEq)]
pub struct Point {
    pub ch: Option<char>,
}

impl Point {
    #[inline]
    pub fn get_char(&self) -> Option<char> {
        self.ch
    }
}

pub fn gen_word_1(rules: &[Point]) -> String {
    rules
        .into_iter()
        .map(|r| r.get_char())
        .filter_map(|r| r)
        .collect()
}

pub fn gen_word_2(rules: &[Point]) -> String {
    let mut vec = Vec::new();

    for rule in rules.iter() {
        if let Some(c) = rule.get_char() {
            vec.push(c)
        }
    }

    vec.into_iter().collect()
}

pub fn gen_word_3(rules: &[Point]) -> String {
    let mut out = String::with_capacity(rules.len());
    out.extend(rules.iter().filter_map(|r| r.get_char()));
    out.shrink_to_fit();
    out
}

pub fn gen_word_4(rules: &[Point]) -> String {
    rules.iter().filter_map(|r| r.get_char()).collect()
}

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

    fn data() -> Vec<Point> {
        (0..5000)
            .map(|x| {
                let o = if x % 2 == 0 { Some('a') } else { None };
                Point { ch: o }
            })
            .collect()
    }

    #[bench]
    fn bench_gen_word_1(b: &mut Bencher) {
        let words = data();
        b.iter(|| gen_word_1(&words));
    }

    #[bench]
    fn bench_gen_word_2(b: &mut Bencher) {
        let words = data();
        b.iter(|| gen_word_2(&words));
    }

    #[bench]
    fn bench_gen_word_3(b: &mut Bencher) {
        let words = data();
        b.iter(|| gen_word_3(&words));
    }

    #[bench]
    fn bench_gen_word_4(b: &mut Bencher) {
        let words = data();
        b.iter(|| gen_word_4(&words));
    }
}