trait MyTrait<T> {
    fn iter(&self) -> Iterator<Item = &T>;
}

struct MyStructIterator<'a, T> {
    items: std::slice::Iter<'a, T>,
}

impl<'a, T> MyStructIterator<'a, T> {
    fn new(elements: &'a Vec<T>) -> MyStructIterator<'a, T> {
        let items = elements.iter();
        items.skip(3);
        MyStructIterator { items }
    }
}

impl<'a, T> Iterator for MyStructIterator<'a, T> {
    type Item = &'a T;
    fn next(&mut self) -> Option<Self::Item> {
        self.items.next()
    }
}

struct MyStruct<T> {
    elements: Vec<T>,
}

impl<T> MyTrait<T> for MyStruct<T> {
    fn iter(&self) -> MyStructIterator<T> {
        MyStructIterator::new(&self.elements)
    }
}

fn main() {
    let my_struct = MyStruct {
        elements: vec![
            "a".to_string(),
            "b".to_string(),
            "c".to_string(),
            "d".to_string(),
            "e".to_string(),
        ],
    };

    let mut count = 0;
    for elem in my_struct.iter() {
        count += 1;
    }
    assert!(count == 2);
}