rust-lesekreis/session-2025-04-11.md

2025-04-11

Understanding Ownership

take

fn main() {
    let mut s1 = String::from("Hello");
    let s2 = s1.clone();
    
    s1.push_str(" World!");

    takes_ownership(s1);
}

fn takes_ownership(some_string: String) {
    println!("taken: {some_string}");
}

• Ownership um GC zu vermeiden!
  • pass gut zu DDD Aggregaten
  • Das Problem der Heap-Speicher-Fragmentierung bleibt. Wie löst Rust das?

borrow

fn main() {
    let mut s1 = String::from("Hello");
    
    borrow_ownership(&mut s1);

    println!("s1: {s1}");
}

fn borrow_ownership(some_string: &mut String) {
    some_string.push_str(" do illegal things!");
    println!("borrowed: {some_string}");
}

• Borrow == by reference
  • Was passiert, wenn der Eigentümer nebenläufig den Wert ändert?
• Scope == Stack?
  • Gibts in Rust weniger StackOverflows bei Rekursion?

slice

fn main() {
    let mut s4 = String::from("hello world");
    let s4a = &s4[0..5];
    //s4 = s4.replace(" world", "xworld");

    println!("s4: {s4}\ns4a: -{s4a}-");
}

• &String und &str ist jetzt nicht intuitiv ...

• Kann man borrow zurückgeben?

• nicht erlaubt:

let mut s = String::from("hello");

let r1 = &s;
let r2 = &s;
let r3 = &mut s; // Das ist nicht erlaubt

println!("{}, {}, and {}", r1, r2, r3);

• erlaubt:

let mut s = String::from("hello");

let r1 = &s;
let r2 = &s;
println!("{r1} and {r2}");

let r3 = &mut s;
println!("{r3}");

Structs

Vererbung

#[derive(Debug)]
struct User {
    id: u64,
    name: String,
}

let user2 = User {
    email: String::from("another@example.com"),
    ..user1
};

Wie werden Defaults in structs definiert?

You can implement traits for types you didn't define [yourself], whereas interfaces can only be implemented for your own classes.

struct Color(i32, i32, i32);
struct Point(i32, i32, i32);

fn main() {
    let black = Color(0, 0, 0);
    let origin = Point(0, 0, 0);
    
    let Point(x, y, z) = point
}

Constructor

impl Rectangle {
    fn square(size: u32) -> Self {
        Self {
            width: size,
            height: size,
        }
    }
}

Enums

enum IpAddr {
    V4(u8, u8, u8, u8),
    V6(String),
}

if let:

let config_max = Some(3u8);
if let Some(max) = config_max {
    println!("The maximum is configured to be {max}");
} else  {
    println!("There is no maximum");
}

let else:

fn describe_state_quarter(coin: Coin) -> Option<String> {
    let Coin::Quarter(state) = coin else {
        return None; 
    };

    if state.existed_in(1900) { // <--- WTF das kommt aus einer Klammer? Was falsch bei euch?
        Some(format!("{state:?} is pretty old, for America!"))
    } else {
        Some(format!("{state:?} is relatively new."))
    }
}