mod greetings {
    pub fn hello(name: &str) {
        println!("Hello, {}!", name);
    }

    pub fn goodbye(name: &str) {
        println!("Goodbye, {}!", name);
    }

    fn internal_helper() {
        // private — only usable inside this module
        println!("I am a private helper");
    }
}

fn main() {
    greetings::hello("Alice");   // Hello, Alice!
    greetings::goodbye("Alice"); // Goodbye, Alice!
    // greetings::internal_helper(); // ERROR: function is private
}

// src/main.rs
mod garden; // tells the compiler: look for src/garden.rs or src/garden/mod.rs

fn main() {
    garden::plant("tomato");
}

// src/garden.rs
pub fn plant(name: &str) {
    println!("Planting a {}", name);
}

pub fn harvest(name: &str) {
    println!("Harvesting {}", name);
}

// Project layout
// src/
//   main.rs
//   garden.rs           ← the garden module
//   garden/
//     vegetables.rs     ← submodule: garden::vegetables

// src/garden.rs
pub mod vegetables; // loads src/garden/vegetables.rs

pub fn plant(name: &str) {
    println!("Planting: {}", name);
}

// src/garden/vegetables.rs
pub struct Carrot;
pub struct Tomato;

pub fn describe(v: &str) {
    println!("{} is a vegetable", v);
}

// src/main.rs
mod garden;

fn main() {
    garden::plant("spinach");
    garden::vegetables::describe("carrot");
}

mod outer {
    pub fn public_fn() { println!("visible everywhere"); }

    pub(crate) fn crate_fn() { println!("visible within this crate only"); }

    pub(super) fn super_fn() { println!("visible to parent of outer"); }

    fn private_fn() { println!("visible only inside outer"); }

    mod inner {
        pub fn inner_public() {
            // Can call outer's private fn because inner is a child of outer
            super::private_fn();
        }
    }
}

fn main() {
    outer::public_fn();   // OK
    outer::crate_fn();    // OK — we are in the same crate
    // outer::super_fn(); // ERROR — main is not the parent module of outer
}

mod config {
    pub const MAX_RETRIES: u32 = 3;

    pub mod network {
        pub fn connect(url: &str) {
            // absolute path from the crate root
            let retries = crate::config::MAX_RETRIES;
            println!("Connecting to {} (max {} retries)", url, retries);
        }
    }

    pub mod database {
        pub fn init() {
            // relative path: super goes up to config, then into network
            super::network::connect("db://localhost");
        }
    }
}

fn main() {
    config::network::connect("https://api.example.com");
    config::database::init();
}

use std::collections::HashMap;

fn main() {
    // HashMap is now in scope — no need to write std::collections::HashMap
    let mut scores: HashMap<&str, u32> = HashMap::new();
    scores.insert("Alice", 95);
    scores.insert("Bob", 87);

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

// Instead of three separate lines:
// use std::io::Read;
// use std::io::Write;
// use std::io::BufReader;

// Write it as one:
use std::io::{Read, Write, BufReader};

// Bring both io and io::Write into scope using self:
use std::io::{self, Write};

// Glob import — brings in everything public (use sparingly)
use std::collections::*;

fn main() {
    // HashMap comes from the glob import above
    let mut map: HashMap<&str, &str> = HashMap::new();
    map.insert("lang", "Rust");
    println!("{:?}", map);
}

use std::collections::HashMap as HMap;
use std::fmt::Result as FmtResult;
use std::io::Result as IoResult;

// Without renaming, bringing both Results into scope would be ambiguous.

fn format_data() -> FmtResult {
    Ok(())
}

fn read_data() -> IoResult<()> {
    Ok(())
}

fn main() {
    let mut map: HMap<&str, i32> = HMap::new();
    map.insert("x", 42);
    println!("{:?}", map); // {"x": 42}
}

// src/lib.rs  — a library crate

mod auth;
mod user;

// Re-export the types callers actually need at the crate root.
// External users import from my_lib::User, not my_lib::user::User.
pub use auth::Session;
pub use user::User;

// src/auth.rs
pub struct Session {
    pub token: String,
}

// src/user.rs
pub struct User {
    pub name: String,
}

// External caller (another crate):
// use my_lib::User;     // works thanks to pub use
// use my_lib::Session;  // works thanks to pub use

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

pub fn is_even(n: i32) -> bool {
    n % 2 == 0
}

#[cfg(test)]
mod tests {
    use super::*; // bring everything from the parent module into scope

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

    #[test]
    fn test_is_even() {
        assert!(is_even(4));
        assert!(!is_even(7));
    }

    #[test]
    #[should_panic]
    fn test_overflow() {
        let _ = i32::MAX + 1; // panics in debug builds
    }
}

$ cargo test
running 3 tests
test tests::test_add        ... ok
test tests::test_is_even    ... ok
test tests::test_overflow   ... ok

test result: ok. 3 passed; 0 failed

pub mod geometry {
    pub mod shapes {
        #[derive(Debug)]
        pub struct Circle {
            pub radius: f64,
        }

        #[derive(Debug)]
        pub struct Rectangle {
            pub width: f64,
            pub height: f64,
        }

        impl Circle {
            pub fn area(&self) -> f64 {
                std::f64::consts::PI * self.radius * self.radius
            }
        }

        impl Rectangle {
            pub fn area(&self) -> f64 {
                self.width * self.height
            }
        }
    }

    pub mod utils {
        use super::shapes::{Circle, Rectangle};

        pub fn largest_area(c: &Circle, r: &Rectangle) -> f64 {
            c.area().max(r.area())
        }
    }
}

// Re-export the most-used types at the library root
pub use geometry::shapes::{Circle, Rectangle};
pub use geometry::utils::largest_area;

fn main() {
    let c = Circle { radius: 3.0 };
    let r = Rectangle { width: 4.0, height: 5.0 };

    println!("Circle area:    {:.2}", c.area());
    println!("Rectangle area: {:.2}", r.area());
    println!("Largest:        {:.2}", largest_area(&c, &r));
}