References and read-only borrowing

A function that measures a name need not take ownership of it. A reference gives temporary access to a value owned elsewhere. Creating that access is borrowing. An &str parameter accepts a borrowed view of text, making it useful for both String values and string literals.

The ampersand creates a reference. &name can coerce from &String to &str for this call. The function reads the text and returns its byte length without becoming responsible for dropping the String. Multiple shared references can coexist, provided access respects Rust’s borrowing rules.

Save the complete source as main.rs in the Rust environment. No standard input is needed.

Rust 2024 · complete program

fn name_bytes(name: &str) -> usize { name.len() }
fn main() {
  let name = String::from("Diya");
  let count = name_bytes(&name);
  println!("Bytes: {count}");
  println!("Still available: {name}");
}

Expected output

Bytes: 4
Still available: Diya

Follow the execution

Main owns the String. The function borrows its text while calculating the byte count, then returns four. Main can still print name because the call did not consume it. The reference does not extend the lifetime of the owned text.

Try the complete program in the Rust compiler. For tests, Cargo commands and local files, use the specified local environment.

Your task: Why can main still print name after the call?

Rust 2024 · complete program

fn name_bytes(name: &str) -> usize { name.len() }
fn main() {
  let name = String::from("Diya");
  let count = name_bytes(&name);
  println!("Bytes: {count}");
  println!("Still available: {name}");
}

Worked answer

The parameter borrowed the text through &str instead of taking a String by value. Ownership remains in main.

An ordinary shared reference does not permit mutation of its referent; interior-mutability types provide controlled exceptions. Len measures UTF-8 bytes for str, not user-visible letters. Do not return a reference to a local value that will be dropped.

The parameter borrowed the text through &str instead of taking a String by value. Ownership remains in main. An ordinary shared reference does not permit mutation of its referent; interior-mutability types provide controlled exceptions.

Further reading: the official Rust Book on references and read-only borrowing.