# Lifetime elision in impl

When writing `impl` blocks, you can now elide lifetime annotations in some situations.

Consider a trait like `MyIterator`:

    trait MyIterator {
        type Item;
        fn next(&mut self) -> Option<Self::Item>;
    }

In Rust 2015, if we wanted to implement this iterator for mutable references to `Iterators`, we'd need to write this:

    impl<'a, I: MyIterator> MyIterator for &'a mut I {
        type Item = I::Item;
        fn next(&mut self) -> Option<Self::Item> {
            (*self).next()
        }
    }

Note all of the `'a` annotations. In Rust 2018, we can write this:

    impl<I: MyIterator> MyIterator for &mut I {
        type Item = I::Item;
        fn next(&mut self) -> Option<Self::Item> {
            (*self).next()
        }
    }

Similarly, lifetime annotations can appear due to a struct that contains references:

    struct SetOnDrop<'a, T> {
        borrow: &'a mut T,
        value: Option<T>,
    }

In Rust 2015, to implement `Drop` on this struct, we'd write:

    impl<'a, T> Drop for SetOnDrop<'a, T> {
        fn drop(&mut self) {
            if let Some(x) = self.value.take() {
                *self.borrow = x;
            }
        }
    }

But in Rust 2018, we can combine elision with the anonymous lifetime and write this instead.

    impl<T> Drop for SetOnDrop<'_, T> {
        fn drop(&mut self) {
            if let Some(x) = self.value.take() {
                *self.borrow = x;
            }
        }
    }