Rust Owned And Borrowed Types

What are Owned and Borrowed types in Rust? To know these concepts, we need to understand first what Rust Ownership and Rust References.

Get Your Head Around Rust Ownership

When we talk about ownership in Rust, we generally mean – a variable owns a value. As we assign the same value between variables, we move the value, changing the owner. While this is true for Rust Owned types, the behavior is different for Rust References (also known as Borrowed types). We pass around addresses of values somewhere in the memory instead of the values themselves.

Rust Borrowed Types

Rust Borrowed types are types that do not follow the rules for Ownership. Variables of this kind (any Rust data types) have an ampersand (&) symbol in front of them. Consider the following examples.

let pet_name: &String = &String::from("Gary");  // Type is &String

let pet_owner_name: &str = "Karl"; // Type is &str

let pet_name: &String = &String::from("Gary"); // Type is &String

let pet_owner_name: &str = "Karl"; // Type is &str

What happens when we try to move a reference type between variables? What do you think? Here are some Rust codes.

fn main() {
    let pet_name: &String = &String::from("Gary");  // Type is &String
    let pet_owner_name: &str = "Karl"; // Type is &str

    // Assigning the same value between variables pet_name and pet_alias
    let pet_alias = pet_name;
    let pet_owner_alias = pet_owner_name;

    println!("Pet Name: {}", pet_name);
    println!("Pet Alias: {}", pet_alias);

    println!("Pet Owner Name: {}", pet_owner_name);
    println!("Pet Owner Alias: {}", pet_owner_alias);
}

fn main() {

let pet_name: &String = &String::from("Gary"); // Type is &String

let pet_owner_name: &str = "Karl"; // Type is &str

// Assigning the same value between variables pet_name and pet_alias

let pet_alias = pet_name;

let pet_owner_alias = pet_owner_name;

println!("Pet Name: {}", pet_name);

println!("Pet Alias: {}", pet_alias);

println!("Pet Owner Name: {}", pet_owner_name);

println!("Pet Owner Alias: {}", pet_owner_alias);

}

When we run these codes, we get the following results.

Pet Name: Gary
Pet Alias: Gary
Pet Owner Name: Karl
Pet Owner Alias: Karl

Pet Name: Gary

Pet Alias: Gary

Pet Owner Name: Karl

Pet Owner Alias: Karl

Did we move any values? Nope!

Rust Owned Types

Now, the Rust Owned types are different from Borrowed types. They follow the Rust Ownership rules. These variables contain the actual values they represent, unlike Borrowed types which have location addresses of the values they represent.

Let us modify the codes from the previous section as follows. Now we are using the String data type for pet_name and pet_owner_name!

fn main() {
    let pet_name: String = String::from("Gary");  // Type is String
    let pet_owner_name: String = String::from("Karl"); // Type is String

    // Assigning the same value between variables pet_name and pet_alias
    let pet_alias = pet_name;
    let pet_owner_alias = pet_owner_name;

    println!("Pet Name: {}", pet_name);
    println!("Pet Alias: {}", pet_alias);

    println!("Pet Owner Name: {}", pet_owner_name);
    println!("Pet Owner Alias: {}", pet_owner_alias);
}

fn main() {

let pet_name: String = String::from("Gary"); // Type is String

let pet_owner_name: String = String::from("Karl"); // Type is String

// Assigning the same value between variables pet_name and pet_alias

let pet_alias = pet_name;

let pet_owner_alias = pet_owner_name;

println!("Pet Name: {}", pet_name);

println!("Pet Alias: {}", pet_alias);

println!("Pet Owner Name: {}", pet_owner_name);

println!("Pet Owner Alias: {}", pet_owner_alias);

}

When we run these codes, we will get the following compilation errors.

error[E0382]: borrow of moved value: `pet_name`
 --> src\main.rs:9:30
  |
2 |     let pet_name: String = String::from("Gary");  // Type is String
  |         -------- move occurs because `pet_name` has type `String`, which does not implement the `Copy` trait
...
6 |     let pet_alias = pet_name;
  |                     -------- value moved here
...
9 |     println!("Pet Name: {}", pet_name);
  |                              ^^^^^^^^ value borrowed here after move
  |
  = note: this error originates in the macro `$crate::format_args_nl` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0382]: borrow of moved value: `pet_name`

--> src\main.rs:9:30

2 | let pet_name: String = String::from("Gary"); // Type is String

| -------- move occurs because `pet_name` has type `String`, which does not implement the `Copy` trait

...

6 | let pet_alias = pet_name;

| -------- value moved here

...

9 | println!("Pet Name: {}", pet_name);

| ^^^^^^^^ value borrowed here after move

= note: this error originates in the macro `$crate::format_args_nl` (in Nightly builds, run with -Z macro-backtrace for more info)

The error messages could confuse newbies who lack the basic understanding of Rust Owned and Borrowed types, even Rust Ownership rules. Notice the message error uses the root words “borrow” and “move.”

Okay, so what’s next? With a better understanding of Rust Owned and Borrowed types, we could work with Rust more confidently. For example, now we know that we could return Owned values from functions and methods without resorting to global static variables. In the same token, we now know that we should not return a reference type from a function or method.

Are you having fun so far? There are really Owned and Borrowed types, and we didn’t make them up! Check the following codes.

fn main() {
    let pet_name: String = String::from("Gary");  // Type is String
    let pet_owner_name: String = String::from("Karl"); // Type is String
    
    let borrowed_type_variable: &str = "this is a string";
    let owned_type_variable:String = borrowed_type_variable.to_owned();

    println!("borrowed - {}", borrowed_type_variable);
    println!("owned - {}", owned_type_variable);
}