How to know when a borrow ends - rust

Question

I wrote this for simple input parsing:
use std::io;
fn main() {
let mut line = String::new();
io::stdin().read_line(&mut line)
.expect("Cannot read line.");
let parts = line.split_whitespace();
for p in parts {
println!("{}", p);
}
line.clear();
io::stdin().read_line(&mut line)
.expect("Cannot read line.");
}
The above code creates a String object, reads a line into it, splits it by whitespace and prints he output. Then it tries to do the same using the same String object. On compilation I get error:
--> src/main.rs:15:5
|
9 | let parts = line.split_whitespace();
| ---- immutable borrow occurs here
...
15 | line.clear();
| ^^^^ mutable borrow occurs here
...
19 | }
| - immutable borrow ends here
As String is owned by an iterator. The solution is described as:
let parts: Vec<String> = line.split_whitespace()
.map(|s| String::from(s))
.collect();
I have few questions here:
I have already consumed the iterator by calling for each on it. Its borrow should have ended.
How do I know lifetimes of borrow from function definitions?
If a function is borrowing an object how do I know its releasing it? e.g. in solution using collect() releases the borrow.
I think I am missing an important concept here.

Answer 1

The problem in your code is that you bind the result of line.split_whitespace() to a name (parts). If you write this instead:
io::stdin().read_line(&mut line)
.expect("Cannot read line.");
for p in line.split_whitespace() { // <-- pass directly into loop
println!("{}", p);
}
line.clear();
io::stdin().read_line(&mut line)
.expect("Cannot read line.");
That way it just works. Another possibility is to artificially restrict the lifetimes of parts, like so:
io::stdin().read_line(&mut line)
.expect("Cannot read line.");
{
let parts = line.split_whitespace();
for p in parts {
println!("{}", p);
}
}
line.clear();
io::stdin().read_line(&mut line)
.expect("Cannot read line.");
This also works.
So why is that? This is due to how the compiler currently works, often called "lexical borrows". The problem here is that each non-temporary value which contains a borrow will be "alive" until the end of its scope.
In your case: since you assign the result of split_whitespace() (which borrows the string) to parts, the borrow is "alive" until the end of scope of parts. Not until the end of life of parts.
In the first version in this answer, we don't bind a name to the value, thus the result of split_whitespace() is only a temporary and the borrow doesn't extend out the the whole scope. That's also why your collect() example works: not because of collect(), but because there is never a name bound to something borrowing the string. In my second version, we just restrict the scope.
Note, that this is a known shortcoming of the compiler. You are right, the compiler just doesn't see it.