basic/crate-module/use

[giscus[bot]]

basic/crate-module/use

https://course.rs/basic/crate-module/use.html

[jyutjyu]

有点复杂。

[caoxiemeihao]

+10086

[jyutjyu]

这里内容不够全。建议介绍不同目录的代码文件的引用，即代码文件分布在不同目录时，怎样使用。
例如，有2个方法组织代码目录，方法1是每个目录下都有自己的mod文件即mod.rs，方法2是每个目录的同层级都有对应同名的rs文件。

[tianshimoyi]

use 和 pub use 到底什么区别啊？求大佬指教

[lijing-2008]

use在当前作用域有用，只是一个简写，加上了pub就会对外暴露出去，当前模块的父模块之类可以使用

[xpader]

是的，目录间的模块这么重要的部分居然没讲。

[zhangdekui]

在 Rust 语言中，mod.rs 文件是一种特殊的文件名，它通常用于实现模块（module）的组织和管理。

具体来说，当我们在 Rust 语言中创建一个模块时，通常会在模块所在的目录下创建一个名为 mod.rs 的文件。这个 mod.rs 文件中通常包含了该模块的所有公共 API 的定义。

举个例子，假设我们有一个名为 my_module 的模块，它的目录结构如下：

my_module/
├── mod.rs
├── foo.rs
└── bar.rs

其中，mod.rs 文件用于定义 my_module 模块的公共 API，而 foo.rs 和 bar.rs 文件则用于实现这些 API。

在 mod.rs 文件中，通常会使用 pub use 语法来导出该模块中的公共 API，例如：

pub use foo::my_function1;
pub use bar::my_function2;

在这个示例中，我们使用 pub use 语法将 foo 模块中的 my_function1() 函数和 bar 模块中的 my_function2() 函数导出为 my_module 模块的公共 API。

总之，mod.rs 文件是 Rust 语言中非常常用的一个文件，它可以帮助我们组织和管理模块，并实现代码的可重用性和可读性。

[zhangdekui]

from chatgpt:

[yoyoLooming]

怎么在我的项目里用这个restaurant呢..

[licq]

不知道后边有没有分享真实项目package, crate, module的使用的，因为这里不仅是规则上的问题，更多的是一种最佳实践。

[sunface]

practice.rs 上有更详细的练习

[sunfu12]

讲得非常清楚，看懂了，太棒了

[Roxannej]

还是要用起来才知道

[Roxannej]

这个文件夹的问题还是要实践

[xiandaoyan]

引入项再导出---的pub use没看懂，在另一个文件中引入mod之后pub use照样不能访问其中的非pub模块都嘛？请高手赐教

[mattwhatsup]

pub(self)只在当前模块可见有什么意义呢？模块内部的同级本来私有的也是可见的，这是私有的默认定义吗？

[mgisr]

Stack Overflow上有关于这个问题的解释。How is pub(self) visibility different from no pub attribute?

[arielherself]

TL;DR 就是跟没有一样

[Endermanbugzjfc]

https://github.com/rust-lang/rfcs/blob/master/text/1422-pub-restricted.md#semantics 似乎是在宏的时候有些许用处

[Icemans007]

我感觉，pub, pub(crate), pub(super), 没有pub, pub(self), pub(in <path>) 这些限定的可见性都是针对此模块的外层模块？此模块子孙模块照样可以访问

[yxxuweb]

我没看明白受限的可见性那块的描述。代码上给点注释啊。

[Risuntsy]

lib.rs

// lib.rs
pub mod a {
}

main.rs

// main.rs
// 
use test::a;

fn main() {}
 

Cargo.toml

[package]
name = "test"
version = "0.1.0"
edition = "2021"

这样写可以通过cargo编译，但是VS Code报错提示:

error[E0425]: cannot find function `test_main_static` in crate `test`

我有些疑惑默认lib.rs和main.rs中模块的关系

[Risuntsy]

cargo test输出如下

Compiling test v0.1.0 (../Test)
	error[E0425]: cannot find function `test_main_static` in crate `test`

warning: unused import: `test::a`
 --> src\main.rs:1:5
  |
1 | use test::a;
  |     ^^^^^^^
  |
  = note: `#[warn(unused_imports)]` on by default

For more information about this error, try `rustc --explain E0425`.
warning: `test` (bin "test" test) generated 1 warning
error: could not compile `test` (bin "test" test) due to previous error; 1 warning emitted

[Risuntsy]

草，好像是项目名称为test时有某种冲突，其他名称就不会有问题了

[rucat125]

https://www.cnblogs.com/fire-cat/p/17578600.html
这是我自己总结的关于分文件规划模块的随笔，大家帮忙看看有没有什么不对和遗漏的。
水平有限，多多包涵😊

[CamaroW]

大佬写的很好，这篇文章中都没有给那么具体的文件结构和各文件里的“模块引入”例子。不过最下面那里，我有一个小疑问/发现。

原代码及描述：

// main.rs
fn main() {
    println!("hello world");
}

pub fn main_fn() {
    println!("main_fn");
}

// file.rs
pub fn run_main_fn() {
    crate::main_fn();
    super::main_fn();
}

在 main.rs 中的函数可以使用模块路径来调用。并且由上代码可知，并不需要将 file.rs 挂载到模块树（不挂载到模块树只是对模块使用有影响，对于模块路径没有影响）。

这里我感觉虽然在这种情况下 package 仍然可以编译成功，但是若想真的在运行时调用到 run_main_fn 函数的话，还是避免不了在 main.rs 中引出模块 file 的（挂载到模块树）。我的理解就是如果不挂载到树，那么这个模块就是一个独立的 (isolated)，没有和主树连接的边 (edge)。那么，就算可以编译，其实也是没有办法调用到的。

举例论证：
————————————
我们可能会想到创建另一个模块 mod_1，用这个模块中的函数调用 run_main_fn 函数，然后只挂载 mod_1 模块（在 main.rs 中引出它）。这样就可以在 main.rs 中使用 mod_1::call_run_main_fn() 来绕一大圈最后调用 main_fn：

// main.rs
fn main() {
    println!("hello world");
    // mod_1::call_run_main_fn()
}

pub fn main_fn() {
    println!("main_fn");
}

mod mod_1;

// file.rs
pub fn run_main_fn() {
    crate::main_fn();
    super::main_fn();
}

// mod_1.rs
pub fn call_run_main_fn() {
    crate::file::run_main_fn();
    // or
    super::file::run_main_fn();
}

但是，在这种情况下其实是无法编译的，会在 mod_1 中的 crate::file::run_main_fn(); 处提示无法找到 file 模块（“failed to resolve: could not find `file` in the crate root”）。也就是说，我们仍然需要挂载 file 模块到模块树，不然 crate::file 这条路径根本不存在，因为 crate 和 file 节点之间根本没有边连接
————————————

而且，说到底，对于这种 isolated 的模块来说，我发现其实它们无论怎么写，都是可以成功编译 package 的，甚至你可以直接这么写：

// file.rs
pub fn run_main_fn() {
    crate这么写::main_fn();
    super:或者:ma这in_f样n();
}

这应该也算回答了你在文章中给出的猜测：

个人猜测，rust编译器不会编译不在模块树上的模块。

因为如果它编译了 file.rs 文件，编译就一定不会通过。

[jareguo]

总结：

• 每个目录都是一个模块，要在目录旁边定义一个同名 rs 文件，或者包含一个 mod.rs，作用类似于 index.js
• [mod.rs](http://mod.rs) 和同名 rs 文件为空的话将创建空模块，如果要引入目录中的其它文件就需要在此文件中声明
• 每个 rs 文件都是一个模块，但只有被其它模块引入时才会被编译
• mod xxx; 或 pub mod xxx; 才是真正加载模块的语句。后者将同时导出子模块。
• pub use 用来导出已加载的模块中的任意 pub 项，pub use [xxx::]yyy as zzz; 会以 zzz 的名字重新导出 yyy。
• 光秃秃的 use 只是语法糖。

[Risuntsy]

use是什么语法糖??
pub mod是导出时暴露模块到当前命名空间，供外部访问，如果一个pub mod内都是private那样对其他模块来说也没什么意义

[jareguo]

use是什么语法糖??

我说的是光秃秃的 use，相对 pub use 而言的。就是你在行首写一行 use std::xxx，跟在下面 xxx.yyy 的每个地方都写上 std::xxx.yyy 不是一样吗？

pub mod是导出时暴露模块到当前命名空间，供外部访问，如果一个pub mod内都是private那样对其他模块来说也没什么意义

没错，只是我用我的语言总结了一下，作为官方标准定义的补充吧。意思跟你说的没区别。

[Icemans007]

感到有点意外是，例子中使用第三方的 rand package，在模块内使用却没有类似 use rand，和其他编程语言有不同，其他语言类似导入作用域意思，但这个 use 它没有半点导入意思，感觉更像是在此模块内命名申明

[yhm-amber]

但对于 trait 就没有这么简单了。一般有

use a::b::Sometrait as _;

这种写法，它并不会让你在接下来能直接使用 Sometrait ，但它仍然有意义，因为没有它的话，编译器不允许你用 a.f(c) 的形式调用方法，你只能写 a::b::Sometrait::f(&a, c) 这样的形式。我也完全没找到 a 写在 f 左边的形式还可以怎么丰富。

[sanrentai]

绕迷糊了

[upWooStream]

pub(self) 在当前模块可见的意义何在？如果只是当前模块可见，直接不使用pub就可以了吗？

[Endermanbugzjfc]

https://github.com/rust-lang/rfcs/blob/master/text/1422-pub-restricted.md#semantics 似乎是在宏的时候有些许用处

[Quaternijkon]

有点不太优雅

[Skyfacon]

打卡

[vince-1998]

2.12 竟然是我看的最懵逼的一章，莫非是我心态轻浮了。。。

[yuzheng14]

受限的可见性这里举的例子不太合适

// 目标：`a` 导出 `I`、`bar` and `foo`，其他的不导出
pub mod a {
    pub const I: i32 = 3;

    fn semisecret(x: i32) -> i32 {
        use self::b::c::J;
        x + J
    }

    pub fn bar(z: i32) -> i32 {
        semisecret(I) * z
    }
    pub fn foo(y: i32) -> i32 {
        semisecret(I) + y
    }

    mod b {
        mod c {
            const J: i32 = 4;
        }
    }
}

这里本身函数 semisecret 和模块 b 在同一个模块下，semisecret 是可以访问到模块 b 的，所以只需要给模块 c 和常量 J 标记为 pub 即可，与 pub(in crate::a) 的实际作用一样。完整代码如下：

// 目标：`a` 导出 `I`、`bar` and `foo`，其他的不导出
pub mod a {
    pub const I: i32 = 3;

    fn semisecret(x: i32) -> i32 {
        use self::b::c::J;
        x + J
    }

    pub fn bar(z: i32) -> i32 {
        semisecret(I) * z
    }
    pub fn foo(y: i32) -> i32 {
        semisecret(I) + y
    }

    mod b {
        pub mod c {
            pub const J: i32 = 4;
        }
    }
}

[idnsunset]

是的，b 的私有已经限制了外部代码通过 a::b::c::J 这条路径访问 c 和 J。

[zhoulian1193]

怎么用lib.rs查找包啊，没看懂

[jokiclll]

模块mod这块不太复杂，但可见性这块挺复杂的，结合实战继续学习吧！

[PigsyAK]

二刷，觉得更加牛逼了

[PigsyAK]

常读常新

[idnsunset]

感觉限制可见性的例子不够典型。a 模块中的 b 模块本身就是私有的，它只对 a 可见，外部代码是无法通过 a::b::c::J 这种方式访问到 J 的。 所以只要把 c 和 J 都 pub 出来不就行了么？

[CamaroW]

给最后一个例子又加了一些使用情况，也算是一个笔记吧，供参考。有不对的地方也请大佬们指出，不要不小心误导了别人。

// 一个名为 `my_mod` 的模块
mod my_mod {
    // 模块中的项默认具有私有的可见性
    fn private_function() {
        println!("called `my_mod::private_function()`");
    }

    // 使用 `pub` 修饰语来改变默认可见性。
    pub fn function() {
        println!("called `my_mod::function()`");
    }

    // 在同一模块中，项可以访问其它项，即使它是私有的。
    pub fn indirect_access() {
        print!("called `my_mod::indirect_access()`, that\n> ");
        private_function();
    }

    // 模块也可以嵌套
    pub mod nested {
        pub fn function() {
            println!("called `my_mod::nested::function()`");
        }

        #[allow(dead_code)]
        fn private_function() {
            println!("called `my_mod::nested::private_function()`");
        }

        // 使用 `pub(in path)` 语法定义的函数只在给定的路径中可见。
        // `path` 必须是父模块（parent module）或祖先模块（ancestor module）
        pub(in crate::my_mod) fn public_function_in_my_mod() {
            print!("called `my_mod::nested::public_function_in_my_mod()`, that\n > ");
            public_function_in_nested()
        }

        // 使用 `pub(self)` 语法定义的函数则只在当前模块中可见。
        pub(self) fn public_function_in_nested() {
            println!("called `my_mod::nested::public_function_in_nested");
        }

        // 使用 `pub(super)` 语法定义的函数只在父模块中可见。
        pub(super) fn public_function_in_super_mod() {
            println!("called my_mod::nested::public_function_in_super_mod");
        }
    }

    pub fn call_public_function_in_my_mod() {
        print!("called `my_mod::call_public_funcion_in_my_mod()`, that\n> ");
        nested::public_function_in_my_mod();
        print!("> ");
        nested::public_function_in_super_mod();
    }

    // `pub(crate)` 使得函数只在当前包中可见
    pub(crate) fn public_function_in_crate() {
        println!("called `my_mod::public_function_in_crate()");
    }

    // 嵌套模块的可见性遵循相同的规则
    mod private_nested {
        #[allow(dead_code)]
        pub fn function() {
            println!("called `my_mod::private_nested::function()`");
        }
        // Arrow: 父模块中的项（即使私有）对子模块可见，所以可以直接调用
        pub fn call_private_function_in_super() {
            print!("called `my_mod::private_nested::call_private_function_in_super`, that\n > ");
            super::private_function();
        }
        // Arrow: 私有模块内嵌套私有模块，目的是展示用“再导出”方法调用多层私有模块下的 `pub` 函数，和文章中“受限的可见性”章节的第一种方法一样
        mod private_nested_nested {
            pub fn call_private_function_in_super() {
                print!("called `my_mod::private_nested::private_nested_nested::call_private_function_in_super`, that\n > ");
                super::super::private_function();
            }
        }
        // Arrow: 再导出函数，以便 `private_nested` 访问，改名的目的是避免 `private_nested` 下出现两个 `call_private_function_in_super` 函数
        pub use self::private_nested_nested::call_private_function_in_super as c_p_f_i_s;
        
    }
    // Arrow: 没理解错的话，下面两行应该是等价的？不过现实中可能没有人会用第二行那种方法。这两行只能留一个，因为现在是同名的
    pub use private_nested::call_private_function_in_super;
    // pub fn call_private_function_in_super() { self::private_nested::call_private_function_in_super(); }
    
    // Arrow: 再导出函数，以便 `my_mod` 访问
    pub use private_nested::c_p_f_i_s;
    
    // Arrow: 同级时，项访问其他私有模块中的 `pub` 项。最上面的 `indirect_access` 访问的是同级私有函数，我不确定模块是不是也行，所以试了这个
    pub fn indirect_access_private_nested() {
        print!("called `my_mod::indirect_access_private_nested`, that\n> ");
        private_nested::call_private_function_in_super();
    }
}

fn function() {
    println!("called `function()`");
}

fn main() {
    // 模块机制消除了相同名字的项之间的歧义。
    function();
    my_mod::function();

    // 公有项，包括嵌套模块内的，都可以在父模块外部访问。
    my_mod::indirect_access();
    my_mod::nested::function();
    my_mod::call_public_function_in_my_mod();

    // pub(crate) 项可以在同一个 crate 中的任何地方访问
    my_mod::public_function_in_crate();

    // pub(in path) 项只能在指定的模块中访问
    // 报错！函数 `public_function_in_my_mod` 是私有的
    //my_mod::nested::public_function_in_my_mod();
    // 试一试 ^ 取消该行的注释

    // 模块的私有项不能直接访问，即便它是嵌套在公有模块内部的

    // 报错！`private_function` 是私有的
    //my_mod::private_function();
    // 试一试 ^ 取消此行注释

    // 报错！`private_function` 是私有的
    //my_mod::nested::private_function();
    // 试一试 ^ 取消此行的注释

    // 报错！ `private_nested` 是私有的
    //my_mod::private_nested::function();
    // 试一试 ^ 取消此行的注释
    
    // Arrow
    my_mod::indirect_access_private_nested();
    // Arrow: 导出自 `my_mod::private_nested` 的 `call_private_function_in_super` 函数
    my_mod::call_private_function_in_super();
    // Arrow: 导出自 `my_mod::private_nested::private_nested_nested` 的 `call_private_function_in_super` 函数
    my_mod::c_p_f_i_s();
    
    // Arrow: 在这种情况下，这三条是等价的。前两条是永远等价的，第二条只是省略了 `self`。但是第三条，当模块不在根模块下时，也许会需要额外路径。
    self::my_mod::function();
    my_mod::function();
    // Arrow: 下面是绝对路径，上面两个是相对路径。
    crate::my_mod::function();
}

[Marsanor]

三兄弟更短了👍🤣

[yhm-amber]

但是对于 trait 就没法儿不用 use 了。除非对对象用 as 转换成 &dyn Sometrait 才能正常用 a.b(c) 的形式： (a as &dyn Sometrait).b(c) 。

但这还需要这个 Trait 允许被 dyn ，而不至于需要 Sized 。