Ownership and functions

Function calls follow the same rules

A function parameter is just a new variable in the function's scope. So calling a function with a value is like writing let param = value;. For a String, that is a move. For an i32, it is a copy.

fn main() {
    let name = String::from("Kavya");
    let age = 24;

    greet(name);           // name is MOVED into greet
    show_age(age);         // age is COPIED

    // println!("{name}");  // error: borrow of moved value: name
    println!("{age}");     // fine: 24
}

fn greet(person: String) {
    println!("Hello, {person}");
}                          // person goes out of scope here: the String is dropped

fn show_age(years: i32) {
    println!("Age {years}");
}

main: name ──move──> greet: person ──> dropped at greet's closing brace
main: age  ──copy──> show_age: years    (main's age is still 24)

Returning gives ownership back

A function can return a value, which moves ownership to the caller. A function can also create a String and hand it out.

fn make_greeting(name: &str) -> String {
    let text = format!("Welcome, {name}!");
    text                      // ownership moves to the caller
}

fn add_exclamation(mut s: String) -> String {
    s.push('!');
    s                         // give it back
}

fn main() {
    let g = make_greeting("Arjun");
    let g = add_exclamation(g);   // move in, move back out
    println!("{g}");              // Welcome, Arjun!!
}

The clumsy workaround

Suppose you want a function that tells you the length of a String, and you still want to use the String afterwards. With ownership alone, you would have to pass it in and return it back, together with the answer, in a tuple:

fn length(s: String) -> (String, usize) {
    let n = s.len();
    (s, n)                    // hand the String back with the answer
}

fn main() {
    let s1 = String::from("Hyderabad");
    let (s1, n) = length(s1);
    println!("{s1} has {n} bytes");
}

This is exactly the problem references solve. A reference lets a function look at (borrow) a value without taking ownership. The real version is: fn length(s: &String) -> usize, called as length(&s1). You will learn borrowing in the next module, and it will feel like a relief.

Choosing a parameter type (preview)

Common mistakes and fixes

• Using a value after passing it to a function (E0382). Fix: if the function only reads it, change the parameter to a reference; or pass a clone; or return it back.
• Calling a function in a loop with an owned String: for _ in 0..3 { print_name(name); }. The first call moves it. Fix: borrow with &name.
• Forgetting that a function that takes ownership will drop the value at its end. If you need it later, the function must return it, or borrow instead.