Learn Modern Rust for Python and Javascript Developers

use rand::Rng; // Brings random number generation traits into scope
use std::cmp::Ordering;
use std::io;

fn main() {
    // 1..=100 is an inclusive range. thread_rng() is local to the current thread.
    let secret_number = rand::thread_rng().gen_range(1..=100);
    println!("Guess the number between 1 and 100!");

    loop {
        // Variables are immutable by default in Rust. 'mut' makes it mutable.
        let mut guess = String::new(); 
        
        io::stdin()
            // We pass a mutable reference (&mut) to our string buffer so read_line can append to it
            .read_line(&mut guess)
            // .expect() crashes the program gracefully with a custom message if an IO error occurs
            .expect("Failed to read line"); 

        // Shadowing: We reuse the variable name 'guess' to parse it into an unsigned 32-bit int (u32)
        // match forces us to handle both the Ok (success) and Err (failure) states.
        let guess: u32 = match guess.trim().parse() {
            Ok(num) => num,
            Err(_) => {
                println!("Please type a valid number!");
                continue; // Skips to the next loop iteration
            }
        };

        // cmp returns an Ordering enum. We must exhaustively match all 3 possibilities.
        match guess.cmp(&secret_number) {
            Ordering::Less => println!("Higher!"),
            Ordering::Greater => println!("Lower!"),
            Ordering::Equal => {
                println!("You win!");
                break;
            }
        }
    }
}

use rand::Rng;
use std::io::{self, Write};

fn main() {
    let mut rng = rand::thread_rng();
    println!("Solve the addition problems! Type 'quit' to exit.");

    loop {
        let a: i32 = rng.gen_range(1..=10);
        let b: i32 = rng.gen_range(1..=10);
        
        // print! doesn't automatically output to the terminal until a newline is sent.
        // We must manually flush the stdout buffer so the user sees the prompt before typing.
        print!("What is {} + {}? ", a, b);
        io::stdout().flush().unwrap();

        let mut input = String::new();
        io::stdin().read_line(&mut input).unwrap(); // unwrap() assumes it will never fail
        
        // .trim() removes the hidden \n or \r\n captured when the user pressed Enter
        let input = input.trim(); 

        // String comparison in Rust is straightforward using ==
        if input == "quit" {
            println!("Thanks for playing!");
            break;
        }

        // Match Guards: Notice `if answer == a + b` inside the match arm!
        // This allows complex conditional logic directly inside pattern matching.
        match input.parse::() {
            Ok(answer) if answer == a + b => println!("Correct!"),
            Ok(_) => println!("Wrong! It was {}.", a + b),
            Err(_) => println!("Please enter a number or 'quit'."),
        }
    }
}

use rand::Rng;
use std::io::{self, Write};

// Enums in Rust are incredibly powerful and form the backbone of safe State Machines
enum Operation { Add, Multiply }
enum AppState { Menu, Playing, Quit }

// Structs hold our complex data types
struct Settings {
    min: i32,
    max: i32,
    op: Operation,
}

// Day-to-day Best Practice: Implement a constructor using an `impl` block
impl Settings {
    // `Self` refers to the `Settings` struct itself
    fn new() -> Self {
        Self { min: 1, max: 10, op: Operation::Add }
    }
}

fn main() {
    let mut state = AppState::Menu;
    let mut settings = Settings::new();

    loop {
        // match on an Enum in Rust is Exhaustive. 
        // If you add a new state later and forget it here, the code WILL NOT compile.
        match state {
            AppState::Menu => {
                print!("1. Play  2. Set Multiply  3. Quit\n> ");
                io::stdout().flush().unwrap();
                let mut input = String::new();
                io::stdin().read_line(&mut input).unwrap();
                
                match input.trim() {
                    "1" => state = AppState::Playing,
                    "2" => {
                        settings.op = Operation::Multiply;
                        println!("Operation set to Multiplication.");
                    },
                    "3" => state = AppState::Quit,
                    _ => println!("Invalid option."),
                }
            }
            AppState::Playing => {
                let mut rng = rand::thread_rng();
                let a = rng.gen_range(settings.min..=settings.max);
                let b = rng.gen_range(settings.min..=settings.max);
                
                // We can assign the result of a match statement directly to variables
                let (symbol, correct) = match settings.op {
                    Operation::Add => ("+", a + b),
                    Operation::Multiply => ("*", a * b),
                };

                print!("What is {} {} {}? (type 'menu' to go back) ", a, symbol, b);
                io::stdout().flush().unwrap();
                
                let mut input = String::new();
                io::stdin().read_line(&mut input).unwrap();
                
                if input.trim() == "menu" {
                    state = AppState::Menu;
                    continue; // Jumps back to the top of the loop, processing the Menu state next
                }
                
                // `if let` allows us to pattern match a single scenario safely without a full `match` block
                if let Ok(ans) = input.trim().parse::() {
                    if ans == correct { println!("Correct!"); } 
                    else { println!("Wrong, it was {}", correct); }
                }
            }
            AppState::Quit => break,
        }
    }
}

use rand::seq::SliceRandom;
use std::io::{self, Write};

// #[derive] macros automatically generate boilerplate code for you at compile time!
// `Clone` lets you duplicate the struct. `Debug` lets you print it easily with `{:?}`.
#[derive(Debug, Clone)]
struct Flashcard {
    question: String,
    answer: String,
}

impl Flashcard {
    // Helper function to keep initialization clean. 
    // We accept `&str` (string slices) and convert them to owned `String` types inside.
    fn new(q: &str, a: &str) -> Self {
        Self {
            question: q.to_string(),
            answer: a.to_string(),
        }
    }
}

fn main() {
    // `vec![]` is a macro that creates a resizable Vector (like JS arrays or Python lists)
    let mut deck = vec![
        Flashcard::new("Capital of France?", "Paris"),
        Flashcard::new("2 ** 8?", "256"),
        Flashcard::new("Rust package manager?", "Cargo"),
    ];

    let mut rng = rand::thread_rng();
    // Shuffles the vector in place. Requires `rand::seq::SliceRandom` in scope.
    deck.shuffle(&mut rng); 

    // Day-to-day feature: Iterators!
    // Using `.iter()` allows us to loop through *immutable references* of the cards 
    // without destroying 'deck'
    for card in deck.iter() {
        print!("Q: {} (Press Enter)", card.question);
        io::stdout().flush().unwrap();
        
        let mut _discard = String::new();
        io::stdin().read_line(&mut _discard).unwrap();
        
        println!("A: {}\n", card.answer);
    }
    
    // Because we used `.iter()` above, the deck wasn't "moved" and is still alive here!
    // We can print the entire vector because of #[derive(Debug)]
    println!("Deck completed: {:?}", deck);
}

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

// Returning std::io::Result<()> allows us to use the `?` error-bubbling operator inside main
fn main() -> std::io::Result<()> {
    let downloads_dir = Path::new("./downloads_test");
    
    if !downloads_dir.exists() {
        // The `?` at the end instantly returns the error to the caller if create_dir fails
        // This completely eliminates the need for deeply nested try/catch blocks!
        fs::create_dir(downloads_dir)?; 
    }

    // read_dir returns an iterator over directory entries
    for entry in fs::read_dir(downloads_dir)? {
        let entry = entry?;
        let path = entry.path();

        if path.is_file() {
            // Option Chaining: Extracts the extension safely, converting it to a standard str
            if let Some(ext) = path.extension().and_then(|e| e.to_str()) {
                
                // Pattern matching against string slices
                let folder_name = match ext.to_lowercase().as_str() {
                    "pdf" | "docx" | "txt" => "Documents",
                    "jpg" | "png" | "mp4" => "Media",
                    "zip" | "tar" | "gz" => "Compressed",
                    _ => "Others",
                };

                let target_dir = downloads_dir.join(folder_name);
                fs::create_dir_all(&target_dir)?; // acts like `mkdir -p`

                let file_name = path.file_name().unwrap();
                let new_path = target_dir.join(file_name);

                // Day-to-day Gotcha: fs::rename fails if moving between different drives/mounts!
                // Best practice is to try rename, and fallback to copy + remove if it fails.
                if fs::rename(&path, &new_path).is_err() {
                    fs::copy(&path, &new_path)?;
                    fs::remove_file(&path)?;
                }
                
                println!("Moved {:?} to {:?}", file_name, target_dir);
            }
        }
    }
    
    // Ok(()) is the unit type indicating successful completion
    Ok(())
}