Testing Rust collection conversions through FromIterator and IntoIterator

collection_conversion.rs

use std::iter::{Iterator, IntoIterator, FromIterator};

fn main() {
    let v: Vec<i32> = FiveNumbers::new(2,3,5,8,13).into_iter().collect();
    let f = v.iter().cloned().collect::<FiveNumbers>();
    let r: Result<FiveNumbers, ()> = 
        vec![1,2,3,4,5].into_iter().map(|n| Ok(n)).collect();
    let r2: Result<Vec<i32>, &str> = 
        f.clone().into_iter().map(|n| Ok(n)).collect();
    let r3: Result<Vec<i32>, &str> = 
        vec![Ok(2), Err("pls"), Ok(3)].into_iter().collect();
    println!("{:?}\n{:?}\n{:?}\n{:?}\n{:?}", v, f, r, r2, r3);
}

#[derive(Debug, Clone)]
struct FiveNumbers {n0: i32, n1: i32, n2: i32, n3: i32, n4: i32}

impl FiveNumbers {
    fn new(n0: i32, n1: i32, n2: i32, n3: i32, n4: i32) -> FiveNumbers {
        FiveNumbers {n0: n0, n1: n1, n2: n2, n3: n3, n4: n4}
    }
}

struct IntoIter {
    numbers: FiveNumbers,
    count: u8
}

impl Iterator for IntoIter {
    type Item = i32;
    fn next(&mut self) -> Option<i32> {
        macro_rules! match_numbers {
            ($([$prop: ident, $n: expr]),*) => {{ match self.count {
                $($n => Some(self.numbers.$prop)),*,
                _ => None
            }}}
        }
        let iter = match_numbers!([n0, 0], [n1, 1], [n2, 2], [n3, 3],[n4, 4]);
        if self.count < 5 {
            self.count += 1;
        }
        iter
    }
}

impl IntoIterator for FiveNumbers {
    type Item = i32;
    type IntoIter = IntoIter;
    fn into_iter(self) -> IntoIter {
        IntoIter { numbers: self, count: 0 }
    }
}

impl FromIterator<i32> for FiveNumbers {
    fn from_iter<T>(iter: T) -> FiveNumbers where T: IntoIterator<Item=i32> {
        let mut iter = iter.into_iter();
        FiveNumbers::new(
            iter.next().unwrap(),
            iter.next().unwrap(),
            iter.next().unwrap(),
            iter.next().unwrap(),
            iter.next().unwrap()
        )
    }
}