struct A {
    v: Vec<String>,
}
struct AIter<'a> {
    a: &'a A,
    now: usize,
}
struct AIter2 {
    now: usize,
}
impl A {
    fn new(v: Vec<&str>) -> A {
        A {
            v: v.iter().map(|s| s.to_string()).collect(),
        }
    }

    fn iter(&self) -> AIter {
        AIter { a: &self, now: 0 }
    }
    fn iter2(&self) -> AIter2 {
        AIter2 { now: 0 }
    }
}

impl<'a> Iterator for AIter<'a> {
    type Item = &'a str;
    fn next(&mut self) -> Option<&'a str> {
        self.now += 1;
        if self.now - 1 < self.a.v.len() {
            Some(&self.a.v[self.now - 1])
        } else {
            None
        }
    }
}
impl Iterator for AIter2 {
    type Item = usize;
    fn next(&mut self) -> Option<usize> {
        self.now += 1;
        Some(self.now - 1)
    }
}

fn take5<T>(iter: impl Iterator<Item = T>) -> Vec<T> {
    iter.take(5).collect()
}

fn main() {
    let a = A::new(vec!["a", "b", "c", "d", "e", "f", "g"]);
    assert_eq!(vec!["a", "b", "c", "d", "e"], take5(a.iter()));
    assert_eq!(vec![0, 1, 2, 3, 4], take5(a.iter2()));
}