IPW 2026 - Intro to Rust

class: center, middle

# Intro to rust

.title[.center[![Intro to Rust](images/rust.png)]]

---
class: center, middle

# I will be throwing information at you... your goal: understand the keywords, get a vague idea, and practice!

---

# Hello, World!

```rust
fn main() {
    println!("Hello, World!");

let x: u32 = 1337;
    println!("The value of x is: {}", x);
    println!("The value of x is: {x}");
}
```

---

# Printing even more

```rust
// This "derive" is necessary to be able
// for the structure to be printed using {:?}
#[derive(Debug)]
struct MyPoint {
    pub x: u32,
    pub y: u32,
}

fn main() {
    println!("Hello, World!");

let point: MyPoint = MyPoint {
        x: 16,
        y: 37,
    };

// These will NOT work:
    // println!("My point is: {}", point);
    // println!("My point is: {point}");

// These will work: (we have #[derive(Debug)])
    println!("My point is: {:?}", point);
    println!("My point is: {point:?}");
}
```

---

# Variable types - Integers

| Length              | Signed | Unsigned | Java Equivalent | C Equivalent |
| :----------------: | :------: | :----: | :----: | :---: |
| 8-bit |   `i8`   | `u8` | `byte`/ `Byte` | `char` / `unsigned char` |
| 16-bit |   `i16`   | `u16` | `short` / `Short` | `short` / `unsigned short` |
| 32-bit |   `i32`   | `u32` | `int` / `Integer` | `int` / `unsigned int` |
| 64-bit |   `i64`   | `u64` | `long` / `Long` | `long long` / `unsigned long long` |
| 128-bit |   `i128`   | `u128` | N/A | N/A |
| arch |   `isize`   | `usize` | N/A | `intptr_t` / `uintptr_t` |

---

# Variable types - Floats

| Length              | Floating point | Java Equivalent| C Equivalent |
| :----------------: | :------: | :----: | :---: |
| 32-bit | `f32` | `float` | `float` |
| 64-bit | `f64` | `double` | `double` |
| 128-bit | `f128` | N/A | N/A |

```rust
fn main() {
    let x = 2.0; // f64
    let y1: f32 = 3.0; // f32
    let y2 = 3.0f32; // f32
}
```

---

# Booleans

```rust
let t = true;
let f: bool = false; // with explicit type annotation
```

---

# Char

```rust
let c = 'z';
let z: char = 'ℤ'; // with explicit type annotation
let heart_eyed_cat = '😻';
```

`char` is 4-bytes long (and this is why we have UTF support)

---

# Mutability

By default, types are immutable.

```rust
fn main() {
    let x = 5;
    println!("The value of x is: {x}");
    x = 6; // <--- ERROR! Will not compile
    println!("The value of x is: {x}");
}
```

```rust
fn main() {
    let mut x = 5; // <--- Notice the keyword `mut`
    println!("The value of x is: {x}");
    x = 6;
    println!("The value of x is: {x}");
}
```

---

# Functions

```rust
pub fn my_func(x: u32) -> u32 {
    let magic_value = 123;
    let mundane_value = 67;
    x * magic_value + mundane_value
}

pub fn return_one() -> u32 {
    return 1;
}

pub fn return_two() -> u32 {
    2
}
```

---

# Structs

```rust
struct MyPoint {
    pub x: u32,
    pub y: u32,
}

impl MyPoint {
    // Can use Self instead of MyPoint
    pub fn new(x: u32, y: u32) -> Self {
        MyPoint {
            x,
            y
        }
    }

pub fn dist_from_origin(&self) -> f64 {
        let result_squared = self.x * self.x + self.y * self.y;
        (result_squared as f64).sqrt()
    }
}
```

---

# Structs - 2

```rust
struct MyPoint {
    pub x: u32,
    pub y: u32,
}

impl MyPoint {
    // Can use Self instead of MyPoint
    pub fn new(x: u32, y: u32) -> Self {
        MyPoint {
            x,
            y
        }
    }

pub fn set_x_to_0(&mut self) {
        self.x = 0;
    }

pub fn set_y(&mut self, y: u32) {
        self.y = y;
    }

pub fn add_x_y(self) -> u32 {
        self.x + self.y
    }
}
```

---

# Control Expressions - if/else

```rust
let age = 67;

if age >= 21 {
    println!("Allowed to drink in America")
} else if age >= 18 {
    println!("Allowed to drink in Europe")
} else {
    println!("Not allowed to drink")
}

let can_drink = age >= 21;
let can_drink = if age >= 21 { true } else { false };

```

---

# Control Expressions - if/else

```rust
#[derive(Debug)]
struct Adult;
#[derive(Debug)]
struct Minor;

let age = 67;

let person = if age >= 18 {
    Adult {}
} else {
    Minor {}
};

println!("This person: {person:?}");
```

---

# Control Expressions - loop

```rust
loop {
    println!("Hello, world!");
}
```

---

# Control Expressions - loop

```rust
let mut x = 0;
loop {
    println!("{x} Hello, world!");
    x += 1;

if x >= 100 {
        break;
    }
}
```

---

# Control Expressions - loop

```rust
let mut x = 0;
let y = loop {
    println!("{x} Hello, world!");
    x += 1;

if x >= 100 {
        break 5;
    }
};

println!("y = {y}");
```

---

# Control Expressions - while

```rust
let mut x = 0;
while x >= 100 {
    println!("{x} Hello, world!");
}
```

---

# Control Expressions - for

```rust
for x in 0..101 {
    println!("{x} Hello, world!");
}
```

---

# Enums

```rust
#[derive(Debug)]
enum Person {
    Adult,
    Minor,
}

let age = 67;

let person = if age >= 18 {
    Person::Adult
} else {
    Person::Minor
};

println!("This person: {person:?}");
```

---

# Control Expressions - match

```rust
#[derive(Debug)]
enum Money {
    OneEuro,
    TenEuro,
    TwentyEuro,
}

let bank_note = Money::TenEuro;

match bank_note {
    Money::OneEuro => println!("You have 1 euro"),
    Money::TenEuro => {
        println!("You have 10 euro");
    }
    Money::TwentyEuro => {
        println!("You have 20 euro");
        println!("Wow");
    }
}
```

---

# Control Expressions - match

```rust
#[derive(Debug)]
enum Money {
    OneEuro,
    TenEuro,
    TwentyEuro,
}

let bank_note = Money::TenEuro;

let value = match bank_note {
    Money::OneEuro => 1,
    Money::TenEuro => 10,
    Money::TwentyEuro => 20,
};

println!("You have {value} euro");
```

---

# Enums (2)

```rust
#[derive(Debug)]
enum BankAccount {
    Euro(u32),
    Ron(u32),
    Yen(u32),
}

let account = BankAccount::Euro(25);

match account {
    BankAccount::Euro(val) => {
        println!("Your euro account has {val} euros in it")
    }
    BankAccount::Ron(val) => {
        println!("Your ron account has {val} ron in it")
    }
    BankAccount::Yen(val) => {
        println!("Your yen account has {val} yen in it")
    }
}
```

---

# Enums (3)

```rust
#[derive(Debug)]
enum BankAccount {
    Euro {
        balance: u32,
    },
    Ron {
        balance: u32,
    },
    Yen {
        balance: u32,
        secret_value: u32,
    },
}

let account = BankAccount::Yen {
    balance: 25,
    secret_value: 67,
};

match account {
    BankAccount::Yen {balance, secret_value: _ignore} => {
        println!("Your yen account has {balance} yen in it")
    }
    _ => {}
}
```

---

# The two most important rust types you will need to learn are ...

```rust
enum Option<T> {
    Some(T),
    None,
}
```

```rust
enum Result<TOk, TErr> {
    Ok(TOk),
    Err(TErr),
}
```

---

# Option

```rust
use rand::prelude::*;

struct SchrodingerBox;
#[derive(Debug)]
struct Cat;

impl SchrodingerBox {
    pub fn is_cat_alive(&self) -> bool {
        rand::random()
    }

pub fn get_cat(&self) -> Option<Cat> {
        if self.is_cat_alive() {
            Some(Cat {})
        } else {
            None
        }
    }
}

let sbox = SchrodingerBox {};
println!("The cat is: {"?}", sbox.get_cat())
```

---

# Result

```rust
use std::fmt::{Display, Formatter};

#[derive(Debug)]
enum DivisionError {
    ZeroDivision,
    SevenDivision,
}

impl Display for DivisionError {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> { 
        match self {
            Self::ZeroDivision => {
                writeln!(f, "Impossible to divide by zero")?;
            }
            Self::SevenDivision => {
                writeln!(f, "We no longer associated with 7 due to the incident with the number 9")?;
            }
        }
        Ok(())
    }
}

impl std::error::Error for DivisionError {}

pub fn divide(x: u32, y: u32) -> Result<f32, DivisionError> {
    match y {
        0 => Err(DivisionError::ZeroDivision),
        7 => Err(DivisionError::SevenDivision),
        val => Ok((x as f32) / (val as f32)),
    }
}

println!("1/2 = {:?}", divide(1,2));
println!("1/0 = {:?}", divide(1,0));
println!("1/7 = {:?}", divide(1,7));
```

---

# Traits

```rust
trait Animal {
    fn noise(&self) -> &str;
}

struct Dog;
struct Fox;

impl Animal for Dog {
    fn noise(&self) -> &str {
        "Bark"
    }
}

impl Animal for Fox {
    fn noise(&self) -> &str {
        "What does the fox say?"
    }
}

let fox = Fox {};
println!("Fox's noise: {}", fox.noise());
```

---
class: center, middle

# Let's take a breather ... everyone is still here?

---
# Ownership

- A variable binding _takes ownership_ of its data.
    - A piece of data can only have one owner at a time.
- When a binding goes out of scope, the bound data is released automatically. (`Drop` trait)
    - For heap-allocated data, this means de-allocation.
- Data _must be guaranteed_ to outlive its references.

```rust
fn foo() {
    // Creates a String
    // Gives ownership of the String object to s
    let s = String::from ("This text is owned by s");

// At the end of the scope, s goes out of scope.
    // s still owns the String object, so it can be cleaned up.
}
```

---
## Move Semantics

```rust
let s1 = String::from ("A string");

// Ownership of the String object moves to s2.
let s2 = s1;

println!("{}", s1); // error: use of moved value `s1`
```

- `let s2 = s1;`
    - We don't want to copy the data, since that's expensive.
    - The data cannot have multiple owners.
    - Solution: move the String's ownership into `s2`, and declare `s1` invalid.
- `println!("{}", s1);`
    - We know that `s1` is no longer a valid variable binding, so this is an error.
- Rust can reason about this at compile time, so it throws a compiler error.

---
## Move Semantics

- Moving ownership copies data. BUT:
    - Often moves are optimized out by compiler.
    - When we move ownership of a heap allocated data (e.g. `String`), we do
        not touch data on heap, just few bytes allocated on stack are copied
        (pointer to heap, length and capacity; 24 bytes on 64-bit machine)
- Moves are automatic (via assignments); no need to use something like C++'s
  `std::move`.
    - However, there are functions like `std::mem::replace` in Rust to provide
      advanced ownership management.
- For more finer-grained control see standrard library functions:
`std::mem::replace`, `std::mem::swap` and others.

---
## Ownership

- Ownership does not always have to be moved.
- What would happen if it did? Rust would get very tedious to write:

```rust
fn string_length(s: String) -> String {
    // Do whatever here,
    // then return ownership of `s` back to the caller
}
```

---
## Borrowing

- Instead of transferring ownership, we can _borrow_ data.
- A variable's data can be borrowed by taking a reference to the variable;
  ownership doesn't change.
    - When a reference goes out of scope, the borrow is over.
    - The original variable retains ownership throughout.

```rust
let s = String::from ("string");

// s_ref is a reference to s.
let s_ref = &s;

// use s_ref to access the data in the String s.
assert_eq!(s.chars().nth(1), s_ref.chars().nth(1));
```

Rust does automatic dereferencing.

---
## Borrowing

- Caveat: this adds restrictions to the original variable.
- Ownership cannot be transferred from a variable while references to it exist.
    - That would invalidate the reference.

```rust
let s = String::from("for borrow");

// s_ref is a reference to s.
let s_ref = &s;

// Moving ownership to s_new would invalidate s_ref.
// error: cannot move out of `s` because it is borrowed
let s_new = s;

println! ("{}", s_ref);
```

Try it without the `println!`

---
## Borrowing

```rust
/// `length` only needs `String` temporarily, so it is borrowed.
fn length(str_ref: &String) -> usize {
    // str_ref is auto-dereferenced when you call methods on it.
    str_ref.len()
    // you can also explicitly dereference.
    // (*str_ref).len()
}

fn main() {
    let s = String::new ();
    length(&s);
    println!("{:?}", s); // this is fine
}
```
- Note the type of `length`: `str_ref` is passed by reference, so it's now an `&String`.
- References, like bindings, are *immutable* by default.
- The borrow is over after the reference goes out of scope (at the end of `length`).

---
## Borrowing

```rust
/// `push` needs to modify `string` so it is borrowed mutably.
fn push(str_ref: &mut String, x: &str) {
    str_ref.push_str (x);
}

fn main() {
    let mut s: String = String::from ("");
    let string_ref: &mut String = &mut s;
    push(string_ref, "str");
    assert_eq!(string_ref, "str");
}
```
- Variables can be borrowed by _mutable_ reference: `&mut string_ref`.
    - `string_ref` is a reference to a mutable `String`.
    - The type is `&mut String`, not `&String`.
- Different from a reference which is variable.

---
## Borrowing

```rust
/// `push` needs to modify `string` so it is borrowed mutably.
fn push2(str_ref: &mut String, x: &str) {
    // error: cannot move out of borrowed content.
    let string = *str_ref;
    string.push_str(x);
}

fn main() {
    let mut vector = String::from ("");
    push2(&mut string, "a new str");
}
```
- Error! You can't dereference `string_ref` into a variable binding because that
  would change the ownership of the data.

---
## Borrowing

- Rust will auto-dereference variables...
    - When making method calls on a reference.
    - When passing a reference as a function argument.

```rust
/// `length` only needs `s` temporarily, so it is borrowed.
fn length(s_ref: &&String) -> usize {
    // s_ref is auto-dereferenced when you call methods on it.
    s_ref.len()
}

fn main() {
    let s = String::from("");
    length(&&&&&&&&&&&&s);
}
```

---
## Borrowing

- You will have to dereference variables...
    - When writing into them.
    - And other times that usage may be ambiguous.

```rust
let mut a = 5;
let ref_a = &mut a;
*ref_a = 4;
println!("{}", *ref_a + 4);
// ==> 8
```

---
## `Copy` Types

- Rust defines a trait¹ named `Copy` that signifies that a type may be
    copied instead whenever it would be moved.
- Most primitive types are `Copy` (`i32`, `f64`, `char`, `bool`, etc.)
- Types that contain references may not be `Copy` (e.g. `Vec`, `String`).
```rust
let x: i32 = 12;
let y = x; // `i32` is `Copy`, so it's not moved :D
println!("x still works: {}, and so does y: {}", x, y);
```

¹ Like a Java/Go interface or Haskell typeclass

---
## Borrowing Rules
##### _The Holy Grail of Rust_
Learn these rules, and they will serve you well.

- You can't keep borrowing something after it stops existing.
- One object may have many immutable references to it (`&T`).
- **OR** _exactly one_ mutable reference (`&mut T`) (not both).
- That's it!

.card[.small[.center[![Borrow Rules](images/sep_borrow_rules.png)]]]

---
### Borrowing Prevents...

- Iterator invalidation due to mutating a collection you're iterating over.
- This pattern can be written in C, C++, Java, Python, Javascript...
    - But may result in, e.g, `ConcurrentModificationException` (at runtime!)

```rust
let mut vs = [1,2,3,4];
for v in &vs {
    vs[1] = 3;
    println! ("{}", v);
    // ERROR: cannot borrow `vs` as mutable because
    // it is also borrowed as immutable
}
```

- `pop` needs to borrow `vs` as mutable in order to modify the data.
- But `vs` is being borrowed as immutable by the loop!

---
### Borrowing Prevents...

- Use-after-free
- Valid in C, C++...

```rust
let y: &i32;
{
    let x = 5;
    y = &x; // error: `x` does not live long enough
}
println!("{}", *y);
```

- The full error message:

```
error: `x` does not live long enough
note: reference must be valid for the block suffix following statement
    0 at 1:16
...but borrowed value is only valid for the block suffix
    following statement 0 at 4:18
```

- This eliminates a _huge_ number of memory safety bugs _at compile time_.
- As a side note, this technique of creating a block to limit the scope of a
variable (in this case x) is pretty useful.

---
### Borrowing Prevents...

- Data races in multithreaded environments.
- It checks at compile time if it's safe to share or send a given piece of data.
- Compiler ensures that programm uses necessary synchronization using various primitives: mutexes, atomics, channels, etc.
- NB: data races != race condition.
- Check out TRPL section of ["Fearless Concurrency"](https://doc.rust-lang.org/book/ch16-00-concurrency.html)

---

## Generics with Trait Bounds

- Multiple trait bounds are specified like `T: Clone + Ord`.
- There's no way (yet) to specify [negative trait bounds](https://internals.rust-lang.org/t/pre-rfc-mutually-exclusive-traits/2126).
  - e.g. you can't stipulate that a `T` must not be `Clone`.

```rust
fn digital_write<P: Configure + Output>(p: P, value: usize) {
   p.make_output ();
   if value == 1 {
       p.set ();
   } else {
       p.clear ();
   }
}
```

---
## Generic Types With Trait Bounds

- You can also define structs with generic types and trait bounds.
- Be sure to declare all of your generic types in the struct header _and_ the
  impl block header.
- Only the impl block header needs to specify trait bounds.
    - This is useful if you want to have multiple impls for a struct each with
      different trait bounds

```rust
struct MyDriver<P: Pin> {
    pin1: &'static P,
    pin2: &'static P,
    // ...
}
```

And without trait bounds

```rust
struct MyDriver<P> {
    pin1: &'static P,
    pin2: &'static P,
    // ...
}
```

---
## Generic Types With Trait Bounds

```rust
impl<P: Pin> Driver for MyDriver<P> {
   // ...
}
```

---
## Inheritance (kinda)

- Some traits may require other traits to be implemented first.
    - e.g., `Eq` requires that `PartialEq` be implemented, and `Copy` requires `Clone`.
- Implementing the `Child` trait below requires you to also implement `Parent`.

```rust
trait Parent {
    fn foo(&self) {
        // ...
    }
}

trait Child: Parent {
    fn bar(&self) {
        self.foo();
        // ...
    }
}
```

---
# Lifetimes Annotations

- Lifetimes generally have a pretty steep learning curve.
- Don't worry if you don't understand these right away.

.title[.center[![Din Lac in Put](images/mieuneli_din_lac_in_put.png)]]

---
### Question .top_image[![Questions](../images/question.svg)]

Q1: How do you use free?

```c
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

char * without_first_word (char *s);

int main ()
{
    char * s = strdup ("ana has apples");
    char *wfw = without_first_word (s);
    // free (s);   <-- before printf // possible?
    printf ("%s\n", wfw);
    // free (wfw); <-- after printf  // possible?
}

```

---
### Question .top_image[![Questions](../images/question.svg)]

Q2: How do you use free?

```c
// program: bear-salamander-anteater
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

char * without_first_word (char *s) {
    int pos = 0;
    for (unsigned int i=0; i < strlen (s); i++) {
        if (s[i] != ' ') pos = pos + 1;
        else break;
    }
    return &s[pos];
}

int main ()
{
    char * s = strdup ("ana has apples");
    char *wfw = without_first_word (s);
    // free (s);    <-- before printf // possible?
    printf ("%s\n", wfw);
    // free (wfw);  <-- after printf  // possible?
}

```

---
### Question .top_image[![Questions](../images/question.svg)]

Q3: How do you use free?

```c
// program: oyster-guanaco-dinosaur
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

char * without_first_word (char *s) {
    int pos = 0;
    for (unsigned int i=0; i < strlen (s); i++) {
        if (s[i] != ' ') pos = pos + 1;
        else break;
    }
    return strdup (&s[pos]);
}

int main ()
{
    char * s = strdup ("ana has apples");
    char *wfw = without_first_word (s);
    // free (s);   <-- before printf / possible?
    printf ("%s\n", wfw);
    // free (wfw); <-- before printf / possible?
}

```

---
### Lifetime annotations

From a birds eye view, how should Rust free `s` and `wfw`?

```rust
fn without_first_word<'a> (s: &'a str) -> &'a str;

fn main() {
    let s = String::from("ana has apples"); 
    let wfw = without_first_word (&s);      
    // drop(s); // Is this possible?
    println! ("{}", wfw);                  
    // drop(s); // Is this possible?
}                                         
```

---
### This is why lifetimes are useful.

```rust
fn without_first_word<'a> (s: &'a str) -> &'a str {
    let mut pos = 0;
    for a in s.chars() {
        if a != ' ' { pos = pos + 1; }
        else { break; }
    }
    &s[pos..]
}

fn main() {
    let s = String::from("ana has apples");
    let wfw = without_first_word (&s);
    // drop(s); // possible?
    println! ("{}", wfw);
}
```

---
### Lifetime annotations

```rust
fn without_first_word(_s: &str) -> &str {
    todo!()
}

fn main() {
    let s = String::from("ana has apples");
    let wfw = without_first_word (&s);
    drop(s); // possible?                       
    println! ("{}", wfw);
}
```

---
### Question .top_image[![Questions](../images/question.svg)]

Can we use free for `s1` and `s2` before `printf`?

```c
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

char * smaller (char *s1, char *s2);

int main () {
    char *s1 = strdup ("ip");
    char *s2 = strdup ("workshop");
    char *small = smaller (s1, s2);
    // free (s1); // possible?
    // free (s2); // possible?
    printf ("%s\n", small);
}

```

---
### Multiple Lifetime Parameters

```c
// program: wolverine-mallard-gull
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

char * smaller (char *s1, char *s2) {
    if (strlen(s1) > strlen(s2)) return s2;
    else return s1;
}

```

---
### Multiple Lifetime Parameters

```rust
fn smaller <'a> (s1: &'a str, s2: &'a str) -> &'a str {}

fn main() {
    let s1 = String::from("ip"); 
    let s2 = String::from("workshop"); 
    let small = smaller (&s1, &s2);
    // drop(s1); // possible?
    // drop(s2); // possible?
    println! ("{}", small);                  
}                                          
```

---
### Question .top_image[![Questions](../images/question.svg)]

Why can't we free s2?

```rust
fn append <'a> (s: &'a mut String, n: &'a str) -> &'a str {
    s.push_str (n);
    s
}

fn main() {
    let mut s1 = String::from("ip"); 
    let s2 = String::from(" workshop"); 
    let title = append (&mut s1, &s2);
    drop(s2); // possible?
    println! ("{}", title);                  
}                                          
```
---
### Multiple Lifetime Parameters

We now can free s2.

```rust
fn append <'a, 'b> (s: &'a mut String, n: &'b str) -> &'a str {
    s.push_str (n);
    s
}

fn main() {
    let mut s1 = String::from("ip"); 
    let s2 = String::from(" workshop"); 
    let title = append (&mut s1, &s2);
    drop(s2); // possible?
    println! ("{}", title);                  
}                                          
```

---

# Take a break, and check these out when you can

- Rustlings (https://rustlings.rust-lang.org/)
- PM Rust Part 1 (https://embedded-rust-101.wyliodrin.com/docs/fils_en/lab/00.0)
- PM Rust Part 2 (https://embedded-rust-101.wyliodrin.com/docs/fils_en/lab/00.1)