#![feature(specialization)]

pub struct Cloned<I> {
    it: I,
}

impl<'a, I, T: 'a> Iterator for Cloned<I>
    where I: Iterator<Item=&'a T>, T: Clone
{
    type Item = T;

    fn next(&mut self) -> Option<T> {
        self.it.next().cloned()
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        self.it.size_hint()
    }
}

impl<'a, I, T: 'a> Iterator for Cloned<I>
    where I: Iterator<Item=&'a T>, T: Copy
{
    fn nth(&mut self, n: usize) -> Option<T> {
        self.it.nth(n).cloned()
    }

    fn last(self) -> Option<T> {
        self.it.last().cloned()
    }

    fn count(self) -> usize {
        self.it.count()
    }
}

fn main() {
    let mut called = 0;

    let a = [1, 2, 3, 4];

    Cloned { it: a.iter().map(|x| {
        called += 1;
        x
    }) }.count();

    println!("{}", called);
}