strange lifetime in rust functions, second mutable borrow occurs

I have two pieces of rust codes about lifetime. The first one has only one lifetime mark <'a> which can't pass compilation. The second one has two lifetime marks <'a, 'b> which can pass compilation. What's the reason of this?

The first one:

fn deserialize1<'a, I: Iterator<Item = &'a u8>>(_iter: &'a mut I) {
}
fn deserialize2<'a, I: Iterator<Item = &'a u8>>(_iter: &'a mut I) {
}
fn deserialize3<'a, I: Iterator<Item = &'a u8>>(iter: &'a mut I) {
    deserialize1(iter);
    deserialize2(iter);
}

fn main() {
    let v : Vec<u8> = vec![1, 2, 3];
    let mut iter = v.iter();
    deserialize3(&mut iter);
}

The second one:

fn deserialize1<'a, 'b, I: Iterator<Item = &'a u8>>(_iter: &'b mut I) {
}
fn deserialize2<'a, 'b, I: Iterator<Item = &'a u8>>(_iter: &'b mut I) {
}
fn deserialize3<'a, 'b, I: Iterator<Item = &'a u8>>(iter: &'b mut I) {
    deserialize1(iter);
    deserialize2(iter);
}

fn main() {
    let v : Vec<u8> = vec![1, 2, 3];
    let mut iter = v.iter();
    deserialize3(&mut iter);
}

The first one compile failed with:

error[E0499]: cannot borrow `*iter` as mutable more than once at a time
  --> src/main.rs:33:18
   |
31 | fn deserialize3<'a, I: Iterator<Item = &'a u8>>(iter: &'a mut I) {
   |                 -- lifetime `'a` defined here
32 |     deserialize1(iter);
   |     ------------------
   |     |            |
   |     |            first mutable borrow occurs here
   |     argument requires that `*iter` is borrowed for `'a`
33 |     deserialize2(iter);
   |                  ^^^^ second mutable borrow occurs here

I can't understand above compilation info. Why lifetime can affect borrow rules?

When you use one lifetime as you've done here, you are over-constraining your references. Why does the iterator's lifetime have to match the lifetime of the references it yields? Its even more constrained since the 'a used for the iterator Item is invariant in this case meaning the compiler can't adjust the lifetime at all.

Ok, there's a lot of inflexibility when using a single lifetime here, but why is that a problem? Since 'a is invariant, and you're passing the same thing to deserialize1 and deserialize2 which are defined the same way, that means that iter: &'a mut I means the exact same thing in each function. Both functions are trying to exclusively borrow iter for the same exact lifetime 'a and that is plainly not allowed by the Rust borrow checker.

When you introduce iter to use a different lifetime 'b, you allow the compiler to choose a different lifetime for each mutable borrow and thus won't conflict.

> Why lifetime can affect borrow rules?

Lifetime annotations exist solely to inform the borrow checker of how references are used. Obviously if you annotate your lifetimes incorrectly compared to your usage, the borrow checker would catch that and present an error.

As a final note, you don't need to mention 'b explicitly. You can leave iter un-annotated and will be identical to your second variant due to lifetime elision rules:

fn deserialize1<'a, I: Iterator<Item = &'a u8>>(_iter: &mut I) {}
fn deserialize2<'a, I: Iterator<Item = &'a u8>>(_iter: &mut I) {}
fn deserialize3<'a, I: Iterator<Item = &'a u8>>(iter: &mut I) {
    deserialize1(iter);
    deserialize2(iter);
}