Rust Basics

// Rule 1: Each value has one owner
let s1 = String::from("hello");

// Rule 2: Only one owner at a time
let s2 = s1;         // s1 is MOVED to s2
// println!("{}", s1); ← error! s1 invalid

// Rule 3: Owner drops → value freed
{
    let s = String::from("hi");
}  // s is dropped here — memory freed

// Clone — deep copy (heap types)
let s1 = String::from("hello");
let s2 = s1.clone();  // s1 still valid

// Copy — stack types auto-copy
// i32, f64, bool, char, (i32, i32)
let x = 5;
let y = x;      // x still valid — copied
println!("{} {}", x, y);  // 5 5 ✓

fn takes_ownership(s: String) {
    println!("{}", s);
}  // s dropped here

let s1 = String::from("hi");
takes_ownership(s1);
// s1 no longer valid here!

// Return to give ownership back
fn gives_back(s: String) -> String {
    s   // ownership moved to caller
}

fn length(s: &String) -> usize {
    s.len()  // borrows, doesn't own
}

let s1 = String::from("hello");
let len = length(&s1);   // pass reference
println!("{} len={}", s1, len);
// s1 still valid! ✓

// Many immutable refs at once — ok
let r1 = &s1;
let r2 = &s1;  // ✓ allowed

fn append(s: &mut String) {
    s.push_str(", world");
}

let mut s = String::from("hello");
append(&mut s);
println!("{}", s);  // hello, world

// RULE: only ONE &mut at a time
let r1 = &mut s;
// let r2 = &mut s; ← compile error!

// Can't mix & and &mut
let r1 = &s;
// let r2 = &mut s; ← error!

struct User {
    username: String,
    email:    String,
    active:   bool,
    sign_ins: u64,
}

let mut user1 = User {
    username: String::from("alice"),
    email:    String::from("a@b.com"),
    active:   true,
    sign_ins: 1,
};
user1.email = String::from("new@b.com");

impl User {
    // &self — immutable method
    fn greet(&self) -> String {
        format!("Hi {}!", self.username)
    }
    // &mut self — mutable method
    fn login(&mut self) {
        self.sign_ins += 1;
    }
    // Associated function (no self)
    fn new(name: &str) -> User {
        User { username: name.to_string(),
               email: String::new(),
               active: true, sign_ins: 0 }
    }
}
// Struct update syntax
let user2 = User {
    email: String::from("x@y.com"),
    ..user1   // rest from user1
};

let n = 3;
match n {
    1         => println!("one"),
    2 | 3     => println!("two or three"),
    4..=10   => println!("4 to 10"),
    _         => println!("other"),
}

// match is an expression
let msg = match n {
    1 => "one",
    2 => "two",
    _ => "other",
};

let config: Option<u8> = Some(7);

// if let — single pattern match
if let Some(val) = config {
    println!("config is {val}");
}

// while let — loop while pattern matches
let mut stack = vec![1,2,3];
while let Some(top) = stack.pop() {
    println!("{top}");  // 3, 2, 1
}

// Destructure in match
let point = (3, -5);
match point {
    (0, 0)  => println!("origin"),
    (x, 0)  => println!("x-axis at {x}"),
    (0, y)  => println!("y-axis at {y}"),
    (x, y)  => println!("({x},{y})"),
}

// Create
let mut v: Vec<i32> = Vec::new();
let mut v = vec![1, 2, 3];

// Push & pop
v.push(4);           // [1,2,3,4]
v.pop();            // Some(4)

// Access
v[0]                // 1 — panics if OOB
v.get(0)           // Some(&1) — safe
v.len()            // 3

// Iterate
for i in &v { println!("{i}"); }
for i in &mut v { *i *= 2; }

// &str — string slice (immutable, borrowed)
let s: &str = "hello";   // stored in binary

// String — heap-allocated, growable
let mut s = String::from("hello");
s.push_str(", world");
s.push('!');
s.len()             // bytes, not chars
s.is_empty()        // bool
s.contains("world")  // bool
s.to_uppercase()    // new String

// &String auto-coerces to &str
fn greet(s: &str) {}
greet(&s);           // ✓ deref coercion

trait Summary {
    // Required method
    fn summarise(&self) -> String;

    // Default method
    fn preview(&self) -> String {
        format!("{}...", self.summarise())
    }
}

struct Article { title: String }

impl Summary for Article {
    fn summarise(&self) -> String {
        self.title.clone()
    }
}

// impl Trait syntax (simple)
fn notify(item: &impl Summary) {
    println!("{}", item.summarise());
}

// Trait bound syntax (generic)
fn notify<T: Summary>(item: &T) {
    println!("{}", item.summarise());
}

// Multiple bounds
fn show<T: Summary + Display>(t: &T) {}

// where clause (cleaner)
fn show<T>(t: &T)
where T: Summary + Display
{}

// Output
println!("Hello, {}!", "world");
println!("{x} {y}");            // captured vars
println!("{:?}", some_struct);  // Debug format
eprintln!("error: {}", msg);    // stderr

// Collections
let v = vec![1, 2, 3];

// String formatting
let s = format!("Hi {}!", name);

// Assertions (testing & debug)
assert!(x == 5);
assert_eq!(x, 5);
assert_ne!(x, 0);

// Panic
panic!("something went wrong");

// Unimplemented placeholder
todo!();
unimplemented!();