30 Days of Rust - Day 7
Tags: rust, beginners, learning
Published: 2023-04-29 17:03:58

After a week of learning, I'm going to dedicate this blog article to reflecting on what we've learned so far. Before that though here are a few fun facts:

> 1. The blog series has had over 300 views so far - so THANKS for that :)
> 2. If you've read every article in the series, that's over 4500 words.
> 3. Together we've asked and answered 30 questions about Rust.

To break from tradition, I won't be asking any questions today. Tomorrow I'll sketch out what I'm planning for the next week of the series 💪

## Yesterday's questions answered
- All values are by [default stack-allocated](https://doc.rust-lang.org/rust-by-example/std/box.html) in Rust. `Box` is a way to tell the compiler to put a value on the heap. This makes a `Box` a smart pointer. Values should be added to the heap when they are expected to grow or be shared of multiple threads.
- An `Arc` is a smart pointer that [manages multiple atomic references](https://doc.rust-lang.org/std/sync/struct.Arc.html) to a value on a heap. In using an `Arc`, a developer can guarantee thread safety for access to a value. To manipulate values references by an `Arc`, you need to first wrap the value in a `Mutex` before wrapping it in an `Arc`.
- A `Mutex` guarantees single-thread access to a value using the `.lock` method. This enables threads to update values at a given reference safely.
- Having scanned the Rust book, I couldn't find a high-level API for thread management. I did learn about the `channel` concept which enables threads to pass messages to one another.
- The `where` clause is used to improve bounding for traits during generic declarations. The documentation is lacking here and I think it's probably okay to drop this topic for now.
- I couldn't find other exciting features for a `closure`. But I learned that Rust's [compiler will type](https://doc.rust-lang.org/book/ch13-01-closures.html) a `closure` depending on whether it uses variables referenced in another scope.

## 7 Days of Rust in 45 seconds
#### Project management
Depend on Rust's package manager `cargo`:
```bash
cargo new <project_name> # Project init
cargo build; cargo compile; cargo run; # Build and run stuff
cargo add <library> # Add dependencies
cargo test # Run your tests
```

#### Im- / export your Rust
Declare `crates` consisting of `mods` inside of a public function to make code exportable:
```rust
pub fn my_crate() {
	crate::module_root::to::module()
}
```
The same `::` colon syntax is used to import crates and their submodules. You can import wildcards, a single or multiple module members.

#### Indeed I do declare
- `let` and `const` for variable and constants.
- `mut` follows `let` if you want to make something mutable.

#### Control the flow
- Rust supports `if/else` statements as well as `match` statements.
- Tend towards `match` over `if` as `match` is used in several Rust patterns.
- You can loop with `loop`, `for` and `while`.  Opt for `loop` if you need to use uninitialised variables or want a returned value from `break`.
- Use `.iter` method on collections when iterating to get references to its values. 

#### The important data types
- Use arrays and tuples for fixed size collections of single and mixed types, respectively.
- Use `Vec` for a growable collection.
- Favour `String` over read-only `&str`
- `HashMaps` for single-typed lookups, `structs` for logical data groups, `enum` for categories
- Use `traits` to define interfaces for `structs`

#### DaFunc?
- Declare functions with `fn`
- Functions are scoped and will shadow variables outside of their scope
- Omit `return` and trailing `;` to do an implicit return
- Anonymous functions are declared using two pipe operators and are called a `closure`
- `closures` can access variables declared at the same level as them inside their body. Use them for threading!

#### Pointing out the not obvious
- Static values are stored on the stack, dynamic, unknown or recursive structures are stored on the heap.
- Each value on the heap in Rust can only have one owner, thus reassigning a variable to a new variable will relinquish the latter of its ownership.
- Each value has a scope and it will be dropped once that scope is exited -> do you miss the garbage collector?
- Access values via the `&` operator

#### Catching your errors
- If a function doesn't have a `Result` return type, chain its call with `.expect` to catch `panic`.
- Otherwise you can use a `match` statement to handle the error.
- Errors are actually referred to as a `panic` :D

#### Stuff I barely understood
- Use the `Box` API to allocate a value to the heap
- Spawn threads with `thread::spawn` and join all threads with `.join` 
- Use `Arc` to ensure thread-safe resource access