Rust Programming Beginner Guide — Ownership, Lifetimes, and Safe Systems Programming

fn main() {
    let s1 = String::from("hello"); // s1 owns the String
    let s2 = s1;                     // Ownership moves to s2
    // println!("{}", s1);           // Compile error! s1 is no longer valid
    println!("{}", s2);              // OK
} // s2 goes out of scope, memory is freed

// Integers implement Copy trait - they are copied
let x = 5;
let y = x;
println!("x = {}, y = {}", x, y); // Both usable

// String does not implement Copy - it is moved
let s1 = String::from("hello");
let s2 = s1; // Move!
// s1 is no longer usable

// Use clone for explicit copies
let s3 = String::from("world");
let s4 = s3.clone();
println!("s3 = {}, s4 = {}", s3, s4); // Both usable

fn calculate_length(s: &String) -> usize {
    s.len()
} // s is a reference, so it is not dropped here

fn main() {
    let s1 = String::from("hello");
    let len = calculate_length(&s1); // Borrowing (immutable reference)
    println!("The length of '{}' is {}", s1, len); // s1 still valid
}

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

    // Multiple immutable references are allowed simultaneously
    let r1 = &s;
    let r2 = &s;
    println!("{} and {}", r1, r2);

    // Only one mutable reference is allowed
    let r3 = &mut s;
    r3.push_str(", world");
    println!("{}", r3);

    // Cannot have immutable and mutable references simultaneously
    // let r4 = &s;
    // let r5 = &mut s; // Compile error!
}

fn first_word(s: &str) -> &str {
    let bytes = s.as_bytes();
    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }
    &s[..]
}

fn main() {
    let s = String::from("hello world");
    let word = first_word(&s);
    println!("First word: {}", word); // "hello"
}

// This code won't compile - prevents dangling references
// fn dangle() -> &String {
//     let s = String::from("hello");
//     &s  // s is freed at the end of the function, reference becomes invalid
// }

// Correct approach: return the value directly
fn no_dangle() -> String {
    let s = String::from("hello");
    s // Ownership moves to the caller
}

// Returns the longer of two string slices
// The return value's lifetime follows the shorter of the two arguments
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

fn main() {
    let string1 = String::from("long string");
    let result;
    {
        let string2 = String::from("xyz");
        result = longest(string1.as_str(), string2.as_str());
        println!("The longer string is: {}", result); // OK here
    }
    // println!("{}", result); // Could error since string2 has been dropped
}

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
    }
}

fn main() {
    let novel = String::from("Call me Ishmael. Some years ago...");
    let first_sentence;
    {
        let i = novel.find('.').unwrap_or(novel.len());
        first_sentence = &novel[..i];
    }
    let excerpt = ImportantExcerpt {
        part: first_sentence,
    };
    println!("Quote: {}", excerpt.part);
}

// String literals are always 'static
let s: &'static str = "This string is valid for the entire program lifetime";

// Warning: Don't overuse 'static
// In most cases a shorter lifetime is sufficient

// Lifetime elision applied - Rule 2
fn first_word(s: &str) -> &str {
    // Compiler infers: fn first_word<'a>(s: &'a str) -> &'a str
    let bytes = s.as_bytes();
    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }
    &s[..]
}

// Basic enum
enum Direction {
    Up,
    Down,
    Left,
    Right,
}

// Enum with data
enum Message {
    Quit,                        // No data
    Move { x: i32, y: i32 },    // Named fields
    Write(String),               // Single String
    ChangeColor(i32, i32, i32),  // Three i32 values
}

impl Message {
    fn call(&self) {
        match self {
            Message::Quit => println!("Quit"),
            Message::Move { x, y } => println!("Move: ({}, {})", x, y),
            Message::Write(text) => println!("Message: {}", text),
            Message::ChangeColor(r, g, b) => {
                println!("Change color: ({}, {}, {})", r, g, b)
            }
        }
    }
}

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

fn divide(numerator: f64, denominator: f64) -> Option<f64> {
    if denominator == 0.0 {
        None
    } else {
        Some(numerator / denominator)
    }
}

fn main() {
    let result = divide(10.0, 3.0);

    // Handle with match
    match result {
        Some(value) => println!("Result: {:.2}", value),
        None => println!("Cannot divide by zero"),
    }

    // Concise with if let
    if let Some(value) = divide(10.0, 0.0) {
        println!("Result: {}", value);
    } else {
        println!("Division failed");
    }

    // Default value with unwrap_or
    let safe_result = divide(10.0, 0.0).unwrap_or(0.0);
    println!("Safe result: {}", safe_result);
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

enum UsState {
    Alabama,
    Alaska,
    Arizona,
    // ...
}

fn value_in_cents(coin: &Coin) -> u8 {
    match coin {
        Coin::Penny => {
            println!("Lucky penny!");
            1
        }
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter(state) => {
            println!("State quarter: {:?}", state);
            25
        }
    }
}

fn classify_number(n: i32) {
    match n {
        // Range matching
        1..=12 => println!("Month {}", n),
        13..=19 => println!("Teenager"),

        // Guard conditions
        x if x % 2 == 0 => println!("Even: {}", x),
        x if x < 0 => println!("Negative: {}", x),

        // Multiple patterns
        20 | 30 | 40 => println!("Multiple of 10"),

        // Catch all
        _ => println!("Other: {}", n),
    }
}

// Struct destructuring
struct Point {
    x: f64,
    y: f64,
}

fn describe_point(point: &Point) {
    match point {
        Point { x: 0.0, y: 0.0 } => println!("Origin"),
        Point { x, y: 0.0 } => println!("On x-axis: {}", x),
        Point { x: 0.0, y } => println!("On y-axis: {}", y),
        Point { x, y } => println!("({}, {})", x, y),
    }
}

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

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

fn read_file_content(path: &str) -> Result<String, io::Error> {
    let mut file = File::open(path)?;
    let mut content = String::new();
    file.read_to_string(&mut content)?;
    Ok(content)
}

fn main() {
    match read_file_content("config.toml") {
        Ok(content) => println!("File content: {}", content),
        Err(e) => eprintln!("Failed to read file: {}", e),
    }
}

use std::fs;
use std::io;
use std::num::ParseIntError;

#[derive(Debug)]
enum AppError {
    IoError(io::Error),
    ParseError(ParseIntError),
}

impl From<io::Error> for AppError {
    fn from(e: io::Error) -> Self {
        AppError::IoError(e)
    }
}

impl From<ParseIntError> for AppError {
    fn from(e: ParseIntError) -> Self {
        AppError::ParseError(e)
    }
}

fn read_and_parse(path: &str) -> Result<i32, AppError> {
    let content = fs::read_to_string(path)?; // io::Error -> AppError
    let number = content.trim().parse::<i32>()?; // ParseIntError -> AppError
    Ok(number * 2)
}

// thiserror - Define specific error types for libraries
use thiserror::Error;

#[derive(Error, Debug)]
enum DatabaseError {
    #[error("Connection failed: {0}")]
    ConnectionFailed(String),

    #[error("Query execution error: {0}")]
    QueryError(String),

    #[error("Record not found: {id}")]
    NotFound { id: u64 },
}

// anyhow - Convenient error handling for applications
use anyhow::{Context, Result};

fn load_config() -> Result<Config> {
    let content = fs::read_to_string("config.toml")
        .context("Failed to read configuration file")?;

    let config: Config = toml::from_str(&content)
        .context("Failed to parse configuration file")?;

    Ok(config)
}

// panic! immediately terminates the program
fn check_positive(n: i32) {
    if n < 0 {
        panic!("Negative number received: {}", n);
    }
}

// Array index out of bounds also panics
let v = vec![1, 2, 3];
// let element = v[99]; // panic!

// Safe access
match v.get(99) {
    Some(value) => println!("Value: {}", value),
    None => println!("Index out of bounds"),
}

#[derive(Debug, Clone)]
struct User {
    username: String,
    email: String,
    age: u32,
    active: bool,
}

impl User {
    // Constructor pattern (conventionally named new)
    fn new(username: String, email: String, age: u32) -> Self {
        User {
            username,
            email,
            age,
            active: true,
        }
    }

    // Method (borrows &self immutably)
    fn is_adult(&self) -> bool {
        self.age >= 18
    }

    // Mutable method (&mut self)
    fn deactivate(&mut self) {
        self.active = false;
    }

    // Method that takes ownership
    fn into_username(self) -> String {
        self.username
    }
}

fn main() {
    let mut user = User::new(
        "rustacean".to_string(),
        "rust@example.com".to_string(),
        25,
    );

    println!("Is adult: {}", user.is_adult());
    user.deactivate();
    println!("User: {:?}", user);
}

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

    // Can provide a default implementation
    fn summarize(&self) -> String {
        format!("Read more from {}...", self.summarize_author())
    }
}

struct Article {
    title: String,
    author: String,
    content: String,
}

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

    fn summarize(&self) -> String {
        format!("{}, by {} - {}...",
            self.title, self.author,
            &self.content[..50.min(self.content.len())]
        )
    }
}

struct Tweet {
    username: String,
    content: String,
}

impl Summary for Tweet {
    fn summarize_author(&self) -> String {
        format!("@{}", self.username)
    }
    // Uses default implementation for summarize
}

// Generic function + trait bounds
fn notify(item: &impl Summary) {
    println!("Breaking news! {}", item.summarize());
}

// Equivalent expression (trait bound syntax)
fn notify_verbose<T: Summary>(item: &T) {
    println!("Breaking news! {}", item.summarize());
}

// Multiple trait bounds
fn display_and_summarize<T: Summary + std::fmt::Display>(item: &T) {
    println!("Display: {}", item);
    println!("Summary: {}", item.summarize());
}

// where clause for readability
fn complex_function<T, U>(t: &T, u: &U) -> String
where
    T: Summary + Clone,
    U: std::fmt::Display + std::fmt::Debug,
{
    format!("{} - {:?}", t.summarize(), u)
}

struct Stack<T> {
    elements: Vec<T>,
}

impl<T> Stack<T> {
    fn new() -> Self {
        Stack {
            elements: Vec::new(),
        }
    }

    fn push(&mut self, item: T) {
        self.elements.push(item);
    }

    fn pop(&mut self) -> Option<T> {
        self.elements.pop()
    }

    fn peek(&self) -> Option<&T> {
        self.elements.last()
    }

    fn is_empty(&self) -> bool {
        self.elements.is_empty()
    }

    fn size(&self) -> usize {
        self.elements.len()
    }
}

// Additional implementation for specific types
impl<T: std::fmt::Display> Stack<T> {
    fn print_top(&self) {
        if let Some(top) = self.peek() {
            println!("Top: {}", top);
        }
    }
}

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

// async blocks
let future = async {
    let data = fetch_data("https://api.example.com/data").await;
    println!("Data received");
    data
};

use tokio;
use std::time::Duration;

#[tokio::main]
async fn main() {
    // Run multiple tasks concurrently
    let (result1, result2) = tokio::join!(
        async_task("Task 1", 2),
        async_task("Task 2", 1),
    );

    println!("Results: {:?}, {:?}", result1, result2);
}

async fn async_task(name: &str, seconds: u64) -> String {
    println!("{} started", name);
    tokio::time::sleep(Duration::from_secs(seconds)).await;
    println!("{} completed", name);
    format!("{} result", name)
}

use tokio::sync::mpsc;

#[tokio::main]
async fn main() {
    // Multi-producer, single-consumer channel
    let (tx, mut rx) = mpsc::channel::<String>(100);

    // Create multiple producers
    for i in 0..5 {
        let tx_clone = tx.clone();
        tokio::spawn(async move {
            let msg = format!("Message {}", i);
            tx_clone.send(msg).await.unwrap();
        });
    }
    // Drop original tx (channel closes when all producers are done)
    drop(tx);

    // Consumer
    while let Some(message) = rx.recv().await {
        println!("Received: {}", message);
    }
}

use std::sync::Arc;
use tokio::sync::Mutex;

#[tokio::main]
async fn main() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

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

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

    println!("Final counter: {}", *counter.lock().await);
}

[package]
name = "my-project"
version = "0.1.0"
edition = "2021"
authors = ["Developer <dev@example.com>"]
description = "A sample Rust project"
license = "MIT"

[dependencies]
serde = { version = "1.0", features = ["derive"] }
tokio = { version = "1", features = ["full"] }
reqwest = { version = "0.12", features = ["json"] }
anyhow = "1.0"
thiserror = "2.0"
clap = { version = "4", features = ["derive"] }

[dev-dependencies]
criterion = "0.5"
mockall = "0.13"

[profile.release]
opt-level = 3
lto = true
codegen-units = 1
strip = true

# Create a project
cargo new my-project       # Binary project
cargo new my-lib --lib     # Library project

# Build and run
cargo build                # Debug build
cargo build --release      # Release build
cargo run                  # Build and run
cargo run -- --arg1 value  # Pass arguments

# Testing
cargo test                 # Run all tests
cargo test test_name       # Run specific test
cargo test -- --nocapture  # Show output

# Inspection and analysis
cargo check                # Check compilation (faster than build)
cargo clippy               # Lint checks
cargo fmt                  # Code formatting

# Documentation
cargo doc --open           # Generate docs and open in browser

# Dependency management
cargo add serde            # Add dependency
cargo update               # Update dependencies
cargo tree                 # Show dependency tree

# Root Cargo.toml
[workspace]
members = [
    "crates/core",
    "crates/api",
    "crates/cli",
]

[workspace.dependencies]
serde = { version = "1.0", features = ["derive"] }
tokio = { version = "1", features = ["full"] }

# crates/core/Cargo.toml
[package]
name = "my-core"
version = "0.1.0"
edition = "2021"

[dependencies]
serde = { workspace = true }

# Set up crates.io account
cargo login

# Pre-publish check
cargo publish --dry-run

# Publish
cargo publish

use clap::Parser;
use std::path::PathBuf;

#[derive(Parser, Debug)]
#[command(name = "file-analyzer")]
#[command(about = "File analysis tool", long_about = None)]
struct Cli {
    /// File path to analyze
    #[arg(short, long)]
    path: PathBuf,

    /// Output format
    #[arg(short, long, default_value = "text")]
    format: String,

    /// Verbose output
    #[arg(short, long)]
    verbose: bool,

    /// Maximum depth
    #[arg(short, long, default_value_t = 3)]
    depth: u32,
}

fn main() {
    let cli = Cli::parse();

    if cli.verbose {
        println!("File path: {:?}", cli.path);
        println!("Output format: {}", cli.format);
        println!("Max depth: {}", cli.depth);
    }

    analyze_file(&cli.path, cli.depth);
}

fn analyze_file(path: &PathBuf, depth: u32) {
    println!("Analyzing: {:?} (depth: {})", path, depth);
    // File analysis logic...
}

use axum::{
    extract::{Path, State},
    http::StatusCode,
    response::Json,
    routing::{get, post},
    Router,
};
use serde::{Deserialize, Serialize};
use std::sync::Arc;
use tokio::sync::Mutex;

#[derive(Debug, Serialize, Deserialize, Clone)]
struct Todo {
    id: u64,
    title: String,
    completed: bool,
}

type AppState = Arc<Mutex<Vec<Todo>>>;

#[tokio::main]
async fn main() {
    let state: AppState = Arc::new(Mutex::new(Vec::new()));

    let app = Router::new()
        .route("/todos", get(list_todos).post(create_todo))
        .route("/todos/:id", get(get_todo))
        .with_state(state);

    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000")
        .await
        .unwrap();
    println!("Server running: http://localhost:3000");
    axum::serve(listener, app).await.unwrap();
}

async fn list_todos(
    State(state): State<AppState>,
) -> Json<Vec<Todo>> {
    let todos = state.lock().await;
    Json(todos.clone())
}

async fn create_todo(
    State(state): State<AppState>,
    Json(payload): Json<CreateTodo>,
) -> (StatusCode, Json<Todo>) {
    let mut todos = state.lock().await;
    let todo = Todo {
        id: todos.len() as u64 + 1,
        title: payload.title,
        completed: false,
    };
    todos.push(todo.clone());
    (StatusCode::CREATED, Json(todo))
}

#[derive(Deserialize)]
struct CreateTodo {
    title: String,
}

async fn get_todo(
    State(state): State<AppState>,
    Path(id): Path<u64>,
) -> Result<Json<Todo>, StatusCode> {
    let todos = state.lock().await;
    todos
        .iter()
        .find(|t| t.id == id)
        .cloned()
        .map(Json)
        .ok_or(StatusCode::NOT_FOUND)
}

use wasm_bindgen::prelude::*;

#[wasm_bindgen]
pub fn fibonacci(n: u32) -> u64 {
    if n <= 1 {
        return n as u64;
    }
    let mut a: u64 = 0;
    let mut b: u64 = 1;
    for _ in 2..=n {
        let temp = b;
        b = a + b;
        a = temp;
    }
    b
}

#[wasm_bindgen]
pub struct ImageProcessor {
    width: u32,
    height: u32,
    pixels: Vec<u8>,
}

#[wasm_bindgen]
impl ImageProcessor {
    #[wasm_bindgen(constructor)]
    pub fn new(width: u32, height: u32) -> Self {
        ImageProcessor {
            width,
            height,
            pixels: vec![0; (width * height * 4) as usize],
        }
    }

    pub fn grayscale(&mut self) {
        for chunk in self.pixels.chunks_mut(4) {
            let avg = ((chunk[0] as u16 + chunk[1] as u16 + chunk[2] as u16) / 3) as u8;
            chunk[0] = avg;
            chunk[1] = avg;
            chunk[2] = avg;
        }
    }

    pub fn pixels(&self) -> *const u8 {
        self.pixels.as_ptr()
    }
}