mod network {
    pub fn connect() {
        println!("连接到网络");
        // 子模块可以访问父模块的私有项
        internal_helper();
    }

    fn internal_helper() {
        println!("内部辅助函数");
    }

    pub mod http {
        pub fn get(url: &str) -> String {
            println!("GET {}", url);
            format!("响应来自 {}", url)
        }
    }
}

fn main() {
    network::connect();
    let response = network::http::get("https://example.com");
    println!("{}", response);
}

mod outer {
    pub mod inner {
        pub fn public_fn() {
            println!("公开函数");
            private_fn();
        }

        fn private_fn() {
            println!("私有函数");
        }
    }

    // pub(crate) - 对当前 crate 可见
    pub(crate) fn crate_visible() {
        println!("crate 内可见");
    }

    // pub(super) - 对父模块可见
    pub(super) fn parent_visible() {
        println!("父模块可见");
    }

    // pub(in path) - 指定路径可见
    pub(in crate::outer) fn outer_visible() {
        println!("outer 模块内可见");
    }
}

fn main() {
    outer::inner::public_fn();
    outer::crate_visible();
    // outer::parent_visible(); // ❌ 不可见
    // outer::outer_visible(); // ❌ 不可见（不在 outer 模块内）
}

mod shapes {
    pub mod circle {
        pub fn area(r: f64) -> f64 {
            std::f64::consts::PI * r * r
        }
    }

    pub mod rectangle {
        pub fn area(w: f64, h: f64) -> f64 {
            w * h
        }
    }
}

// 使用 use 引入路径
use shapes::circle;
use shapes::rectangle::area as rect_area;

fn main() {
    println!("圆形面积: {}", circle::area(5.0));
    println!("矩形面积: {}", rect_area(4.0, 6.0));
}

use std::collections::{HashMap, HashSet, BTreeMap};
use std::io::{self, Read, Write};

fn main() {
    let map: HashMap<&str, i32> = HashMap::new();
    let set: HashSet<i32> = HashSet::new();
    println!("HashMap: {}, HashSet: {}", map.len(), set.len());
}

mod internal {
    pub struct Config {
        pub host: String,
        pub port: u16,
    }

    impl Config {
        pub fn new() -> Self {
            Self {
                host: "localhost".to_string(),
                port: 8080,
            }
        }
    }
}

// 重导出：外部只需 use crate::Config
pub use internal::Config;

fn main() {
    let config = Config::new();
    println!("{}:{}", config.host, config.port);
}

// src/main.rs
mod config;
mod models;
mod utils;

use config::Config;
use models::User;

fn main() {
    let config = Config::load();
    let user = User::new("Alice", "alice@example.com");
    utils::logger::info(&format!("用户 {} 已创建", user.name));
}

// src/lib.rs
pub mod config;
pub mod models;
pub mod utils;

// 重导出常用类型
pub use config::Config;
pub use models::{User, Order};

[workspace]
members = [
    "crates/api",
    "crates/core",
    "crates/cli",
]
resolver = "2"

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

# crates/api/Cargo.toml
[package]
name = "api-server"
version = "0.1.0"
edition = "2024"

[dependencies]
core = { path = "../core" }
tokio = { workspace = true }
serde = { workspace = true }

// src/main.rs
mod routes;
mod models;
mod services;
mod middleware;

pub use models::{User, Order};
pub use services::AuthService;

fn main() {
    println!("Web 应用启动");
}

// src/models/mod.rs
pub mod user;
pub mod order;

pub use user::User;
pub use order::Order;

// src/models/user.rs
#[derive(Debug)]
pub struct User {
    pub id: u64,
    pub name: String,
    pub email: String,
}

impl User {
    pub fn new(name: &str, email: &str) -> Self {
        Self {
            id: 0,
            name: name.to_string(),
            email: email.to_string(),
        }
    }
}