How long a borrow lasts

Chatterbox's command.rs still has the function from lesson 4.6: fn first_word(text: &str) -> &str. It does not copy anything. It hands back a borrow: a window onto the first few bytes of text that somebody else owns. A window is only useful while the thing behind it still exists. So how does the compiler know, everywhere first_word is called, that the text is still there when the window is used?

Start with the danger itself, in a tiny program. The curly braces in the middle make an inner block: anything made inside it is cleaned up at its closing brace, exactly like a function's frame in lesson 4.1.

error[E0597]: `msg` does not live long enough
 --> src/main.rs:5:13
  |
4 |         let msg = String::from("hello");
  |             --- binding `msg` declared here
5 |         r = &msg;
  |             ^^^^ borrowed value does not live long enough
6 |     }
  |     - `msg` dropped here while still borrowed
7 |     println!("{r}");
  |                - borrow later used here

In languages without this check, a reference like r is a classic bug: the program reads memory that has been handed back and maybe reused, and prints garbage, crashes, or worse. Rust rules it out before the program exists.

To do that, the compiler gives every borrow a lifetime: the stretch of the program during which the borrow is good. Here it is from line 5 to the last use on line 7. The owner msg only lives until line 6. The rule is one sentence: a borrow's lifetime must fit inside its owner's. Line 7 breaks it, and that is E0597.

The same rule explains a mistake everyone makes once: making a value inside a function and handing back a borrow of it. When the function returns, its frame is gone, and the value with it.

error[E0515]: cannot return reference to local variable `text`
 --> src/main.rs:3:5
  |
3 |     &text
  |     ^^^^^ returns a reference to data owned by the current function

Here is the catch. The compiler checks each function on its own, by its first line, its signature. When it checks a call to first_word, it does not read the body. So the signature has to say where the returned borrow comes from. For most functions there is only one sensible answer, and Rust fills it in for you. This is called lifetime elision (elided means "left out"), and it follows three rules:

1. Every borrowed input gets its own lifetime.
2. If there is exactly one borrowed input, the output borrows from it.
3. If the function is a method with &self, the output borrows from self.

first_word(text: &str) -> &str has one borrowed input, so rule 2 says the result borrows from text, and every caller is checked against that. Chatterbox's arg works the same way. And the name(&self) -> &str method you wrote for Replier in lesson 8.4 is rule 3.

The rules run out when there is no single answer. Then the compiler asks you.

error[E0106]: missing lifetime specifier
 --> src/main.rs:1:32
  |
1 | fn longer(a: &str, b: &str) -> &str {
  |              ----     ----     ^ expected named lifetime parameter
  |
  = help: this function's return type contains a borrowed value, but the signature does not say whether it is borrowed from `a` or `b`
help: consider introducing a named lifetime parameter
  |
1 | fn longer<'a>(a: &'a str, b: &'a str) -> &'a str {
  |          ++++     ++          ++          ++

Notice what 'a does not do: it does not make anything live longer. A lifetime annotation only describes how borrows relate, so the compiler can check each call. With one 'a on both inputs, the result is good only while both are, which is the shorter of the two. Try it.

error[E0597]: `second` does not live long enough
  --> src/main.rs:10:33
   |
 9 |         let second = String::from("hi");
   |             ------ binding `second` declared here
10 |         result = longer(&first, &second);
   |                                 ^^^^^^^ borrowed value does not live long enough
11 |     }
   |     - `second` dropped here while still borrowed
12 |     println!("{result}");
   |                ------ borrow later used here

The top row is fine: the loan ends inside its owner. In the bottom row the loan runs past line 11, where second is dropped. Moving the println! inside the block, or making second before the block, fixes it.

One lifetime has a name built in. Text in quotes, like "/help", is written into the program file itself, so it exists for the whole run. Its type is &'static str: a borrow good for as long as the program runs. Chatterbox's const HELP: &str is one of those; inside a const, Rust fills in 'static for you. In a function with no borrowed input at all, there is nothing to borrow from, so you must say it.

error[E0106]: missing lifetime specifier
 --> src/main.rs:1:18
  |
1 | fn bot_name() -> &str {
  |                  ^ expected named lifetime parameter
  |
  = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
help: consider using the `'static` lifetime, but this is uncommon unless you're returning a borrowed value from a `const` or a `static`
  |
1 | fn bot_name() -> &'static str {
  |                   +++++++
help: instead, you are more likely to want to return an owned value
  |
1 - fn bot_name() -> &str {
1 + fn bot_name() -> String {
  |

Chatterbox did not change in this lesson; you can now read it more closely. Every & in it has a lifetime, and the compiler checked each one fits inside its owner. Elision wrote them for first_word, arg and Replier::name, and you write one only when a function returns a borrow and the rules cannot tell where it comes from. As a preview, chapter 9 adds JSON and the real model.

Sources The Rust Book: Validating References with Lifetimes · The Rust Reference: Lifetime elision · Rust error index: E0106