The `Result` types are **enumerations**, often referred to as *enums*. An enumeration is a type that can have a *fixed set of values*, and those values are called the enum’s **variants**.
The `&` indicates that this argument is a reference, which gives a way to let multiple parts of the code access one piece of data without needing to copy that data into memory multiple times.
## Variables & Mutability
By default variables are *immutable*.
```rs
let var1 = value; // immutable var init
let var2: Type = value; // explicit type annotation
let mut var3 = value; // mutable var init
let mut var4: Type = value; // explicit type annotation
const CONSTANT_NAME: type = value; // constant must have the type annotation
By using let, it's possible to perform a few transformations on a value but have the variable be immutable after those transformations have been completed.
An array isn’t as flexible as the `vector` type, though. A vector is a similar collection type provided by the standard library that *is allowed to grow or shrink in size*.
```rs
let array = [0, 1, 2, 3, 4];
let array: [Type; length] = [...];
let array: [value; length]; // same as python's [value] * length
array[index] = value; // member acces and update
```
### Slice Types
Slices allows to reference a contiguos sequence of elements in a collection rather than the whole collection. **Slices don't take ownership**.
```rs
let s = String::from("string literal");
let slice = &s[start..end];
let a = [0, 1, 2, 3, 4, 5];
let slice = &a[start..end];
```
## Functions
Rust code uses *snake_case* as the conventional style for function and variable names.
All programs have to manage the way they use a computer’s memory while running.
Some languages have garbage collection that constantly looks for no longer used memory as the program runs; in other languages, the programmer must explicitly allocate and free the memory.
Rust uses a third approach: memory is managed through a system of ownership with a set of rules that the compiler checks at compile time.
Adding data is called *pushing* onto the stack, and removing data is called *popping* off the stack.
All data stored on the stack must have a known, fixed size. Data with an unknown size at compile time or a size that might change must be stored on the heap instead.
The heap is less organized: when you put data on the heap, you request a certain amount of space. The memory allocator finds an empty spot in the heap that is big enough, marks it as being in use, and returns a **pointer**, which is the address of that location. This process is called *allocating on the heap* and is sometimes abbreviated as just *allocating*.
Pushing to the stack is faster than allocating on the heap because the allocator never has to search for a place to store new data; that location is always at the top of the stack.
Comparatively, allocating space on the heap requires more work, because the allocator must first find a big enough space to hold the data and then perform bookkeeping to prepare for the next allocation.
Accessing data in the heap is slower than accessing data on the stack because you have to follow a pointer to get there. Contemporary processors are faster if they jump around less in memory.
Keeping track of what parts of code are using what data on the heap, minimizing the amount of duplicate data on the heap, and cleaning up unused data on the heap so you don’t run out of space are all problems that ownership addresses.
### Ownership Rules
- Each *value* in Rust has a variable 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.
A "deep copy" (`var.clone()`) makes a copy of the data in the new variable without make the original fall out of scope.
When a variable goes out of scope, Rust calls a special function for us. This function is called `drop`, and it’s where the code to return the memory is located.
If the type needs something special to happen when the value goes out of scope and we add the `Copy` annotation to that type, we’ll get a compile-time error.
```rs
let s = String::new()
let t = s; // shallow copy, s is now out of scope
let u = t.clone(); // deep copy, t is still valid
```
### Ownership & Functions
The semantics for passing a value to a function are similar to those for assigning a value to a variable. Passing a variable to a function will move or copy, just as assignment does.
```rs
fn main() {
let s = String::from("hello"); // s comes into scope
takes_ownership(s); // s's value moves into the function and so is no longer valid here
let x = 5; // x comes into scope
makes_copy(x); // x would move into the function, but i32 is Copy, so it’s okay to still use x afterward
} // Here, x goes out of scope, then s. But because s's value was moved, nothing special happens.
fn takes_ownership(some_string: String) { // some_string comes into scope
println!("{}", some_string);
} // Here, some_string goes out of scope and `drop` is called. The backing memory is freed.
fn makes_copy(some_integer: i32) { // some_integer comes into scope
println!("{}", some_integer);
} // Here, some_integer goes out of scope. Nothing special happens.
```
### Return Values & Scope
Returning values can also transfer ownership.
```rs
fn main() {
let s1 = gives_ownership(); // gives_ownership moves its return value into s1
let s2 = String::from("hello"); // s2 comes into scope
let s3 = takes_and_gives_back(s2); // s2 is moved into takes_and_gives_back, which also moves its return value into s3
} // Here, s3 goes out of scope and is dropped. s2 goes out of scope but was moved, so nothing happens. s1 goes out of scope and is dropped.
fn gives_ownership() -> String { // gives_ownership will move its return value into the function that calls it
let some_string = String::from("hello"); // some_string comes into scope
some_string // some_string is returned and moves out to the calling function
}
// takes_and_gives_back will take a String and return one
fn takes_and_gives_back(a_string: String) -> String { // a_string comes into scope
a_string // a_string is returned and moves out to the calling function
}
```
### References & Borrowing
*Mutable references* have one big restriction: you can have *only one* mutable reference to a particular piece of data in a particular scope.
The `Option` type is used in many places because it encodes the very common scenario in which a value could be something or it could be nothing. Expressing this concept in terms of the type system means the compiler can check whether you’ve handled all the cases you should be handling; this functionality can prevent bugs that are extremely common in other programming languages.
In addition, so are its variants: you can use `Some` and `None` directly without the `Option::` prefix.
```rs
// std implementation
enum Option<T> {
Some(T),
None
}
```
*NOTE*: When `None` is used the type of `Option<T>` must be specified, because the compiler can’t infer the type that the `Some` variant will hold by looking only at a `None` value.
Vectors allow to store more than one value in a single data structure that puts all the values next to each other in memory. Vectors can only store values of the *same type*.
Like any other struct, a vector is freed when it goes out of scope. When the vector gets dropped, all of its contents are also dropped.
```rs
let v: Vec<Type> = Vec<Type>::new(); // empty vec init
