2010 Rust：消滅段錯誤的百年之戰#

fn main() {
    let s = String::from("hello");  // s 擁有這塊字串
    takes_ownership(s);             // 所有權被 move 走
    // println!("{}", s);           // 編譯錯誤！s 已不再有效
}

fn takes_ownership(s: String) {
    println!("{}", s);
}   // s 離開作用域，記憶體自動釋放，無 GC 也無洩漏

fn main() {
    let mut v = vec![1, 2, 3];
    let first = &v[0];          // 不可變借用
    v.push(4);                  // 可變借用（push 需要 &mut self）
    // println!("{}", first);   // 編譯錯誤！push 可能導致重新配置，
    //                          // first 變成懸垂指標——借用檢查器擋下了它
}

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

#[derive(Debug)]
struct Point { x: i32, y: i32 }

fn dist_from_origin(p: &Point) -> f64 {   // 借用，不奪走所有權
    ((p.x * p.x + p.y * p.y) as f64).sqrt()
}

fn bump(p: &mut Point) {                  // 可變借用
    p.x += 1;
    p.y += 1;
}

fn main() {
    let mut p = Point { x: 3, y: 4 };     // p 擁有 Point
    println!("{}", dist_from_origin(&p)); // 5.0，借用後 p 仍有效
    bump(&mut p);                         // 可變借用
    println!("{:?}", p);                  // Point { x: 4, y: 5 }

    // 所有權 move：
    let q = p;
    // println!("{:?}", p);  // 編譯錯誤：p 的所有權已 move 給 q
    println!("{:?}", q);

    // 模式匹配（承襲 ML 血統）：
    let opt: Option<i32> = Some(42);
    match opt {
        Some(n) => println!("got {}", n),
        None    => println!("nothing"),
    }
}

# 模擬 Rust 借用檢查器：追蹤每個作用域內的借用狀態
class BorrowError(Exception): pass

class BorrowChecker:
    def __init__(self):
        self.immutable_borrows = 0
        self.mutable_borrow = False
        self.owner_alive = True

    def borrow_imm(self):
        if self.mutable_borrow:
            raise BorrowError(
                "cannot borrow as immutable: mutable borrow in scope")
        self.immutable_borrows += 1

    def borrow_mut(self):
        if self.mutable_borrow or self.immutable_borrows > 0:
            raise BorrowError(
                "cannot borrow as mutable: other borrows in scope")
        self.mutable_borrow = True

    def drop_scope(self):
        self.immutable_borrows = 0
        self.mutable_borrow = False

ck = BorrowChecker()
ck.borrow_imm(); ck.borrow_imm()   # 兩個不可變借用：OK
print("two immutable borrows: OK")
ck.drop_scope()
ck.borrow_mut()                    # 一個可變借用：OK
print("one mutable borrow: OK")
ck.drop_scope()
ck.borrow_imm()
try:
    ck.borrow_mut()                # 不可變存在時的可變借用：拒絕
except BorrowError as e:
    print("BorrowError:", e)

class Owner:
    def __init__(self, name):
        self.name = name
        print(f"  alloc {self.name}")

    def __del__(self):
        print(f"  free  {self.name}")

def move_demo():
    print("scope A:")
    a = Owner("p")
    b = a                 # move：a 失效，所有權轉給 b
    a = None
    print("  a moved to b")
    print("scope B (nested):")
    def inner():
        c = Owner("q")
        return            # c 離開作用域即釋放——靜態可預測
    inner()
    print("end of move_demo, b will drop")

move_demo()