Hi there! welcome back, this time we will be back to the
notes posts revisiting some of the core concepts of
Rust. We will focus on the concepts of ownership and borrowing. These are developed in chapter 4 of the book, but we will also use other sources to internalize each one.
Ownership is Rust’s most unique feature, and it enables Rust to make memory safety guarantees without needing a garbage collector.
In Rust memory is managed through a system of ownership with a set of rules that the compiler checks at compile time. None of the ownership features slow down your program while it’s running.
- Each value in Rust has a variable binding that’s called its owner.
- There can only be one owner at a time.
- When the owner goes out of scope, the value will be dropped.
Let’s see a couple of examples that introduce the next topic (
This works as expected
But this don’t compile
Move and Copy semantics
- Move semantics
In the above examples, the second one don’t compile. That is because
Rust by default have
move semantics, that means:
When assigning a variable binding to another variable binding or when passing it to a function(without referencing), the bound resources are moved to the new variable binding and we can not access the original variable binding anymore.
ownership state of the original bindings is set to
- Copy semantics
But, the other example compiles… That is because the
type we use implements the
Copy trait. ( has
copy semantic )
When assigning a variable binding to another variable binding or when passing it to a function(without referencing), the bound resources are made a copy and assign or pass it to the function.
Also, the ownership state of the original bindings is set to
copied state. Mostly
primitive types implement
References and Borrowing
Remember the first rule of
value can have only one owner (a
variable binding ). So, what happens when we need to pass the binding to another function or assign them to other variable bindings. In those cases, we are referencing the original binding, borrow the data of it.
- Either have
multipleimmutable (&T) borrows
exclusivelyone mutable (&mut T) borrow
Looking resources for this post I found this post where it’s recommended to use other naming convention that is more clear to me:
Shared references ( &T )
shared reference means that other references to the same value might exist, possibly on other threads (if
Sync) or the caller’s stack frame on the current thread.
Exclusive references ( &mut T)
exclusive reference means that no other reference to the same value could possibly exist at the same time.
** Examples based from learning rust
That’s all for today, we revisited the concepts of
Borrowing, in the next
post we will talking about
As always, I write this as a learning journal and any feedback is welcome.
Author Javier Viola