Rust for Python Developers

print("Hello, world!")

fn main() {
    println!("Hello, world!");
}

name = "Alice"
age = 30
age = 31         # reassign freely
pi = 3.14
is_valid = True

let name = "Alice";      // type inferred as &str
let age = 30;            // inferred as i32
// age = 31;             // compile error! age is immutable

let mut age = 30;        // mut makes it mutable
age = 31;                // now fine

let pi: f64 = 3.14;      // explicit type annotation
let is_valid: bool = true;

x = 5
x = x + 1        # rebinds the same name — there is no second variable
x = "now a str"  # type changes silently; nothing was declared to violate

let x = 5;
let x = x + 1;       // new variable, shadows the old one
let x = "now a str"; // even change the type — this is valid

# Python: one string type
greeting = "hello"
greeting = greeting + " world"   # creates a new string

// &str — a reference to existing string data (like a view/slice)
let s1: &str = "hello";          // lives in the binary, borrowed

// String — owned, heap-allocated, can grow
let mut s2: String = String::from("hello");
s2.push_str(" world");           // mutate in place

// Convert between them
let s3: &str = &s2;              // String → &str (borrow it)
let s4: String = s1.to_string(); // &str  → String (clone into heap)

c = "hello"[0]        # still a str, just length 1
type(c)               # <class 'str'>

let c: char = 'h';               // single quotes = char, double = &str
let c2: char = '🦀';             // 4 bytes, holds any Unicode scalar
let count = "hello".chars().count();   // 5 chars
let bytes = "hello".len();             // 5 bytes — NOT always the same number

buf = [0] * 32        # a list that happens to have 32 items; can grow
buf.append(1)         # now 33 — nothing stops you

let buf: [u8; 32] = [0; 32];     // exactly 32 u8s, on the stack, cannot grow
// buf.push(1);                  // no such method — arrays have fixed length

fn checksum(block: [u8; 32]) -> u8 { /* ... */ }
// checksum(&[0u8; 16]);         // compile error: expected [u8; 32], found [u8; 16]

from typing import NewType

Meters = NewType("Meters", float)
Feet = NewType("Feet", float)

def altitude(m: Meters) -> str: ...

altitude(Feet(1000.0))    # type checker complains; Python runs it happily

struct Meters(f64);        // tuple struct — a genuinely distinct type
struct Feet(f64);

fn altitude(m: Meters) -> String { format!("{} m", m.0) }

// altitude(Feet(1000.0));   // compile error: expected Meters, found Feet
altitude(Meters(305.0));     // and it costs zero bytes at runtime

from typing import NoReturn

def fail(msg: str) -> NoReturn:
    raise ValueError(msg)        # NoReturn is a promise to the checker, not a check

def get(value: int | None) -> int:
    match value:
        case int(n): return n
        case None:   return fail("required")  # a call, not a type — must be returned

fn fail(msg: &str) -> ! {
    panic!("{msg}");          // never returns
}

let x: i32 = match input {
    Some(n) => n,
    None => fail("required"),  // `!` fits where i32 is expected
};

def add(a: int, b: int) -> int:
    return a + b

result = add(3, 4)
print(result)  # 7

fn add(a: i32, b: i32) -> i32 {
    a + b        // no semicolon = implicit return of this expression
}

fn main() {
    let result = add(3, 4);
    println!("{result}");  // 7
}

# explicit early return
def divide(a: float, b: float) -> float:
    if b == 0.0:
        return 0.0           # early return with keyword
    return a / b             # no implicit return — drop `return` and you get None

divide(3, 0)                 # ints pass fine; the annotations are never checked

// explicit early return
fn divide(a: f64, b: f64) -> f64 {
    if b == 0.0 {
        return 0.0;          // early return with keyword
    }
    a / b                    // implicit return
}

from typing import TypeVar

T = TypeVar("T")

def largest(items: list[T]) -> T:
    biggest = items[0]
    for item in items:
        if item > biggest:      # nothing guarantees T supports `>`
            biggest = item
    return biggest

largest([object(), object()])   # TypeError at runtime

// T must implement PartialOrd — enforced here, before any caller exists
fn largest<T: PartialOrd>(items: &[T]) -> &T {
    let mut biggest = &items[0];
    for item in items {
        if item > biggest {     // legal only because of the bound
            biggest = item;
        }
    }
    biggest
}

largest(&[3, 7, 2]);            // compiles a u/i32 version
largest(&["a", "c", "b"]);      // compiles a &str version
// largest(&[some_struct]);     // compile error unless it derives PartialOrd

from typing import Protocol

class DisplayClone(Protocol):                # `Display + Clone` must fuse into one type
    def clone(self) -> "DisplayClone": ...   # __str__ comes free on every object

def describe[T: DisplayClone](item: T) -> str:   # one bound only — no `+`, no `where`
    return f"{item.clone()}"                     # nothing checks clone() until it runs

fn describe<T>(item: T) -> String
where
    T: std::fmt::Display + Clone,
{
    format!("{}", item.clone())
}

BUFFER_SIZE = 8 * 1024        # computed at import time, every run

const fn buffer_size(kb: usize) -> usize {
    kb * 1024
}

const BUF: usize = buffer_size(8);   // evaluated by the compiler
let arr = [0u8; buffer_size(8)];     // usable as an array length — runtime fn can't be

def add_one(x: int) -> int:
    return x + 1

# a function is just an object, like any other
ops = [add_one, lambda x: x * 2]

fn add_one(x: i32) -> i32 { x + 1 }

// fn(i32) -> i32 is a concrete type — a function POINTER, not a closure.
// It can't capture anything, which is exactly what makes it safe to store
// and copy around without a Box or a lifetime.
let op: fn(i32) -> i32 = add_one;
println!("{}", op(5));   // 6

// Mixing fn items with closures needs a common denominator — Fn, see 12. Closures & Iterators
let ops: Vec<Box<dyn Fn(i32) -> i32>> = vec![Box::new(add_one), Box::new(|x| x * 2)];

x = 10
if x > 5:
    print("big")
elif x == 5:
    print("five")
else:
    print("small")

let x = 10;
if x > 5 {
    println!("big");
} else if x == 5 {
    println!("five");
} else {
    println!("small");
}

# Python ternary
label = "even" if x % 2 == 0 else "odd"

// Rust if-expression (much cleaner than ternary)
let label = if x % 2 == 0 { "even" } else { "odd" };

# while
i = 0
while i < 5:
    print(i)
    i += 1

# for range
for i in range(5):
    print(i)

# for over collection
names = ["Alice", "Bob"]
for name in names:
    print(name)

# loop with break and value — not native, use while True
result = None
for i in range(100):
    if i * i > 50:
        result = i
        break

// while
let mut i = 0;
while i < 5 {
    println!("{i}");
    i += 1;
}

// for range (0..5 is exclusive end, 0..=5 is inclusive)
for i in 0..5 {
    println!("{i}");
}

// for over collection
let names = vec!["Alice", "Bob"];
for name in &names {
    println!("{name}");
}

// loop — Rust's infinite loop; can return a value with break
let result = loop {
    i += 1;
    if i * i > 50 {
        break i;         // break with a value — returned from loop
    }
};

# Python — match is a statement, so you assign inside each branch
match status:
    case 200: label = "ok"
    case 404: label = "missing"
# forget a case and nothing complains here — `label` is simply unbound,
# and you find out at the next line with a NameError
print(label)

// Rust — match evaluates to a value
let label = match status {
    200 => "ok",
    404 => "missing",
    _   => "other",     // delete this arm → compile error, not a runtime surprise
};

# Python — needs a temp variable and a function to scope the setup
def _build_config():
    base = load_defaults()
    return base.merge(env_overrides())

config = _build_config()

// Rust — a block is an expression; intermediates stay scoped inside it
let config = {
    let base = load_defaults();
    base.merge(env_overrides())   // last expression, no semicolon = block's value
};
// `base` doesn't exist out here

# Python — no labeled break. You need a flag, an exception, or a helper function.
found = None
for i in range(10):
    for j in range(10):
        if i * j > 20:
            found = (i, j)
            break
    if found:            # the awkward second check
        break

// Rust — name the loop, break it directly
let found = 'outer: loop {
    for i in 0..10 {
        for j in 0..10 {
            if i * j > 20 {
                break 'outer Some((i, j));   // exits the labeled loop with a value
            }
        }
    }
    break None;
};

// `continue 'label` works too — skip to the next outer iteration
'rows: for row in &grid {
    for cell in row {
        if cell.is_invalid() {
            continue 'rows;                  // abandon this row entirely
        }
    }
}

# Python's closest attempts
if (m := PATTERN.match(line)):    # binds, but can't destructure into fields
    print(m.group(1))

while (item := stack.pop() if stack else None) is not None:
    print(item)               # no `while let` — you fake it with a sentinel

user = find_user(id)          # no `let ... else` — guard clauses are manual
if user is None:
    raise ValueError("no such user")

// if let — run the branch only if the pattern matches, binding as it goes
if let Some(name) = maybe_name {
    println!("{name}");
}

// while let — loop as long as the pattern keeps matching
while let Some(top) = stack.pop() {
    println!("{top}");      // drains the stack, no is_empty() check needed
}

// let ... else — bind or diverge. Keeps the happy path unindented.
let Some(user) = find_user(id) else {
    return Err("no such user".into());   // must diverge: return / break / panic
};
println!("{}", user.name);  // `user` is in scope here, zero nesting

import copy

# Rule 1: python has no owner — only names pointing at one object
s1 = "hello"
s2 = s1                            # nothing moves; s1 stays perfectly valid
print(s1, s2)                      # hello hello
print(id(s1) == id(s2))            # True — one object, two names: the aliasing rust removes

# "Copy types" aren't a category here — ints just happen to be immutable
x1 = 5
x2 = x1
print(x1, x2)                      # 5 5

# with a mutable object, that aliasing is what it costs you
a = ["hello"]
b = a                              # still one list, now reachable through two names
b.append("world")
print(a)                           # ['hello', 'world'] — `a` changed and nothing announced it

# copy.deepcopy — the explicit clone, and the only thing here that isn't aliasing
c = copy.deepcopy(a)
print(a is c, a == c)              # False True — different objects, equal contents

# no borrowing: passing an argument just makes a third permanent name
def print_list(items):             # not a borrower — a co-owner, for as long as it likes
    print(items)
def append(items):                 # nothing in the signature admits that this one writes
    items.append("world")

s = ["hello"]                      # no owner, no `mut`, nothing to lend
print_list(s)                      # ['hello']
append(s)                          # no `&mut` at the call site — you find out by reading the body
print(s)                           # ['hello', 'world'] — the caller's list, mutated

// Rule 1: one owner
let s1 = String::from("hello");
let s2 = s1;              // ownership MOVED to s2
// println!("{s1}");      // compile error: s1 no longer valid

// Copy types are the exception — no move happens at all
let x1 = 5;
let x2 = x1;              // x1 is bitwise COPIED, not moved
println!("{x1} {x2}");    // both still valid — i32 implements Copy

// Cloning — like Python's copy.deepcopy
let s1 = String::from("hello");
let s2 = s1.clone();      // deep copy — both s1 and s2 are valid
println!("{s1} {s2}");

// Borrowing — pass a reference, don't transfer ownership
fn print_str(s: &String) {          // s here is a BORROWER — read-only, temporary
    println!("{s}");
}                                   // borrower's scope ends here; nothing is dropped

let s = String::from("hello");      // s here is the OWNER
print_str(&s);                      // lend a borrow to print_str
println!("{s}");                    // s (the owner) still valid — the borrow already ended

// Mutable borrow
fn append(s: &mut String) {         // s here is a BORROWER — exclusive, temporary write access
    s.push_str(" world");
}

let mut s = String::from("hello");  // s here is the OWNER
append(&mut s);                     // lend a mutable borrow — only one allowed at a time
println!("{s}");                    // "hello world" — the owner sees the mutation

# Python: this just works — GC handles it
def process(items):
    result = items          # both point to the same list
    result.append(99)
    return result           # original items also modified!

// Rust: the compiler forces you to be explicit
fn process(items: Vec<i32>) -> Vec<i32> {   // takes ownership
    let mut result = items;
    result.push(99);
    result                                   // returns ownership
}

// Or borrow it instead
fn process_borrow(items: &[i32]) -> Vec<i32> {
    let mut result = items.to_vec();         // make a copy
    result.push(99);
    result
}

# Python — sharing is implicit and free-looking
shared = {"count": 0}
a = shared
b = shared
b["count"] += 1
print(a["count"])         # 1 — a and b are the same object

use std::rc::Rc;
use std::cell::RefCell;

// Rc = shared ownership. RefCell = interior mutability.
let shared = Rc::new(RefCell::new(0));
let a = Rc::clone(&shared);          // refcount 2 — cheap, no deep copy
let b = Rc::clone(&shared);          // refcount 3

*b.borrow_mut() += 1;
println!("{}", a.borrow());          // 1
println!("{}", Rc::strong_count(&shared));  // 3

let cell = RefCell::new(5);
let first = cell.borrow_mut();
// let second = cell.borrow_mut();   // panics: already mutably borrowed

nums = [1, 2, 3, 4, 5]
window = nums[1:4]        # a NEW list — copies the elements
window[0] = 99            # original untouched

let nums = vec![1, 2, 3, 4, 5];
let window: &[i32] = &nums[1..4];   // a VIEW — zero copy, zero allocation
println!("{window:?}");             // [2, 3, 4]

// Because it borrows, the compiler stops you invalidating it:
// nums.push(6);                    // error: cannot borrow `nums` as mutable
println!("{window:?}");             // ...while `window` is still alive

nums = [1, 2, 3]
nums.append(4)
nums.pop()
print(nums[0])
print(len(nums))
nums2 = [x * 2 for x in nums]   # list comprehension

let mut nums: Vec<i32> = vec![1, 2, 3];
nums.push(4);
nums.pop();
println!("{}", nums[0]);
println!("{}", nums.len());

// iterator chain replaces list comprehension
let nums2: Vec<i32> = nums.iter().map(|x| x * 2).collect();

mixed = [1, "two", 3.0, [4], None]   # completely normal

// let mixed = vec![1, "two", 3.0];   // compile error: no single type fits every element

# Closed set — a union alias, but it is documentation: nothing enforces it
Value = int | str | float
mixed: list[Value] = [1, "two", 3.0]

# Open set — the default. Every list already is this; no declaration needed
mixed: list[object] = [1, "two", 3.0]
for item in mixed:              # the two lists are indistinguishable at runtime
    print(item)                 # each element was always a separate heap object

// Closed set of shapes — no extra allocation beyond the Vec, matched exhaustively
enum Value { Int(i32), Text(String), Float(f64) }
let mixed: Vec<Value> = vec![Value::Int(1), Value::Text("two".into()), Value::Float(3.0)];

// Open set — any type implementing the trait, one heap allocation per element
let mixed: Vec<Box<dyn std::fmt::Display>> =
    vec![Box::new(1), Box::new("two"), Box::new(3.0)];
for item in &mixed { println!("{item}"); }

buf = [0, 0, 0, 0, 0]
buf.append(1)          # now 6 — nothing stops you

let buf: [i32; 5] = [0, 0, 0, 0, 0];
let filled: [i32; 5] = [0; 5];    // shorthand: 5 copies of 0

for x in &buf {                   // iterate by reference
    println!("{x}");
}
println!("{}", buf.len());        // 5, known at compile time
// buf.push(1);                   // no such method — length is fixed

nums = [1, 2, 3, 4, 5]
arr = (1, 2, 3, 4, 5)             # tuple — fixed length, still heap-allocated

from_list = nums[1:4]             # a new list, not a view — [2, 3, 4]
from_tuple = arr[1:4]             # a new tuple — copied again
memoryview(b"hello")[1:4]         # the one zero-copy slice: buffers only, not lists

let nums = vec![1, 2, 3, 4, 5];
let arr: [i32; 5] = [1, 2, 3, 4, 5];

let from_vec: &[i32] = &nums[1..4];   // view into the Vec — [2, 3, 4]
let from_arr: &[i32] = &arr[1..4];    // view into the array — same slice type

scores = {"Alice": 100, "Bob": 85}
scores["Charlie"] = 90
print(scores.get("Alice"))
print(scores.get("Dave", 0))     # default value

for name, score in scores.items():
    print(f"{name}: {score}")

use std::collections::HashMap;

let mut scores: HashMap<&str, i32> = HashMap::new();
scores.insert("Alice", 100);
scores.insert("Bob", 85);
scores.insert("Charlie", 90);

println!("{:?}", scores.get("Alice"));     // Some(100)
println!("{}", scores.get("Dave").unwrap_or(&0)); // 0

for (name, score) in &scores {
    println!("{name}: {score}");
}

point = (3, 4)
x, y = point          # destructuring
print(point[0])

let point = (3, 4);
let (x, y) = point;           // destructuring
println!("{}", point.0);      // index access with .0, .1, ...

let mixed = (3, "four", 5.0);  // (i32, &str, f64) — three different types, one tuple

literal = "hello"                # a constant baked into the code object
owned = "".join(["hel", "lo"])   # built on the heap at runtime — same `str` type
borrowed = owned                 # another name for it; there is no view type
back = literal                   # nothing to copy — str is immutable, sharing is free

let literal: &str = "hello";               // baked into the binary
let owned: String = String::from("hello"); // on the heap
let borrowed: &str = &owned;               // view into the String
let back: String = literal.to_string();    // copy into the heap

s = "hello"
s = str(42)
s = f"{a} {b}"
s = "".join(parts)
s = "ab" * 3

let s = "hello";                      // &str
let s = 42.to_string();               // String — via Display
let s = format!("{a} {b}");           // String — the f-string equivalent
let s = parts.concat();               // String — join with nothing
let s = parts.join(", ");             // String — join with a separator
let s = "ab".repeat(3);               // "ababab"

let s = String::new();                // empty, no allocation yet
let s = String::with_capacity(1024);  // pre-allocate — no Python equivalent

s = "x"
a = str(s)           # already a str — str() hands the same object back
b = s[:]             # full slice — the same object again, not a copy
c = "".join([s])     # single-element join — CPython returns it unchanged
d = s                # one str type, so "make it owned" isn't a thing to say

let a = "x".to_string();     // via Display — most common
let b = "x".to_owned();      // via ToOwned — signals "I need ownership"
let c = String::from("x");   // explicit constructor
let d: String = "x".into();  // inferred from the target type

parts = []
for i in range(1000):
    parts.append(str(i))
result = "".join(parts)      # the idiomatic fast path

s = "a"
s += "b"                     # allocates a new string each time

// push_str / push — mutate in place
let mut s = String::new();
s.push_str("hello");
s.push(' ');                     // a single char
s.push_str("world");

// += works on String (takes &str on the right)
let mut s = String::from("a");
s += "b";

// + consumes the left operand — note the & on the right
let a = String::from("foo");
let b = String::from("bar");
let c = a + &b;                  // `a` is MOVED, no longer usable

// format! — clearest for anything non-trivial
let c = format!("{a}{b}");       // both still usable

// Pre-allocate when you know the size — no Python equivalent
let mut s = String::with_capacity(4096);
for i in 0..1000 {
    s.push_str(&i.to_string());  // zero reallocations
}

// collect from an iterator
let s: String = (0..5).map(|i| i.to_string()).collect();   // "01234"

// write! into a String — avoids intermediate allocations
use std::fmt::Write;
let mut s = String::new();
write!(s, "{}-{}", 1, 2).unwrap();

for c in s: ...              # characters
for b in s.encode(): ...     # bytes
for i, c in enumerate(s): ...
for line in s.splitlines(): ...

for c in s.chars() { }               // char — Unicode scalar values
for b in s.bytes() { }               // u8 — raw UTF-8 bytes
for (i, c) in s.char_indices() { }   // (byte offset, char) — NOT 0,1,2,3
for line in s.lines() { }            // &str per line
for word in s.split_whitespace() { } // &str per word

s = "hello"
c = s[0]         # 'h'
c = s[-1]        # 'o'
sub = s[1:3]     # 'el'

let s = "hello";
// let c = s[0];       // COMPILE ERROR — String/&str don't implement Index<usize>

s = "héllo"

len(s)                   # 5 — code points, not bytes and not graphemes
len(s.encode())          # 6 — bytes, only if you go and ask for them

s[0]                     # 'h' — O(1), paid for in memory at build time
s[1]                     # 'é' — O(1) too; the cost is hidden, not absent
s[-1]                    # 'o'

s[0:1]                   # 'h' — code-point indices, so never half a char
s[1:2]                   # 'é' — no panic; a slice can't split a code point
s.encode()[1:2]          # b'\xc3' — half of 'é', silently, no complaint
# s.encode()[1:2].decode()   # UnicodeDecodeError — one step too late

let s = "héllo";

s.len();                    // 6 — bytes, because é is 2 bytes
s.chars().count();          // 5 — characters

s.chars().next();           // Some('h')  — first char
s.chars().nth(1);           // Some('é')  — O(n), and that's visible
s.chars().last();           // Some('o')  — Python's s[-1]

&s[0..1];                   // "h" — fine, byte 1 is a boundary
// &s[1..2];                // PANICS at runtime: byte index 2 is inside 'é'
s.get(1..2);                // None — the non-panicking version

len("é")            # 1 — precomposed é
len("é")           # 2 — e + combining accent, renders identically
len("👨‍👩‍👧")             # 5 — three people plus two zero-width joiners
# no grapheme iterator in the stdlib either: pip install regex, regex.findall(r"\X", s)

// "é" can be one char (U+00E9) or two (e + U+0301 combining accent).
// Emoji like 👨‍👩‍👧 are several chars joined by zero-width joiners.
// s.chars().count() on that emoji returns 5, not 1.
// For user-perceived characters, use the unicode-segmentation crate.

s = "héllo wörld"

# Slices are by code point — always safe, never raise
head = s[0:2]                   # 'hé'
s[0:999]                        # 'héllo wörld' — out of range is clamped

# The dangerous layer is bytes, and it fails one step late
half = s.encode()[0:2]          # b'h\xc3' — the front half of 'é'
# half.decode()                 # UnicodeDecodeError, not at the slice

# Find a real index before slicing
idx = s.find(" ")               # 5 — a char index; Rust's find returns 6, a byte offset
if idx != -1:                   # -1 on failure, not None — easy to slice with by mistake
    first, rest = s[:idx], s[idx:]      # two fresh copies, not views

# Best: partition instead of index arithmetic
key, sep, value = "host=localhost".partition("=")
if sep:
    print(f"{key} -> {value}")

# split with maxsplit works too, but the unpack is the failure mode
key, value = "host=localhost".split("=", 1)   # ValueError on unpack if "=" is absent

# A slice remembers nothing about its parent — no substr_range equivalent
"host=localhost".index(key)     # 0, and only by searching the text over again

let s = "héllo wörld";

// Byte ranges — panics on a non-boundary
let head = &s[0..2];

// Non-panicking
if let Some(head) = s.get(0..2) { }

// Character-based, safely
let first3: String = s.chars().take(3).collect();
let skip2: String = s.chars().skip(2).collect();

// Find a real boundary before slicing
if let Some(idx) = s.find(' ') {
    let (first, rest) = s.split_at(idx);   // idx came from find, so it's valid
}

// Best: split_once instead of index arithmetic
if let Some((key, value)) = "host=localhost".split_once('=') {
    println!("{key} -> {value}");
}

// New in 1.98 — recover a derived slice's byte range within its parent
let s = "host=localhost";
let (key, _) = s.split_once('=').unwrap();
let range = s.substr_range(key);   // Some(0..4) — where `key` sits inside `s`

n = int("42")
f = float("3.14")
try:
    n = int(user_input)
except ValueError:
    n = 0

let n: i32 = "42".parse()?;                     // turbofish alternative:
let n = "42".parse::<i32>()?;                   // parse returns Result
let f: f64 = "3.14".parse()?;

let n: i32 = user_input.parse().unwrap_or(0);   // with a default

match user_input.trim().parse::<i32>() {
    Ok(n) => println!("got {n}"),
    Err(e) => eprintln!("bad number: {e}"),
}

from dataclasses import dataclass

@dataclass
class Point:
    x: int
    y: int

    @classmethod
    def parse(cls, s: str) -> "Point":
        x, sep, y = s.partition(",")
        if not sep:
            raise ValueError("expected x,y")
        return cls(int(x), int(y))   # int() strips space and raises on junk

p = Point.parse("3, 4")              # Point(x=3, y=4)
# no FromStr to dispatch on, so the caller must name Point — nothing
# lets a bare "3, 4".parse() infer the target type from context

use std::str::FromStr;

struct Point { x: i32, y: i32 }

impl FromStr for Point {
    type Err = String;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let (x, y) = s.split_once(',').ok_or("expected x,y")?;
        Ok(Point {
            x: x.trim().parse().map_err(|_| "bad x")?,
            y: y.trim().parse().map_err(|_| "bad y")?,
        })
    }
}

let p: Point = "3, 4".parse()?;

def word_count(text: str) -> int:    # only one string type to pick from
    return len(text.split())

owned = " ".join(["a", "b", "c"])
word_count("a b c")     # 3 — a literal
word_count(owned)       # 3 — a built-up str; same call, nothing coerced
# what the signature can't say: "I only read this, I won't keep it"

// The default — 90% of functions want this
fn word_count(text: &str) -> usize {
    text.split_whitespace().count()
}

word_count("a b c");           // &str — works
word_count(&owned_string);      // String — deref coercion, works

use std::borrow::Cow;

fn sanitize(input: &str) -> Cow<'_, str> {
    if input.contains(' ') {
        Cow::Owned(input.replace(' ', "_"))   // allocate — we changed something
    } else {
        Cow::Borrowed(input)                  // no allocation at all
    }
}

from dataclasses import dataclass

@dataclass
class User:
    id: int
    name: str
    email: str

user = User(id=1, name="Alice", email="[email protected]")
print(user.name)

struct User {
    id: u64,
    name: String,
    email: String,
}

let user = User {
    id: 1,
    name: String::from("Alice"),
    email: String::from("[email protected]"),
};
println!("{}", user.name);

@dataclass
class User:
    id: int
    name: str
    email: str

    def greet(self) -> str:
        return f"Hi, I'm {self.name}"

    @classmethod
    def guest(cls) -> "User":
        return cls(id=0, name="Guest", email="")

struct User {
    id: u64,
    name: String,
    email: String,
}

impl User {
    // associated function (like @classmethod / static method) — no self
    fn guest() -> User {
        User { id: 0, name: String::from("Guest"), email: String::new() }
    }

    // method — takes &self (read-only borrow, like Python's self)
    fn greet(&self) -> String {
        format!("Hi, I'm {}", self.name)
    }

    // mutable method — takes &mut self
    fn rename(&mut self, new_name: &str) {
        self.name = new_name.to_string();
    }
}

let mut user = User::guest();
user.rename("Alice");
println!("{}", user.greet());

# Python — cleanup requires an explicit context manager
class Connection:
    def __enter__(self): return self
    def __exit__(self, *exc): self.close()
    def close(self): print("closed")

with Connection() as c:      # forget `with` and it may never close
    ...

struct Connection { name: String }

impl Drop for Connection {
    fn drop(&mut self) {
        println!("closing {}", self.name);   // runs automatically
    }
}

fn main() {
    let _c = Connection { name: "db".into() };
    // ... use it ...
}   // <- "closing db" prints HERE, always. No with-block, no try/finally.

from dataclasses import dataclass, replace

@dataclass
class Config:
    host: str = "localhost"
    port: int = 8080
    debug: bool = False

base = Config()
prod = replace(base, host="prod.example.com")   # needs dataclasses.replace

#[derive(Default, Clone)]
struct Config {
    host: String,
    port: u16,
    debug: bool,
}

let prod = Config {
    host: "prod.example.com".into(),
    ..Default::default()          // fill every remaining field from Default
};

let staging = Config { debug: true, ..prod.clone() };   // or from another value

class Account:
    def __init__(self, id: int, balance: int) -> None:
        self.id = id
        self._balance = balance    # underscore is a request, not a rule

    @property
    def balance(self) -> int:      # read-only accessor
        return self._balance

a = Account(1, 100)
a._balance          # 100 — the convention stopped nobody
a._balance = -999   # and nothing stops this either
# __balance only mangles the name to _Account__balance — still reachable

mod account {
    pub struct Account {
        pub id: u64,
        balance: i64,          // no `pub` — invisible outside this module
    }

    impl Account {
        pub fn balance(&self) -> i64 { self.balance }   // read-only accessor
    }
}

let a = account::Account { id: 1, balance: 100 };  // compile error: `balance` is private

from enum import Enum

class Direction(Enum):
    NORTH = "north"
    SOUTH = "south"

class Shape(Enum):
    CIRCLE = "circle"
    RECTANGLE = "rectangle"

# Python can't cleanly attach different data per variant

enum Direction {
    North,
    South,
    East,
    West,
}

// Each variant can hold different data
enum Shape {
    Circle { radius: f64 },
    Rectangle { width: f64, height: f64 },
    Triangle(f64, f64, f64),     // unnamed fields (tuple variant)
}

fn area(shape: &Shape) -> f64 {
    match shape {
        Shape::Circle { radius } => std::f64::consts::PI * radius * radius,
        Shape::Rectangle { width, height } => width * height,
        Shape::Triangle(a, b, c) => {
            let s = (a + b + c) / 2.0;
            (s * (s - a) * (s - b) * (s - c)).sqrt()
        }
    }
}

from dataclasses import dataclass
from typing import Union

@dataclass
class Circle:
    radius: float

@dataclass
class Rectangle:
    width: float
    height: float

Shape = Union[Circle, Rectangle]   # not one type — just a type-checker alias

def area(shape: Shape) -> float:
    if isinstance(shape, Circle):
        return 3.14159 * shape.radius ** 2
    # forget the Rectangle branch — mypy may warn, but nothing stops it running,
    # and there's no runtime error until something downstream breaks

// Add a variant to Shape and this stops compiling until every match handles it
fn area(shape: &Shape) -> f64 {
    match shape {
        Shape::Circle { radius } => std::f64::consts::PI * radius * radius,
        Shape::Rectangle { width, height } => width * height,
        // omit Triangle here → compile error, not a maybe-caught type-checker warning
    }
}

def read_file(path: str) -> str:
    try:
        with open(path) as f:
            return f.read()
    except FileNotFoundError:
        return ""
    except PermissionError as e:
        raise RuntimeError(f"Cannot read {path}") from e

# Caller
try:
    content = read_file("data.txt")
except RuntimeError as e:
    print(f"Error: {e}")

use std::fs;

fn read_file(path: &str) -> Result<String, std::io::Error> {
    let content = fs::read_to_string(path)?;  // ? = propagate error up
    Ok(content)
}

// Caller
match read_file("data.txt") {
    Ok(content) => println!("{content}"),
    Err(e) => eprintln!("Error: {e}"),
}

# the verbose form — catch only to hand the error straight back
def read_file(path: str) -> str:
    try:
        with open(path) as f:
            return f.read()
    except OSError:
        raise                        # re-raise: propagate the error

# the form people actually write — propagation is the default
def read_file(path: str) -> str:
    with open(path) as f:
        return f.read()              # an OSError leaves on its own; no `?`, no Ok()

# nothing in the signature mentions OSError, and no caller is forced to look

// Without ? — verbose
fn read_file(path: &str) -> Result<String, std::io::Error> {
    let content = match fs::read_to_string(path) {
        Ok(c) => c,
        Err(e) => return Err(e),   // propagate the error
    };
    Ok(content)
}

// With ? — concise (equivalent to above)
fn read_file(path: &str) -> Result<String, std::io::Error> {
    let content = fs::read_to_string(path)?;
    Ok(content)
}

# Python — just raise with a message
def process(path: str) -> str:
    content = read_file(path)
    if not content:
        raise ValueError("empty file")
    return content.upper()

use anyhow::{Result, bail, Context};

fn process(path: &str) -> Result<String> {
    let content = fs::read_to_string(path)
        .with_context(|| format!("failed to read {path}"))?;

    if content.is_empty() {
        bail!("empty file");           // like raise ValueError
    }

    Ok(content.to_uppercase())
}

def find_user(id: int) -> dict | None:
    users = {1: {"name": "Alice"}}
    return users.get(id)

user = find_user(1)
if user is not None:
    print(user["name"])

# Or with walrus
if user := find_user(2):
    print(user["name"])
else:
    print("not found")

fn find_user(id: u64) -> Option<String> {
    let users = std::collections::HashMap::from([(1u64, "Alice")]);
    users.get(&id).map(|s| s.to_string())
}

match find_user(1) {
    Some(name) => println!("{name}"),
    None => println!("not found"),
}

// Shorter form
if let Some(name) = find_user(2) {
    println!("{name}");
}

// With default
let name = find_user(3).unwrap_or_else(|| String::from("Anonymous"));

# Python — one mechanism, two meanings, indistinguishable from the signature
def withdraw(balance: int, amount: int) -> int:
    if amount > balance:
        raise ValueError("insufficient funds")   # expected — caller should handle
    if balance < 0:
        raise AssertionError("negative balance") # a bug — nobody should catch this
    return balance - amount

fn withdraw(balance: i64, amount: i64) -> Result<i64, String> {
    assert!(balance >= 0, "negative balance: {balance}");  // a BUG — panics

    if amount > balance {
        return Err("insufficient funds".into());          // expected — returned
    }
    Ok(balance - amount)
}
// The signature tells you the only error you must handle is the String.
// The panic isn't in the type — because it's not supposed to happen.

def parse_digit(c: str) -> int:
    match c:
        case d if d.isdigit():
            return int(d)
        case _:
            raise AssertionError(f"parse_digit called with non-digit: {c}")

# also common after a check the type system can't see:
match "a=b".split("=", 1):
    case [key, value]:
        print(key, value)                 # a b
    case _:
        raise AssertionError("split(maxsplit=1) always yields 1 or 2 parts")
# `assert False` is the shorter spelling — and disappears entirely under python -O

fn parse_digit(c: char) -> u32 {
    match c {
        '0'..='9' => c.to_digit(10).unwrap(),
        _ => unreachable!("parse_digit called with non-digit: {c}"),
    }
}

// Also common after a check the type system can't see:
let parts: Vec<&str> = "a=b".splitn(2, '=').collect();
let (key, value) = match parts.as_slice() {
    [k, v] => (k, v),
    _ => unreachable!("splitn(2) always yields 1 or 2 parts"),
};

# Python — a stub body needs no type to line up
def calculate_tax(order: Order) -> Decimal:
    ...                              # or: raise NotImplementedError

fn calculate_tax(order: &Order) -> Decimal {
    todo!("waiting on the rates table")   // type-checks as Decimal. Or as anything.
}

n = int("42")                                        # ValueError on bad input — like .unwrap()
n = int("42")                                        # no reason string to attach: the traceback is all you get
n = int("42") if "42".lstrip("-").isdigit() else 0   # no exception — default, but you guard instead of recover
n = int("42")                                        # no exception — propagate; that's just python's default

let n: i32 = "42".parse().unwrap();                     // panics on bad input
let n: i32 = "42".parse().expect("literal is valid");   // panics with a reason
let n: i32 = "42".parse().unwrap_or(0);                 // no panic — default
let n: i32 = "42".parse()?;                             // no panic — propagate

try:
    raise RuntimeError("boom")
except RuntimeError as e:            # a typed exception, not a Box<dyn Any> to downcast
    print(f"caught: {e}")            # .args, .__traceback__, .__cause__ all still attached
    # raise                          # re-raising here keeps the original traceback

# the bare form is the closer analogue to catch_unwind
try:
    int("boom")
except:                              # == except BaseException — swallows SystemExit too
    pass
finally:
    print("cleanup runs either way") # rust's equivalent is Drop, run as the stack unwinds

use std::panic;

let result = panic::catch_unwind(|| {
    panic!("boom");
});
match result {
    Ok(v) => println!("fine: {v:?}"),
    Err(payload) => {
        // payload is Box<dyn Any> — not a typed exception hierarchy
        if let Some(s) = payload.downcast_ref::<&str>() {
            eprintln!("caught: {s}");
        }
    }
}

from typing import Protocol

class Greetable(Protocol):
    def greet(self) -> str: ...

class User:
    def greet(self) -> str:
        return "Hi from User"

class Bot:
    def greet(self) -> str:
        return "Beep boop"

def print_greeting(thing: Greetable) -> None:
    print(thing.greet())

print_greeting(User())
print_greeting(Bot())

trait Greetable {
    fn greet(&self) -> String;

    // default implementation
    fn loud_greet(&self) -> String {
        self.greet().to_uppercase()
    }
}

struct User { name: String }
struct Bot;

impl Greetable for User {
    fn greet(&self) -> String {
        format!("Hi from {}", self.name)
    }
}

impl Greetable for Bot {
    fn greet(&self) -> String {
        String::from("Beep boop")
    }
}

fn print_greeting(thing: &impl Greetable) {
    println!("{}", thing.greet());
}

print_greeting(&User { name: String::from("Alice") });
print_greeting(&Bot);

@dataclass
class Point:        # __eq__, __repr__ etc. auto-generated
    x: float
    y: float

#[derive(Debug, Clone, PartialEq)]
struct Point {
    x: f64,
    y: f64,
}

let p = Point { x: 1.0, y: 2.0 };
println!("{p:?}");              // Debug: Point { x: 1.0, y: 2.0 }
let p2 = p.clone();
assert_eq!(p, p2);              // PartialEq

# Python: always dynamic. Every call is a runtime dict lookup on the instance.
def print_greeting(thing: Greetable) -> None:
    print(thing.greet())

// STATIC dispatch — compiler generates one copy per concrete type.
// Zero runtime cost, call is inlinable, binary is larger.
fn print_greeting(thing: &impl Greetable) {
    println!("{}", thing.greet());
}

// DYNAMIC dispatch — one copy, method looked up through a vtable pointer.
// Small runtime cost, smaller binary, allows heterogeneous collections.
fn print_greeting_dyn(thing: &dyn Greetable) {
    println!("{}", thing.greet());
}

// dyn is what you need for a mixed collection — the type isn't known statically
let things: Vec<Box<dyn Greetable>> = vec![
    Box::new(User { name: "Alice".into() }),
    Box::new(Bot),
];
for t in &things {
    println!("{}", t.greet());
}

from typing import NamedTuple, Protocol

class User(NamedTuple):
    name: str

class Repository[ItemT](Protocol):        # the item type must be a parameter of the whole protocol
    def get(self, id: int) -> ItemT: ...  # and there is no slot for an error type at all

class UserRepo:
    def get(self, id: int) -> User:
        return User(f"user{id}")

repo: Repository[User] = UserRepo()       # structural — UserRepo never names Repository
print(repo.get(1).name)                   # user1
# Repository[User] is erased at runtime: nothing checks it, nothing dispatches on it

trait Repository {
    type Item;                                  // implementor decides
    type Error;

    fn get(&self, id: u64) -> Result<Self::Item, Self::Error>;
}

struct UserRepo;

impl Repository for UserRepo {
    type Item = User;
    type Error = std::io::Error;

    fn get(&self, id: u64) -> Result<User, std::io::Error> {
        Ok(User { name: format!("user{id}") })
    }
}

trait Describe {
    fn describe(&self) -> String;
}

// Implement Describe for EVERY type that already implements Display
impl<T: std::fmt::Display> Describe for T {
    fn describe(&self) -> String {
        format!("<<{self}>>")
    }
}

println!("{}", 42.describe());        // "<<42>>"
println!("{}", "hi".describe());      // "<<hi>>"

# Python: monkeypatching is allowed, and it's global and invisible
import datetime
datetime.date.today = lambda: "lol"    # every library in the process is affected

// impl Display for Vec<u8> { }   // ERROR: both Display and Vec are foreign

// The sanctioned workaround: your own trait (an "extension trait")
trait Hex {
    fn to_hex(&self) -> String;
}

impl Hex for Vec<u8> {                 // legal — Hex is mine
    fn to_hex(&self) -> String {
        self.iter().map(|b| format!("{b:02x}")).collect()
    }
}

// Or the newtype pattern to make the type yours
struct Bytes(Vec<u8>);
impl std::fmt::Display for Bytes { /* now legal */ }

numbers = [1, 2, 3, 4, 5]

# map / filter
doubled = list(map(lambda x: x * 2, numbers))
evens = list(filter(lambda x: x % 2 == 0, numbers))

# list comprehension (idiomatic Python)
doubled = [x * 2 for x in numbers]
evens = [x for x in numbers if x % 2 == 0]

# reduce
from functools import reduce
total = reduce(lambda acc, x: acc + x, numbers, 0)
total = sum(numbers)

let numbers = vec![1, 2, 3, 4, 5];

// Closures use |args| body syntax
let doubled: Vec<i32> = numbers.iter().map(|x| x * 2).collect();
let evens: Vec<i32> = numbers.iter().filter(|&&x| x % 2 == 0).cloned().collect();

// Chaining (equivalent to nested comprehensions)
let result: Vec<i32> = numbers.iter()
    .filter(|&&x| x % 2 == 0)
    .map(|&x| x * 10)
    .collect();

// fold = reduce
let total: i32 = numbers.iter().fold(0, |acc, x| acc + x);
let total: i32 = numbers.iter().sum();         // shorthand

data = [1, 2, 3]

# Fn — only reads captured state
printer = lambda: print(data)
printer()
printer()                      # fine, called twice

# FnMut — mutates captured state
count = 0
def bump():
    global count               # `nonlocal` in a nested scope; at module level, `global`
    count += 1
bump()
bump()

# FnOnce — no python equivalent
def consume():
    owned = data               # just another name for the same list, not ownership
    print(len(owned))
consume()
consume()                      # runs again happily — nothing was moved out of `data`

let data = vec![1, 2, 3];

// Fn — only reads captured state
let printer = || println!("{data:?}");
printer();
printer();                     // fine, called twice

// FnMut — mutates captured state
let mut count = 0;
let mut bump = || count += 1;   // note: closure itself must be `mut`
bump();
bump();

// FnOnce — consumes what it captures
let consume = move || {
    let owned = data;           // takes ownership of data
    println!("{}", owned.len());
};
consume();
// consume();                   // compile error: value moved in the first call

def apply_twice(f, x):          # Python doesn't care what f captures
    return f(f(x))

fn apply_twice<F: Fn(i32) -> i32>(f: F, x: i32) -> i32 {
    f(f(x))                     // needs Fn — FnOnce wouldn't allow two calls
}

fn run_once<F: FnOnce()>(f: F) {
    f();                        // accepts a closure that consumes its captures
}

# Python: the closure sees the variable, not a copy. Classic late-binding bug:
fns = [lambda: i for i in range(3)]
print([f() for f in fns])      # [2, 2, 2] — all share the same `i`

// Rust: `move` transfers ownership into the closure — each gets its own value
let fns: Vec<Box<dyn Fn() -> i32>> = (0..3)
    .map(|i| Box::new(move || i) as Box<dyn Fn() -> i32>)
    .collect();

let vals: Vec<i32> = fns.iter().map(|f| f()).collect();
// [0, 1, 2] — the late-binding bug is impossible

v: list[int] = list(range(1, 5))              # a list — `list` chose that, not the annotation
s: set[int] = set(range(1, 5))                # a set — a second constructor, named by hand
c: str = "".join(["a", "b", "c"])             # a str — a third, unrelated spelling
r: list[int] = [int(x) for x in ["1", "2"]]   # raises on a bad element; there is no Result to collect into

let v: Vec<i32> = (1..5).collect();                     // a Vec
let s: HashSet<i32> = (1..5).collect();                 // a HashSet
let s: String = ['a', 'b', 'c'].into_iter().collect();  // a String
let r: Result<Vec<i32>, _> = ["1", "2"].iter().map(|x| x.parse()).collect(); // short-circuits on Err

# math_utils.py
def add(a, b):
    return a + b

# main.py
from math_utils import add
import math_utils

add(1, 2)
math_utils.add(1, 2)

// src/math_utils.rs
pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

// src/main.rs
mod math_utils;                // tells Rust to load src/math_utils.rs

use math_utils::add;           // bring into scope
add(1, 2);
math_utils::add(1, 2);         // fully qualified path also works

// Bring multiple items
use std::collections::{HashMap, HashSet};

command = ("move", 10, 20)

match command:
    case ("move", x, y):
        print(f"Move to {x},{y}")
    case ("quit",):
        print("Quit")
    case _:
        print("Unknown")

let command = ("move", 10, 20);

match command {
    ("move", x, y) => println!("Move to {x},{y}"),
    ("quit", ..) => println!("Quit"),
    _ => println!("Unknown"),
}

// Match on enum variants — the most common use
enum Message {
    Move { x: i32, y: i32 },
    Write(String),
    Quit,
}

let msg = Message::Move { x: 10, y: 20 };

match msg {
    Message::Move { x, y } => println!("Move to {x},{y}"),
    Message::Write(text) => println!("Write: {text}"),
    Message::Quit => println!("Quit"),
    // no _ needed — compiler verifies all variants are covered
}

x = 15
match x:
    case n if n < 0:
        print("negative")
    case n if n < 10:
        print("small")
    case _:
        print("big")

let x = 15;
match x {
    n if n < 0 => println!("negative"),
    n if n < 10 => println!("small"),
    _ => println!("big"),
}

# Python needs guards for what Rust does with a range pattern
match n:
    case 0: msg = "zero"
    case 1 | 2 | 3: msg = "small"
    case n if 4 <= n <= 9: msg = "medium"      # `case 4..=9` is a SyntaxError
    case n if 10 <= n <= 99: msg = "large"     # and no `@` binding — rebind manually
    case _: msg = "huge"

let msg = match n {
    0 => "zero",
    1 | 2 | 3 => "small",                  // or-pattern (Python has this)
    4..=9 => "medium",                     // range pattern — no Python equivalent
    big @ 10..=99 => {                     // @ binds the value *while* matching
        println!("two digits: {big}");
        "large"
    }
    _ => "huge",
};

// Struct destructuring with `..` to ignore the rest
struct Config { host: String, port: u16, debug: bool, retries: u8 }

match cfg {
    Config { port: 443, host, .. } => println!("https on {host}"),
    Config { debug: true, .. }     => println!("debug mode"),
    _                              => println!("default"),
}

// Slice patterns — match on length and position
match values.as_slice() {
    []            => println!("empty"),
    [only]        => println!("one: {only}"),
    [first, .., last] => println!("{first} … {last}"),
}

# Python: dangling references are impossible — the GC keeps the object alive
def first_word(s: str) -> str:
    return s.split()[0]      # returns a new string; original may be freed later

word = first_word("hello world")
# `word` is fine no matter what happens to the input

// Rust: returning a reference means the compiler must prove it outlives the call
fn first_word(s: &str) -> &str {           // lifetime elided — only one input
    s.split_whitespace().next().unwrap()   // borrowed FROM s
}

let sentence = String::from("hello world");
let word = first_word(&sentence);
println!("{word}");

// Uncomment BOTH lines and it stops compiling. Both are needed: the drop is
// only rejected because `word` is still read afterwards.
// drop(sentence);        // error[E0505]: cannot move out of `sentence` because it is borrowed
// println!("{word}");    //             ...borrow later used here

// 'a says: the return value lives as long as the SHORTER of x and y
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

let result;
let s1 = String::from("long string");
{
    let s2 = String::from("short");
    result = longest(&s1, &s2);    // error[E0597]: `s2` does not live long enough
}                                  // s2 dropped here while still borrowed...
println!("{result}");              // ...borrow later used here

struct Parser<'a> {
    input: &'a str,      // this Parser cannot outlive the string it borrows
    pos: usize,
}

impl<'a> Parser<'a> {
    fn new(input: &'a str) -> Self {
        Parser { input, pos: 0 }
    }
}

let s: &'static str = "baked into the binary";

import asyncio

async def fetch(url: str) -> str:
    await asyncio.sleep(1)       # simulate I/O
    return f"data from {url}"

async def main():
    results = await asyncio.gather(
        fetch("http://a.com"),
        fetch("http://b.com"),
    )
    print(results)

asyncio.run(main())

use tokio;

async fn fetch(url: &str) -> String {
    tokio::time::sleep(std::time::Duration::from_secs(1)).await;
    format!("data from {url}")
}

#[tokio::main]
async fn main() {
    let (a, b) = tokio::join!(
        fetch("http://a.com"),
        fetch("http://b.com"),
    );
    println!("{a}\n{b}");
}

from multiprocessing import Pool

numbers = list(range(1_000_000))
with Pool(4) as pool:                                  # processes, not threads — the GIL
    total = sum(pool.map(sum, [numbers[i::4] for i in range(4)]))
print(total)                                           # 499999500000, pickled both ways

use rayon::prelude::*;

let numbers: Vec<i64> = (0..1_000_000).collect();
let sum: i64 = numbers.par_iter().sum();  // parallel across all CPU cores

# Python — this compiles, runs, and is WRONG. No tool warns you.
import threading

counter = 0

def bump():
    global counter
    for _ in range(100_000):
        counter += 1      # read-modify-write, not atomic

ts = [threading.Thread(target=bump) for _ in range(4)]
[t.start() for t in ts]
[t.join() for t in ts]
print(counter)            # < 400000, non-deterministically. A real data race.

use std::thread;

let mut counter = 0;

// The naive version DOESN'T COMPILE — the error is the feature
let handles: Vec<_> = (0..4).map(|_| {
    thread::spawn(|| {
        for _ in 0..100_000 {
            counter += 1;    // error[E0597]: `counter` does not live long enough
        }                    // spawn requires 'static — a borrow can't escape into a thread
    })
}).collect();

import threading

counter = 0
lock = threading.Lock()

def work():
    global counter                       # no shared ownership — just module scope
    for _ in range(100_000):
        with lock:                       # drop this line and it still runs
            counter += 1

threads = [threading.Thread(target=work) for _ in range(4)]
for t in threads: t.start()
for t in threads: t.join()
print(counter)                           # 400000 — only because we remembered the lock

use std::sync::{Arc, Mutex};
use std::thread;

let counter = Arc::new(Mutex::new(0));       // Arc = shared, Mutex = synchronised

let handles: Vec<_> = (0..4).map(|_| {
    let counter = Arc::clone(&counter);      // each thread gets its own handle
    thread::spawn(move || {
        for _ in 0..100_000 {
            *counter.lock().unwrap() += 1;   // lock, mutate, auto-unlock on drop
        }
    })
}).collect();

for h in handles { h.join().unwrap(); }
println!("{}", *counter.lock().unwrap());    // exactly 400000, every time

lock = threading.Lock()
counter = 0

with lock:
    counter += 1        # correct

counter += 1            # ALSO legal — the lock is advisory, nothing enforces it

let counter = Mutex::new(0);
// *counter += 1;                 // impossible — the i32 lives INSIDE the Mutex
*counter.lock().unwrap() += 1;    // the only way in is through the lock

# test_math.py
import pytest

def add(a, b):
    return a + b

def test_add():
    assert add(2, 3) == 5

def test_add_negative():
    assert add(-1, 1) == 0

def test_raises():
    with pytest.raises(TypeError):
        add("a", 1)

fn add(a: i32, b: i32) -> i32 {
    a + b
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_add() {
        assert_eq!(add(2, 3), 5);
    }

    #[test]
    fn test_add_negative() {
        assert_eq!(add(-1, 1), 0);
    }

    #[test]
    #[should_panic]
    fn test_panics() {
        panic!("this is expected");
    }
}

name = "Alice"
score = 42
pi = 3.14159

print(f"Name: {name}")
print(f"Score: {score:>10}")       # right-align, width 10
print(f"Pi: {pi:.2f}")             # 2 decimal places
print(f"{name!r}")                 # repr

let name = "Alice";
let score = 42;
let pi = 3.14159_f64;

println!("Name: {name}");
println!("Score: {score:>10}");    // right-align, width 10
println!("Pi: {pi:.2}");           // 2 decimal places
println!("{name:?}");              // Debug format (like repr)

// Named args
println!("{val:.2}", val = pi);

// Padding and fill
println!("{:0>5}", 42);            // "00042"
println!("{:-<10}", "hi");         // "hi--------"

use core::fmt::NumBuffer;

let mut buf = NumBuffer::new();
let s: &str = 42i32.format_into(&mut buf);   // borrows from buf — no heap allocation
println!("{s}");

# Python: integers are arbitrary precision
x = 10 ** 100    # works fine

// Rust: integers have fixed size — overflow panics in debug, wraps in release
let x: u8 = 255;
// let y = x + 1;    // panics in debug mode!

// Use checked/wrapping/saturating arithmetic explicitly
let y = x.checked_add(1);          // Option<u8> — None on overflow
let y = x.wrapping_add(1);         // wraps to 0
let y = x.saturating_add(1);       // stays at 255

x = 1 + 1.5      # Python auto-converts int to float

let x = 1_i32;
// let y = x + 1.5;    // compile error: mismatched types
let y = x as f64 + 1.5;            // explicit cast required

s = "hello"
c = s[0]         # 'h'

let s = "hello";
// let c = s[0];        // compile error!
let c = s.chars().nth(0);          // Option<char>
let c = &s[0..1];                  // byte slice — unsafe for multibyte chars

a = [1, 2, 3]
b = a              # both point to same list

let a = vec![1, 2, 3];
let b = a;                          // a is MOVED into b — a is gone
// println!("{:?}", a);             // compile error

let a = vec![1, 2, 3];
let b = a.clone();                  // explicit copy — both valid

# Python: *args is free
def log(fmt, *args):
    print(fmt.format(*args))

log("{} + {} = {}", 1, 2, 3)
log("{}", 1)

println!("{}", 1);
println!("{} + {} = {}", 1, 2, 3);      // same macro, different arity

"{} {}".format(1)          # IndexError — at runtime, in production

println!("{} {}", 1);      // COMPILE ERROR: 2 placeholders, 1 argument

@dataclass          # runtime: builds methods when the class is defined
class Point:
    x: float
    y: float

#[derive(Debug, Clone, PartialEq)]   // compile time: generates impl blocks
struct Point { x: f64, y: f64 }

macro_rules! square {
    ($x:expr) => {           // pattern  =>  expansion
        $x * $x
    };
}

let n = square!(3 + 1);      // expands to (3 + 1) * (3 + 1)  =  16

macro_rules! print_all {
    ( $( $item:expr ),* ) => {
        $(                              // repeat this block per item
            println!("{}", $item);
        )*
    };
}

print_all!("a", 1, true);       // three println! calls

macro_rules! my_vec {
    () => { Vec::new() };                       // empty case
    ($elem:expr; $n:expr) => {                  // my_vec![0; 10]
        vec![$elem; $n]
    };
    ($( $item:expr ),+ $(,)?) => {{             // my_vec![1, 2, 3]
        let mut v = Vec::new();
        $( v.push($item); )+
        v
    }};
}

macro_rules! make_temp {
    () => { let tmp = 99; };
}

let tmp = 1;
make_temp!();          // introduces a *different* tmp
println!("{tmp}");     // 1 — the caller's tmp is untouched

scores = {                          # dict literal — grammar, not a macro
    "Alice": 100,
    "Bob": 85,
}

# the ":" separator is baked into the parser; you cannot invent your own
scores = dict(Alice=100, Bob=85)    # or the constructor, keys limited to identifiers
scores = {**scores, "Carol": 92}    # or unpack into a fresh dict

nums = [1, 2, 3]                    # and [] is why Python never needed a vec! either

macro_rules! hashmap {
    ( $( $key:expr => $val:expr ),* $(,)? ) => {{
        let mut m = std::collections::HashMap::new();
        $( m.insert($key, $val); )*
        m
    }};
}

let scores = hashmap!{
    "Alice" => 100,
    "Bob"   => 85,
};

import time, functools

def timed(fn):                       # runtime wrapper
    @functools.wraps(fn)
    def inner(*args, **kwargs):
        start = time.perf_counter()
        try:
            return fn(*args, **kwargs)
        finally:
            print(f"{fn.__name__}: {time.perf_counter() - start:.3f}s")
    return inner

@timed
def load_data(): ...

macro_rules! timed {
    ($label:expr, $body:block) => {{
        let start = std::time::Instant::now();
        let result = $body;
        println!("{}: {:?}", $label, start.elapsed());
        result                        // the block's value passes through
    }};
}

let data = timed!("load_data", {
    expensive_call()
});

from typing import Protocol

class Describe(Protocol):
    def describe(self) -> str: ...

def impl_describe(cls, name):        # a "macro" that can only run at runtime
    cls.describe = lambda self: f"{name} value: {self}"

class Integer(int): pass    # int itself rejects the patch:
class Float(float): pass    # "cannot set attribute of immutable type 'int'"

for cls, label in [(Integer, "integer"), (Float, "float")]:
    impl_describe(cls, label)

def show(d: Describe) -> None:
    print(d.describe())

show(Integer(7))            # integer value: 7
show(Float(2.5))            # float value: 2.5

# nothing verified either class satisfies Describe — the impl is a dict write,
# and bool is not an acceptable base type, so it cannot receive one at all

trait Describe {
    fn describe(&self) -> String;
}

macro_rules! impl_describe {
    ( $( $t:ty => $name:expr ),* $(,)? ) => {
        $(
            impl Describe for $t {
                fn describe(&self) -> String {
                    format!("{} value: {}", $name, self)
                }
            }
        )*
    };
}

impl_describe! {
    i32 => "integer",
    f64 => "float",
    bool => "boolean",
}

from dataclasses import dataclass

@dataclass(frozen=True)      # __repr__, __eq__, __hash__ — built at class-creation time
class UserId:
    value: int = 0           # the Default; the annotation itself is never enforced

#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
struct UserId(u64);

from pydantic import BaseModel, Field

class Config(BaseModel):
    host: str
    port: int = 8080                                 # same role as serde's default
    debug: bool = Field(alias="debugMode")           # rename on the wire
    internal: str = Field(default="", exclude=True)  # skipped on the way out

raw = '{"host": "localhost", "debugMode": true}'
cfg = Config.model_validate_json(raw)                # parse and validate in one step
print(cfg.port, cfg.debug)                           # 8080 True
print(cfg.model_dump())                              # internal never appears

# Config is a real runtime object, rebuilding validators for every call

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize, Debug)]
struct Config {
    host: String,
    #[serde(default = "default_port")]      // helper attributes configure it
    port: u16,
    #[serde(rename = "debugMode")]
    debug: bool,
    #[serde(skip)]
    internal: String,
}

fn default_port() -> u16 { 8080 }

let cfg: Config = serde_json::from_str(raw)?;   // parse and validate in one step

import argparse

parser = argparse.ArgumentParser(description="Process some files")
parser.add_argument("--version", action="version", version="1.0.0")
parser.add_argument("path", help="Input path")          # a string arg, not a doc comment
parser.add_argument("-w", "--workers", type=int, default=4)
parser.add_argument("--dry-run", action="store_true")   # dest becomes args.dry_run

args = parser.parse_args(["in.txt", "--dry-run"])       # parser assembled imperatively
print(args.path, args.workers, args.dry_run)            # in.txt 4 True

args = parser.parse_args(["in.txt", "-w", "8"])
print(args.workers, args.dry_run)                       # 8 False

# args is a plain Namespace built at runtime — no struct, no fields, and
# args.typo is an AttributeError you find when you first hit that branch

use clap::Parser;

#[derive(Parser)]
#[command(version, about = "Process some files")]
struct Args {
    /// Input path                      <- doc comment becomes the help text
    path: String,

    #[arg(short, long, default_value_t = 4)]
    workers: usize,

    #[arg(long)]
    dry_run: bool,
}

let args = Args::parse();       // full CLI, parsed and type-checked

class Password:
    def __init__(self, value: str):
        self.value = value

    def __repr__(self) -> str:      # __repr__ is the Debug analogue
        return "Password(***)"      # @dataclass would have printed the secret

p = Password("hunter2")
print(f"{p!r}")                     # Password(***)
print(p.value)                      # hunter2 — still there, just not in the logs

struct Password(String);

// Derived Debug would print the password into your logs. Don't.
impl std::fmt::Debug for Password {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "Password(***)")
    }
}

import asyncio

async def main(): ...

asyncio.run(main())          # a call you make at run time, not an annotation

def test_it_works(): ...     # pytest finds it by name, at collection time

# and nothing gates tests out of the build — they are ordinary code that always ships

#[tokio::main]              // rewrites async main into a sync main + runtime setup
async fn main() { }

#[test]                     // registers the fn with the test harness
fn it_works() { }

#[cfg(test)]                // built in, not a proc macro — see §23
mod tests { }

// Validates the SQL against your real schema — at compile time.
let user = sqlx::query_as!(User, "SELECT id, name FROM users WHERE id = $1", id)
    .fetch_one(&pool)
    .await?;

// Embeds file contents into the binary. No runtime I/O, no missing-file error.
const SCHEMA: &str = include_str!("../schema.sql");
const LOGO: &[u8] = include_bytes!("../logo.png");

// Reads an environment variable during compilation.
const VERSION: &str = env!("CARGO_PKG_VERSION");

# no matches! needed — a comparison is already a bool, and match is a statement
is_digit = c.isdigit()
if isinstance(msg, Quit): return

# no dbg! either — print() returns None, so walrus keeps the value in the expression
total = (subtotal_tax := subtotal + tax) * quantity
print(f"{subtotal_tax = }")            # subtotal_tax = 42

// matches! — because Rust's `match` is an expression, not a bool
let is_digit = matches!(c, '0'..='9');
if matches!(msg, Message::Quit) { return; }

// dbg! — returns its argument, so wrap an expression without restructuring
let total = dbg!(subtotal + tax) * quantity;
// prints: [src/main.rs:12] subtotal + tax = 42

#[macro_export]          // makes it available as crate::my_macro
macro_rules! my_macro { () => {}; }

import ctypes

x = ctypes.c_int(5)
p = ctypes.pointer(x)         # a real pointer — but from an FFI library, not the language
p.contents.value += 1         # deref is plain attribute access; nothing marks it dangerous
print(x.value)                # 6
# closest analogue, not an equivalent: there is no checked region here to opt out of

let mut x = 5;
let p = &mut x as *mut i32;       // creating a raw pointer is SAFE

unsafe {
    *p += 1;                      // dereferencing it needs unsafe
}
println!("{x}");                  // 6

# Python's escape hatch: ctypes / cffi / a C extension module
import ctypes
libc = ctypes.CDLL("libc.so.6")
libc.abs(-42)                     # no type safety whatsoever

// Rust's FFI — declare the signature, call inside unsafe
unsafe extern "C" {
    fn abs(input: i32) -> i32;
}

let n = unsafe { abs(-42) };      // 42

pub fn split_at_mut(slice: &mut [i32], mid: usize) -> (&mut [i32], &mut [i32]) {
    assert!(mid <= slice.len());              // check the invariant ourselves
    let len = slice.len();
    let ptr = slice.as_mut_ptr();
    unsafe {
        (
            std::slice::from_raw_parts_mut(ptr, mid),
            std::slice::from_raw_parts_mut(ptr.add(mid), len - mid),
        )
    }
}
// Callers never write `unsafe` — the guarantee is restored at the boundary.

import sys

if sys.platform == "win32":
    def config_dir(): return "C:\\ProgramData"
else:
    def config_dir(): return "/etc"
# both branches parse and ship on every platform

#[cfg(target_os = "windows")]
fn config_dir() -> &'static str { "C:\\ProgramData" }

#[cfg(not(target_os = "windows"))]
fn config_dir() -> &'static str { "/etc" }
// only one version exists in the compiled binary

#[cfg(debug_assertions)]
fn log_internal(msg: &str) { eprintln!("[dbg] {msg}"); }

#[cfg(test)]
mod tests { }                     // you've already seen this one in §18

#[cfg(all(unix, target_arch = "x86_64"))]
fn fast_path() { }                // combinators: all / any / not

# pyproject.toml equivalent
[project.optional-dependencies]
postgres = ["asyncpg"]

# Cargo.toml
[features]
default = ["json"]
json = ["serde", "serde_json"]
postgres = ["sqlx"]

[dependencies]
serde = { version = "1", optional = true }
serde_json = { version = "1", optional = true }
sqlx = { version = "0.7", optional = true }

try:
    import orjson              # extras: pyproject.toml json = ["orjson"]
except ImportError:
    orjson = None              # checked at run time; the body below parses either way

def to_json(self): return orjson.dumps(self).decode()
# to_json(obj) → AttributeError: 'NoneType' object has no attribute 'dumps'

#[cfg(feature = "json")]
pub fn to_json(&self) -> String {
    serde_json::to_string(self).unwrap()
}
// Build without --features json and this method does not exist.

# Deployment: ship source + an interpreter + a resolved dependency tree
FROM python:3.14-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt      # ~50-150 MB image, needs Python present
COPY . .
CMD ["python", "app.py"]

# Deployment: ship one file
FROM rust:1 AS build
WORKDIR /src
RUN rustup target add x86_64-unknown-linux-musl   # static link — nothing to ship alongside
COPY . .
RUN cargo build --release --target x86_64-unknown-linux-musl

FROM scratch                             # literally an empty image
COPY --from=build /src/target/x86_64-unknown-linux-musl/release/app /app
CMD ["/app"]                             # ~5-15 MB, no interpreter, no deps

def connect(host, port=5432, *, timeout=30, retries=3, **extra):
    ...

connect("db.local", timeout=5)      # skip what you don't care about

// 1. Separate constructors for the common cases
impl Client {
    fn new(host: &str) -> Self { /* defaults */ }
    fn with_timeout(host: &str, timeout: u64) -> Self { }
}

// 2. A config struct plus Default (closest to keyword args)
#[derive(Default)]
struct Options { timeout: u64, retries: u8 }

Client::connect("db.local", Options { timeout: 5, ..Default::default() });

// 3. The builder pattern (what real crates do)
Client::builder()
    .host("db.local")
    .timeout(5)
    .build()?;

// 4. Macros, for genuine variadics — see §21