浅谈Rust中声明可见性

mod my_module {
    // 私有函数，只能在 my_module 内部访问
    fn private_function() {
        println!("This is a private function.");
    }

    // 公开函数，可以在 my_module 外部访问
    pub fn public_function() {
        println!("This is a public function.");
    }
}

fn main() {
    // my_module::private_function(); // 错误：私有函数无法在模块外部访问
    my_module::public_function(); // 正确：公开函数可以在模块外部访问
}

mod parent_module {
    // 私有子模块，外部无法直接访问
    mod private_child_module {
        pub fn public_function_in_private_module() {
            println!("This function is public within a private module.");
        }
    }

    // 公开子模块，外部可以访问
    pub mod public_child_module {
        pub fn public_function_in_public_module() {
            println!("This function is public within a public module.");
        }
    }
}

fn main() {
    // parent_module::private_child_module::public_function_in_private_module(); // 错误：无法访问私有模块
    parent_module::public_child_module::public_function_in_public_module(); // 正确：可以访问公开模块中的公开函数
}

mod grandparent_module {
    pub mod parent_module {
        // 这个函数只对 grandparent_module 内部的模块可见
        pub(in grandparent_module) fn semi_private_function() {
            println!("This function is semi-private.");
        }

        pub fn public_function() {
            println!("This function is public.");
        }
    }

    pub mod another_module {
        pub fn call_semi_private_function() {
            // 可以调用，因为 another_module 与 parent_module 都在 grandparent_module 内部
            parent_module::semi_private_function();
        }
    }
}

fn main() {
    // grandparent_module::parent_module::semi_private_function(); // 错误：这个函数在 grandparent_module 外部不可见
    grandparent_module::parent_module::public_function(); // 正确：公开函数可以在任何地方访问
    grandparent_module::another_module::call_semi_private_function(); // 正确：因为调用发生在 grandparent_module 内部
}