#![feature(generators, generator_trait)]

extern crate arrayvec;

use arrayvec::{Array, ArrayVec};

macro_rules! gen_iter {
    ($($exp:tt)*) => {
        GenIter(move || {
            $($exp)*
        })
    }
}

fn chunks<A, I>(iter: I) -> impl Iterator<Item = ArrayVec<A>>
where
    A: Array,
    I: IntoIterator<Item = A::Item>,
{
    let mut iter = iter.into_iter();
    gen_iter! {
        loop {
            let mut arr = ArrayVec::new();
            while arr.len() != arr.capacity() {
                if let Some(element) = iter.next() {
                    arr.push(element);
                } else {
                    return;
                }
            }
            yield arr;
        }
    }
}

fn main() {
    let vec = vec![1, 2, 3, 4, 5, 6, 7, 8];
    for chunk in chunks::<[_; 2], _>(vec) {
        println!("{:?}", chunk);
    }
}

use std::ops::{Generator, GeneratorState};
use std::iter::Iterator;

/// a iterator that holds an internal generator representing
/// the iteration state
#[derive(Copy, Clone, Debug)]
pub struct GenIter<T>(pub T)
    where T: Generator;

impl<T: Generator> Iterator for GenIter<T> {
    type Item = <T as Generator>::Yield;

    fn next(&mut self) -> Option<Self::Item> {
        match unsafe { self.0.resume() } {
            GeneratorState::Yielded(n) => Some(n),
            GeneratorState::Complete(_) => None,
        }
    }
}

impl<G: Generator> From<G> for GenIter<G> {
    fn from(gen: G) -> Self {
        GenIter(gen)
    }
}