Rust

fn main() {
    println!("Hello, world!");
    println!("x = {}", 42);        // Formatted
    println!("{:?}", vec![1, 2]);  // Debug format
}

let x = 5;                    // Immutable
let mut y = 10;               // Mutable
y = 15;                       // Ok

const MAX: u32 = 100;         // Constant
static GLOBAL: &str = "hi";   // Static

// Integers
let a: i32 = -42;             // Signed 32-bit
let b: u64 = 100;             // Unsigned 64-bit

// Floats
let c: f64 = 3.14;

// Boolean
let d: bool = true;

// Character
let e: char = 'z';

// String
let s: &str = "hello";        // String slice
let s: String = String::from("hello");

fn add(x: i32, y: i32) -> i32 {
    x + y                     // No semicolon = return
}

fn nothing() {
    println!("No return");
}

// Multiple returns with tuple
fn swap(x: i32, y: i32) -> (i32, i32) {
    (y, x)
}

let number = 6;

if number % 2 == 0 {
    println!("even");
} else {
    println!("odd");
}

// If as expression
let result = if number > 5 { "big" } else { "small" };

// Infinite loop
loop {
    println!("forever");
    break;                    // Exit loop
}

// While loop
while number < 10 {
    number += 1;
}

// For loop
for i in 0..5 {              // Range 0 to 4
    println!("{}", i);
}

for item in &vec![1, 2, 3] {
    println!("{}", item);
}

let number = 3;

match number {
    1 => println!("one"),
    2 | 3 => println!("two or three"),
    4..=6 => println!("four through six"),
    _ => println!("something else"),  // Catch-all
}

// Match as expression
let description = match number {
    1 => "one",
    _ => "other",
};

// if let - pattern matching shorthand
let some_value = Some(3);

if let Some(x) = some_value {
    println!("Got: {}", x);
} else {
    println!("No value");
}

// More concise than:
// match some_value {
//     Some(x) => println!("Got: {}", x),
//     None => println!("No value"),
// }

// while let - loop with pattern matching
let mut stack = vec![1, 2, 3];

while let Some(top) = stack.pop() {
    println!("{}", top);
}

// Process values until None
let mut optional = Some(0);
while let Some(i) = optional {
    if i > 5 {
        optional = None;
    } else {
        optional = Some(i + 1);
    }
}

let s1 = String::from("hello");
let s2 = s1;                  // s1 moved to s2
// println!("{}", s1);        // ⚠️ Error: s1 no longer valid

let s3 = s2.clone();          // Deep copy
println!("{} {}", s2, s3);    // Both valid

Ownership rules:

• Each value has one owner
• Owner goes out of scope → value dropped
• Assignment moves ownership (except Copy types)

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

// Immutable borrow
let r1 = &s;
let r2 = &s;
println!("{} {}", r1, r2);    // Ok: multiple immutable refs

// Mutable borrow
let mut s = String::from("hello");
let r = &mut s;
r.push_str(" world");
// ⚠️ Can't have other refs while mutable ref exists

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

let hello: &str = &s[0..5];   // Slice
let world: &str = &s[6..11];

// Array slices
let a = [1, 2, 3, 4, 5];
let slice: &[i32] = &a[1..3]; // [2, 3]

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

// Tuple struct
struct Color(i32, i32, i32);

// Unit struct
struct AlwaysEqual;

let user = User {
    email: String::from("test@example.com"),
    username: String::from("user123"),
    active: true,
    sign_in_count: 1,
};

// Access fields
println!("{}", user.email);

// Mutable struct
let mut user2 = User { ..user };  // Struct update syntax
user2.email = String::from("new@example.com");

struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    // Method (takes &self)
    fn area(&self) -> u32 {
        self.width * self.height
    }

    // Associated function (no self)
    fn square(size: u32) -> Rectangle {
        Rectangle { width: size, height: size }
    }
}

// Usage
let rect = Rectangle { width: 30, height: 50 };
println!("{}", rect.area());
let sq = Rectangle::square(20);

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

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

// Built-in enum for nullable values
enum Option<T> {
    Some(T),
    None,
}

let some_number = Some(5);
let absent_number: Option<i32> = None;

// Using Option
match some_number {
    Some(i) => println!("Got: {}", i),
    None => println!("No value"),
}

// Unwrap shortcuts
let x = some_number.unwrap_or(0);     // 5
let y = absent_number.unwrap_or(0);   // 0

// Built-in enum for error handling
enum Result<T, E> {
    Ok(T),
    Err(E),
}

fn divide(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 {
        Err(String::from("division by zero"))
    } else {
        Ok(a / b)
    }
}

// Usage
match divide(10, 2) {
    Ok(result) => println!("Result: {}", result),
    Err(e) => println!("Error: {}", e),
}

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

// Add elements
let mut v = Vec::new();
v.push(5);
v.push(6);

// Access elements
let third = &v[2];            // Panics if out of bounds
let third = v.get(2);         // Returns Option<&T>

// Iterate
for i in &v {
    println!("{}", i);
}

// Mutable iteration
for i in &mut v {
    *i += 50;
}

// Create string
let mut s = String::new();
let s = String::from("hello");
let s = "hello".to_string();

// Append
s.push_str(" world");
s.push('!');

// Concatenate
let s1 = String::from("Hello, ");
let s2 = String::from("world!");
let s3 = s1 + &s2;            // s1 moved
let s4 = format!("{}{}", s2, s3);

// Slicing ⚠️ Use carefully with UTF-8
let hello = &s[0..5];

// Iteration
for c in "नमस्ते".chars() {
    println!("{}", c);
}

use std::collections::HashMap;

// Create
let mut scores = HashMap::new();

// Insert
scores.insert(String::from("Blue"), 10);
scores.insert(String::from("Red"), 50);

// Access
let team = String::from("Blue");
let score = scores.get(&team);    // Returns Option<&V>

// Iterate
for (key, value) in &scores {
    println!("{}: {}", key, value);
}

// Update
scores.insert(String::from("Blue"), 25);  // Overwrites

// Insert if absent
scores.entry(String::from("Yellow")).or_insert(50);

// Update based on old value
let count = scores.entry(String::from("Blue")).or_insert(0);
*count += 1;

// Unrecoverable errors
panic!("crash and burn");

// Access out of bounds causes panic
let v = vec![1, 2, 3];
v[99];                        // Panic!

use std::fs::File;
use std::io::ErrorKind;

// Explicit match
let f = File::open("hello.txt");
let f = match f {
    Ok(file) => file,
    Err(error) => match error.kind() {
        ErrorKind::NotFound => match File::create("hello.txt") {
            Ok(fc) => fc,
            Err(e) => panic!("Error creating: {:?}", e),
        },
        other_error => panic!("Error opening: {:?}", other_error),
    },
};

// Shortcuts
let f = File::open("hello.txt").unwrap();  // Panic on error
let f = File::open("hello.txt").expect("Failed to open");

use std::io;
use std::fs::File;
use std::io::Read;

fn read_username() -> Result<String, io::Error> {
    let mut f = File::open("hello.txt")?;  // ? operator
    let mut s = String::new();
    f.read_to_string(&mut s)?;
    Ok(s)
}

// ? operator shortcuts
fn read_username_short() -> Result<String, io::Error> {
    let mut s = String::new();
    File::open("hello.txt")?.read_to_string(&mut s)?;
    Ok(s)
}

trait Summary {
    fn summarize(&self) -> String;

    // Default implementation
    fn summarize_default(&self) -> String {
        String::from("(Read more...)")
    }
}

// Implement trait
struct Article {
    title: String,
    content: String,
}

impl Summary for Article {
    fn summarize(&self) -> String {
        format!("{}: {}", self.title, self.content)
    }
}

// Trait as parameter
fn notify(item: &impl Summary) {
    println!("{}", item.summarize());
}

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

// Multiple traits
fn notify<T: Summary + Display>(item: &T) {}

// Where clause for readability
fn some_function<T, U>(t: &T, u: &U) -> i32
where
    T: Display + Clone,
    U: Clone + Debug,
{
    // ...
}

// Return impl Trait
fn returns_summarizable() -> impl Summary {
    Article {
        title: String::from("Title"),
        content: String::from("Content"),
    }
}

// ⚠️ Can only return single type
// This won't work if returning different types:
// fn returns_summarizable(switch: bool) -> impl Summary {
//     if switch { Article {...} } else { Tweet {...} }
// }

// Dynamic dispatch with dyn Trait
trait Draw {
    fn draw(&self);
}

struct Circle {
    radius: f64,
}

struct Square {
    side: f64,
}

impl Draw for Circle {
    fn draw(&self) {
        println!("Drawing circle");
    }
}

impl Draw for Square {
    fn draw(&self) {
        println!("Drawing square");
    }
}

// Box<dyn Trait> for heterogeneous collections
let shapes: Vec<Box<dyn Draw>> = vec![
    Box::new(Circle { radius: 5.0 }),
    Box::new(Square { side: 10.0 }),
];

for shape in shapes {
    shape.draw();  // Dynamic dispatch
}

// Static vs dynamic dispatch
fn static_dispatch(item: &impl Draw) {    // Monomorphization
    item.draw();
}

fn dynamic_dispatch(item: &dyn Draw) {    // Runtime vtable lookup
    item.draw();
}

Static dispatch (impl Trait):

• Faster (no vtable)
• Generates code for each type
• Larger binary size

Dynamic dispatch (dyn Trait):

• Runtime flexibility
• Single function body
• Smaller binary, slight overhead

// Implementing From<T>
struct Number {
    value: i32,
}

impl From<i32> for Number {
    fn from(item: i32) -> Self {
        Number { value: item }
    }
}

// Into is automatically implemented
let num: Number = 5.into();
let num = Number::from(5);

// Error conversion pattern
use std::fs::File;
use std::io;

#[derive(Debug)]
enum MyError {
    Io(io::Error),
    Parse(std::num::ParseIntError),
}

impl From<io::Error> for MyError {
    fn from(error: io::Error) -> Self {
        MyError::Io(error)
    }
}

impl From<std::num::ParseIntError> for MyError {
    fn from(error: std::num::ParseIntError) -> Self {
        MyError::Parse(error)
    }
}

// Use with ? operator
fn read_and_parse() -> Result<i32, MyError> {
    let mut file = File::open("number.txt")?;  // Auto-converts io::Error
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;
    let num: i32 = contents.trim().parse()?;   // Auto-converts ParseIntError
    Ok(num)
}

use std::fmt;

struct Point {
    x: i32,
    y: i32,
}

// Debug trait - for developers
#[derive(Debug)]
struct DebugPoint {
    x: i32,
    y: i32,
}

// Display trait - for users
impl fmt::Display for Point {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "({}, {})", self.x, self.y)
    }
}

// Custom Debug implementation
impl fmt::Debug for Point {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.debug_struct("Point")
            .field("x", &self.x)
            .field("y", &self.y)
            .finish()
    }
}

// Usage
let p = Point { x: 10, y: 20 };
println!("{}", p);        // Display: (10, 20)
println!("{:?}", p);      // Debug: Point { x: 10, y: 20 }
println!("{:#?}", p);     // Pretty Debug (multiline)

let dp = DebugPoint { x: 5, y: 15 };
println!("{:?}", dp);     // Derived Debug

fn largest<T: PartialOrd>(list: &[T]) -> &T {
    let mut largest = &list[0];

    for item in list {
        if item > largest {
            largest = item;
        }
    }

    largest
}

// Multiple type parameters
fn mix<T, U>(x: T, y: U) -> (T, U) {
    (x, y)
}

struct Point<T> {
    x: T,
    y: T,
}

// Multiple types
struct Point<T, U> {
    x: T,
    y: U,
}

// Methods on generic types
impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }
}

// Methods for specific types
impl Point<f32> {
    fn distance_from_origin(&self) -> f32 {
        (self.x.powi(2) + self.y.powi(2)).sqrt()
    }
}

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

enum Result<T, E> {
    Ok(T),
    Err(E),
}

// Heap allocation
let b = Box::new(5);
println!("b = {}", b);

// Recursive types (unknown size at compile time)
enum List {
    Cons(i32, Box<List>),
    Nil,
}

use List::{Cons, Nil};

let list = Cons(1,
    Box::new(Cons(2,
        Box::new(Cons(3,
            Box::new(Nil))))));

// Large data on heap
struct BigStruct {
    data: [u8; 10000],
}

let big = Box::new(BigStruct { data: [0; 10000] });

Use when:

• Type has unknown size at compile time
• Large data to avoid stack overflow
• Transfer ownership without copying

use std::rc::Rc;

// Reference counting for shared ownership
let a = Rc::new(5);
let b = Rc::clone(&a);      // Increment count
let c = Rc::clone(&a);

println!("count = {}", Rc::strong_count(&a));  // 3

// Shared ownership of graph/tree
enum List {
    Cons(i32, Rc<List>),
    Nil,
}

use List::{Cons, Nil};

let a = Rc::new(Cons(5, Rc::new(Cons(10, Rc::new(Nil)))));
let b = Cons(3, Rc::clone(&a));
let c = Cons(4, Rc::clone(&a));

// Drop decrements count
drop(a);
println!("count after drop = {}", Rc::strong_count(&b));  // 2

Use when:

• Multiple owners needed
• Single-threaded only (use Arc for threads)
• Immutable shared data

use std::cell::RefCell;

// Interior mutability - mutate through immutable reference
let data = RefCell::new(5);

*data.borrow_mut() += 1;    // Mutable borrow
println!("{}", data.borrow());  // Immutable borrow

// Borrow checking at runtime
let mut_borrow = data.borrow_mut();
// let another = data.borrow_mut();  // ⚠️ Panic at runtime!

// Multiple owners with mutable data
use std::rc::Rc;

let value = Rc::new(RefCell::new(5));
let a = Rc::clone(&value);
let b = Rc::clone(&value);

*a.borrow_mut() += 10;
*b.borrow_mut() += 20;
println!("{:?}", value);    // 35

Use when:

• Need mutability through shared reference
• Borrow rules checked at runtime
• Single-threaded (use Mutex for threads)

use std::borrow::Cow;

// Clone-on-write - avoid cloning until mutation
fn process(input: &str) -> Cow<str> {
    if input.contains("REPLACE") {
        Cow::Owned(input.replace("REPLACE", "FIXED"))
    } else {
        Cow::Borrowed(input)  // No clone!
    }
}

let s1 = "Hello world";
let result1 = process(s1);      // Borrowed

let s2 = "REPLACE this";
let result2 = process(s2);      // Owned

// Works with any cloneable + borrowable type
fn abs_all(input: &mut Cow<[i32]>) {
    for i in 0..input.len() {
        let v = input[i];
        if v < 0 {
            input.to_mut()[i] = -v;  // Clone on first mutation
        }
    }
}

Use when:

• Might not need to modify data
• Avoid unnecessary clones
• Working with borrowed or owned data

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

// Usage
let string1 = String::from("long string");
let result;
{
    let string2 = String::from("xyz");
    result = longest(string1.as_str(), string2.as_str());
    println!("{}", result);
}
// ⚠️ result can't outlive string2

struct ImportantExcerpt<'a> {
    part: &'a str,
}

impl<'a> ImportantExcerpt<'a> {
    fn level(&self) -> i32 {
        3
    }

    fn announce_and_return_part(&self, announcement: &str) -> &str {
        println!("Attention: {}", announcement);
        self.part
    }
}

// These are equivalent:
fn first_word(s: &str) -> &str {}
fn first_word<'a>(s: &'a str) -> &'a str {}

// Compiler infers lifetimes based on rules

cargo new myproject        # Create new project
cargo init                 # Initialize in current dir
cargo build                # Build debug
cargo build --release      # Build optimized
cargo run                  # Build and run
cargo check                # Check without building
cargo test                 # Run tests
cargo doc --open           # Generate and open docs

# Cargo.toml
[package]
name = "myproject"
version = "0.1.0"
edition = "2021"

[dependencies]
serde = "1.0"
serde_json = "1.0"
rand = "0.8.5"

[dev-dependencies]
criterion = "0.5"

cargo add serde            # Add dependency
cargo update               # Update dependencies
cargo clean                # Remove build artifacts

# Cargo.toml (workspace root)
[workspace]
members = [
    "crate1",
    "crate2",
]

cargo build --workspace    # Build all crates
cargo test --workspace     # Test all crates

// Define module
mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
        fn seat_at_table() {}       // Private
    }

    mod serving {
        fn take_order() {}
        fn serve_order() {}
    }
}

// Use module
pub fn eat_at_restaurant() {
    // Absolute path
    crate::front_of_house::hosting::add_to_waitlist();

    // Relative path
    front_of_house::hosting::add_to_waitlist();
}

// src/lib.rs or src/main.rs
mod garden;                // Looks for src/garden.rs or src/garden/mod.rs

// src/garden.rs
pub mod vegetables;        // Looks for src/garden/vegetables.rs

// src/garden/vegetables.rs
#[derive(Debug)]
pub struct Asparagus {}

src/
├── lib.rs
├── garden.rs
└── garden/
    └── vegetables.rs

Old style (still works):

src/
├── lib.rs
├── garden/
│   ├── mod.rs
│   └── vegetables.rs

mod outer {
    pub fn public_fn() {}
    fn private_fn() {}

    pub mod inner {
        pub fn inner_public() {}

        pub(crate) fn crate_visible() {}      // Visible in crate
        pub(super) fn parent_visible() {}     // Visible to parent
        pub(in crate::outer) fn outer_visible() {}  // Visible in outer
    }
}

// Usage
outer::public_fn();           // Ok
outer::inner::inner_public(); // Ok
outer::inner::crate_visible(); // Ok (same crate)
// outer::private_fn();       // Error

// Import
use std::collections::HashMap;
use std::io::{self, Write};       // Import module and trait
use std::fmt::Result;
use std::io::Result as IoResult;  // Rename

// Glob import (use sparingly)
use std::collections::*;

// Re-export with pub use
pub use crate::front_of_house::hosting;

// External crates
use rand::Rng;
use serde::{Serialize, Deserialize};

Idiomatic patterns:

// For functions: import module
use std::collections::HashMap;
let map = HashMap::new();

// For types/traits: import directly
use std::fmt::Display;
fn print(item: impl Display) {}

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

    #[test]
    fn it_works() {
        assert_eq!(2 + 2, 4);
    }

    #[test]
    fn exploration() {
        assert!(true);
    }

    #[test]
    #[should_panic]
    fn panic_test() {
        panic!("This should panic");
    }

    #[test]
    fn result_test() -> Result<(), String> {
        if 2 + 2 == 4 {
            Ok(())
        } else {
            Err(String::from("two plus two != four"))
        }
    }
}

assert!(condition);                // Panic if false
assert_eq!(left, right);           // Panic if not equal
assert_ne!(left, right);           // Panic if equal

// With custom message
assert!(condition, "Error: {}", msg);
assert_eq!(a, b, "Values differ: {} vs {}", a, b);

cargo test                 # Run all tests
cargo test test_name       # Run specific test
cargo test -- --nocapture  # Show println! output
cargo test -- --ignored    # Run ignored tests

use std::thread;
use std::time::Duration;

// Spawn thread
let handle = thread::spawn(|| {
    for i in 1..10 {
        println!("spawned thread: {}", i);
        thread::sleep(Duration::from_millis(1));
    }
});

handle.join().unwrap();    // Wait for thread to finish

// Move closure
let v = vec![1, 2, 3];
let handle = thread::spawn(move || {
    println!("vector: {:?}", v);
});

use std::sync::mpsc;
use std::thread;

// Create channel
let (tx, rx) = mpsc::channel();

thread::spawn(move || {
    let val = String::from("hi");
    tx.send(val).unwrap();
});

let received = rx.recv().unwrap();
println!("Got: {}", received);

// Multiple producers
let (tx, rx) = mpsc::channel();
let tx1 = tx.clone();

thread::spawn(move || {
    tx.send(String::from("hi from tx")).unwrap();
});

thread::spawn(move || {
    tx1.send(String::from("hi from tx1")).unwrap();
});

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

// Arc = Atomic Reference Counter
// Mutex = Mutual Exclusion
let counter = Arc::new(Mutex::new(0));
let mut handles = vec![];

for _ in 0..10 {
    let counter = Arc::clone(&counter);
    let handle = thread::spawn(move || {
        let mut num = counter.lock().unwrap();
        *num += 1;
    });
    handles.push(handle);
}

for handle in handles {
    handle.join().unwrap();
}

println!("Result: {}", *counter.lock().unwrap());

// Async function returns a Future
async fn fetch_data() -> String {
    String::from("data")
}

// .await to execute Future
async fn process() {
    let data = fetch_data().await;
    println!("{}", data);
}

// Async block
let future = async {
    let result = fetch_data().await;
    result
};

// Cargo.toml
// [dependencies]
// tokio = { version = "1", features = ["full"] }

// Main function with tokio runtime
#[tokio::main]
async fn main() {
    println!("Hello from async!");

    let result = fetch_data().await;
    println!("{}", result);
}

// Alternative: manual runtime
fn main() {
    let rt = tokio::runtime::Runtime::new().unwrap();
    rt.block_on(async {
        fetch_data().await;
    });
}

use tokio::task;

#[tokio::main]
async fn main() {
    // Spawn concurrent task
    let handle = task::spawn(async {
        // Runs on tokio thread pool
        expensive_computation().await
    });

    // Do other work
    do_something_else().await;

    // Wait for task
    let result = handle.await.unwrap();
    println!("Result: {}", result);
}

// Multiple tasks
async fn fetch_multiple() {
    let task1 = task::spawn(fetch_user(1));
    let task2 = task::spawn(fetch_user(2));

    let (user1, user2) = tokio::join!(task1, task2);
}

use tokio::net::TcpListener;
use tokio::io::{AsyncReadExt, AsyncWriteExt};

// Async TCP server
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let listener = TcpListener::bind("127.0.0.1:8080").await?;

    loop {
        let (mut socket, _) = listener.accept().await?;

        // Spawn task per connection
        tokio::spawn(async move {
            let mut buf = [0; 1024];

            loop {
                match socket.read(&mut buf).await {
                    Ok(0) => return,  // Connection closed
                    Ok(n) => {
                        if socket.write_all(&buf[0..n]).await.is_err() {
                            return;
                        }
                    }
                    Err(_) => return,
                }
            }
        });
    }
}

// Async HTTP request
use reqwest;

async fn fetch_url(url: &str) -> Result<String, reqwest::Error> {
    let body = reqwest::get(url)
        .await?
        .text()
        .await?;
    Ok(body)
}

// Timeout
use tokio::time::{timeout, Duration};

async fn with_timeout() {
    let result = timeout(
        Duration::from_secs(5),
        fetch_data()
    ).await;

    match result {
        Ok(data) => println!("Got: {:?}", data),
        Err(_) => println!("Timeout!"),
    }
}

println!("Hello");         // Print with newline
print!("Hello");           // Print without newline
eprintln!("Error");        // Print to stderr
format!("x = {}", x);      // Format to String

vec![1, 2, 3];             // Create vector
panic!("Error!");          // Panic with message

assert!(condition);        // Assert condition
assert_eq!(a, b);          // Assert equality
debug_assert!(condition);  // Assert in debug only

// Define macro
macro_rules! say_hello {
    () => {
        println!("Hello!");
    };
}

// With arguments
macro_rules! create_function {
    ($func_name:ident) => {
        fn $func_name() {
            println!("Function {:?} called", stringify!($func_name));
        }
    };
}

// Multiple patterns
macro_rules! my_vec {
    () => {
        Vec::new()
    };
    ($elem:expr; $n:expr) => {
        vec![$elem; $n]
    };
}

#[derive(Debug)]           // Auto-implement Debug
#[derive(Clone)]           // Auto-implement Clone
#[derive(PartialEq)]       // Auto-implement PartialEq
#[derive(Eq)]              // Auto-implement Eq

// Multiple derives
#[derive(Debug, Clone, PartialEq)]
struct Point {
    x: i32,
    y: i32,
}

// Derive traits
#[derive(Debug, Clone, PartialEq)]
struct MyStruct {}

// Allow/warn/deny lints
#[allow(dead_code)]
#[warn(missing_docs)]
#[deny(unsafe_code)]

// Testing
#[test]
fn my_test() {}

#[cfg(test)]
mod tests {}

// Conditional compilation
#[cfg(target_os = "linux")]
fn linux_only() {}

#[cfg(not(target_os = "windows"))]
fn not_windows() {}

#[cfg(any(unix, target_os = "windows"))]
fn multi_platform() {}

#[cfg(all(unix, target_arch = "x86_64"))]
fn specific_platform() {}

// Cargo.toml
// [features]
// default = ["std"]
// std = []
// experimental = []

#[cfg(feature = "std")]
use std::collections::HashMap;

#[cfg(not(feature = "std"))]
use alloc::collections::BTreeMap;

#[cfg(feature = "experimental")]
pub mod experimental {
    pub fn new_feature() {}
}

/// Document the following item
///
/// # Examples
///
/// ```
/// let x = example();
/// ```
pub fn example() {}

//! Document the enclosing item (module/crate)

#[doc = "Alternative doc syntax"]
pub fn other() {}

// Doc tests
/// ```
/// assert_eq!(add(2, 2), 4);
/// ```
pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

// Hide from docs
#[doc(hidden)]
pub fn internal_api() {}

// Inline suggestions
#[inline]
fn small_function() {}

#[inline(always)]
fn always_inline() {}

// Must use return value
#[must_use]
fn important() -> i32 { 42 }

// Deprecated
#[deprecated]
fn old_api() {}

#[deprecated(since = "1.5.0", note = "Use new_api instead")]
fn old_api_detailed() {}

// Non-exhaustive (for library evolution)
#[non_exhaustive]
pub enum ApiError {
    NotFound,
    Timeout,
}

#[non_exhaustive]
pub struct Config {
    pub timeout: u64,
}

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

// Map
let v2: Vec<_> = v.iter().map(|x| x + 1).collect();

// Filter
let v3: Vec<_> = v.iter().filter(|x| *x % 2 == 0).collect();

// Fold (reduce)
let sum: i32 = v.iter().fold(0, |acc, x| acc + x);

// Chain operations
let result: Vec<_> = v.iter()
    .filter(|x| *x % 2 == 0)
    .map(|x| x * 2)
    .collect();

// Find
let first_even = v.iter().find(|x| *x % 2 == 0);

// Any/All
let has_even = v.iter().any(|x| x % 2 == 0);
let all_positive = v.iter().all(|x| *x > 0);

// Closure types
let add_one = |x| x + 1;               // Type inferred
let add_one = |x: i32| -> i32 { x + 1 };

// Capture environment
let x = 4;
let equal_to_x = |z| z == x;           // Captures x

// Move ownership
let x = vec![1, 2, 3];
let equal_to_x = move |z| z == x;      // Takes ownership

// Function parameters
fn apply<F>(f: F, x: i32) -> i32
where
    F: Fn(i32) -> i32,
{
    f(x)
}

struct Circle {
    x: f64,
    y: f64,
    radius: f64,
}

struct CircleBuilder {
    x: f64,
    y: f64,
    radius: f64,
}

impl CircleBuilder {
    fn new() -> CircleBuilder {
        CircleBuilder {
            x: 0.0,
            y: 0.0,
            radius: 1.0,
        }
    }

    fn x(&mut self, x: f64) -> &mut Self {
        self.x = x;
        self
    }

    fn y(&mut self, y: f64) -> &mut Self {
        self.y = y;
        self
    }

    fn radius(&mut self, radius: f64) -> &mut Self {
        self.radius = radius;
        self
    }

    fn build(&self) -> Circle {
        Circle {
            x: self.x,
            y: self.y,
            radius: self.radius,
        }
    }
}

// Usage
let c = CircleBuilder::new()
    .x(10.0)
    .y(20.0)
    .radius(5.0)
    .build();

use std::fs;
use std::io;

// Read entire file to string
let contents = fs::read_to_string("file.txt")?;

// Read entire file to bytes
let bytes = fs::read("file.bin")?;

// Write string to file (overwrites)
fs::write("output.txt", "Hello, world!")?;

// Write bytes to file
fs::write("output.bin", &[0, 1, 2, 3])?;

// Check if file exists
if fs::metadata("file.txt").is_ok() {
    println!("File exists");
}

// Create directory
fs::create_dir("my_dir")?;
fs::create_dir_all("path/to/nested/dir")?;

// Remove file
fs::remove_file("file.txt")?;

use std::fs::File;
use std::io::{Read, Write};

// Open for reading
let mut file = File::open("input.txt")?;
let mut contents = String::new();
file.read_to_string(&mut contents)?;

// Create or truncate
let mut file = File::create("output.txt")?;
file.write_all(b"Hello, world!")?;

// Append
use std::fs::OpenOptions;

let mut file = OpenOptions::new()
    .append(true)
    .open("log.txt")?;
file.write_all(b"New log entry\n")?;

// Read and write
let mut file = OpenOptions::new()
    .read(true)
    .write(true)
    .create(true)
    .open("data.txt")?;

use std::fs::File;
use std::io::{BufReader, BufRead, BufWriter, Write};

// Buffered reading (efficient for large files)
let file = File::open("large.txt")?;
let reader = BufReader::new(file);

// Read line by line
for line in reader.lines() {
    let line = line?;
    println!("{}", line);
}

// Buffered writing
let file = File::create("output.txt")?;
let mut writer = BufWriter::new(file);

writer.write_all(b"Line 1\n")?;
writer.write_all(b"Line 2\n")?;
writer.flush()?;  // Ensure data is written

// Read specific lines
let file = File::open("file.txt")?;
let reader = BufReader::new(file);
let lines: Vec<_> = reader
    .lines()
    .take(5)           // First 5 lines
    .collect();

use std::path::Path;
use std::fs;

let path = Path::new("dir/file.txt");

// Path info
println!("Exists: {}", path.exists());
println!("Is file: {}", path.is_file());
println!("Is dir: {}", path.is_dir());
println!("File name: {:?}", path.file_name());
println!("Extension: {:?}", path.extension());
println!("Parent: {:?}", path.parent());

// Build paths
use std::path::PathBuf;

let mut path = PathBuf::from("/tmp");
path.push("dir");
path.push("file.txt");
// Result: /tmp/dir/file.txt

// Canonicalize (resolve symlinks, relative paths)
let canonical = fs::canonicalize("./file.txt")?;

// Cargo.toml
// [dependencies]
// serde = { version = "1.0", features = ["derive"] }
// serde_json = "1.0"

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize, Debug)]
struct Person {
    name: String,
    age: u32,
    email: String,
}

// Serialize to JSON
let person = Person {
    name: "Alice".to_string(),
    age: 30,
    email: "alice@example.com".to_string(),
};

let json = serde_json::to_string(&person)?;
println!("{}", json);
// {"name":"Alice","age":30,"email":"alice@example.com"}

// Pretty print
let json = serde_json::to_string_pretty(&person)?;

// Deserialize from JSON
let json_str = r#"{"name":"Bob","age":25,"email":"bob@example.com"}"#;
let person: Person = serde_json::from_str(json_str)?;
println!("{:?}", person);

// From file
let file = File::open("data.json")?;
let person: Person = serde_json::from_reader(file)?;

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
struct User {
    // Rename field in JSON
    #[serde(rename = "userName")]
    username: String,

    // Skip field
    #[serde(skip)]
    password_hash: String,

    // Skip when serializing
    #[serde(skip_serializing)]
    internal_id: u64,

    // Skip when deserializing
    #[serde(skip_deserializing)]
    computed: String,

    // Default value if missing
    #[serde(default)]
    active: bool,

    // Custom default function
    #[serde(default = "default_role")]
    role: String,

    // Flatten nested struct
    #[serde(flatten)]
    metadata: Metadata,
}

fn default_role() -> String {
    "user".to_string()
}

#[derive(Serialize, Deserialize)]
struct Metadata {
    created_at: String,
    updated_at: String,
}

// Option fields
#[derive(Serialize, Deserialize)]
struct OptionalFields {
    // Skip if None
    #[serde(skip_serializing_if = "Option::is_none")]
    middle_name: Option<String>,
}

// Rename all fields
#[derive(Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
struct Product {
    product_name: String,      // -> "productName"
    unit_price: f64,           // -> "unitPrice"
}

// Tag for enums
#[derive(Serialize, Deserialize)]
#[serde(tag = "type")]
enum Message {
    Text { content: String },
    Image { url: String },
}
// {"type":"Text","content":"hello"}

// Untagged enum (by structure)
#[derive(Serialize, Deserialize)]
#[serde(untagged)]
enum Value {
    Number(i32),
    Text(String),
}

// Deny unknown fields
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct Strict {
    field1: String,
}

use libc::size_t;

#[link(name = "snappy")]
unsafe extern "C" {
    fn snappy_max_compressed_length(source_length: size_t) -> size_t;
}

fn main() {
    let x = unsafe { snappy_max_compressed_length(100) };
    println!("max compressed length: {}", x);
}