rust 代码组织结构

src
  ╰-main.rs
Cargo.toml
Cargo.lock

error: `cargo run` could not determine which binary to run. Use the `--bin` option to specify a binary, or the `default-run` manifest key.
available binaries: cat1, cat2

// from GPT-4
在 Rust 中，一个 package 可以包含多个 bin（binary）类型的 crate，这种特性在一些场景中非常有用。

命令行工具套件：如果你正在开发一套命令行工具，每个工具都有自己的功能，但它们共享一些公共的库代码。在这种情况下，你可以为每个工具创建一个单独的 bin crate，然后将公共代码放在 lib crate 中。

多目标项目：如果你的项目需要生成多个不同的二进制文件，比如一个客户端和一个服务器，或者一个前端和一个后端，你可以为每个目标创建一个 bin crate。

示例代码：如果你正在创建一个库并且想要提供一些示例代码，你可以创建一个或多个 bin crate 来展示如何使用你的库。

在这些情况下，所有的 bin crate 都可以在同一个 package 中管理，这样可以共享版本号、依赖和构建设置，使得项目的管理变得更加方便。

// from GPT-4
在 Rust 中，一个 package 中只能有一个 library crate 的原因主要是为了简化编译和依赖管理的过程。在 package 中，library crate 的名字与 package 的名字相同，这使得在使用 cargo build 或 cargo publish 等命令时，cargo 可以明确知道应该编译或发布哪个 crate。

如果一个 package 中允许有多个 library crate，那么在处理依赖关系时，可能会产生一些复杂的问题。比如，如果两个 library crate 有相同的名字但版本不同，那么在解析依赖关系时就会产生冲突。另外，如果一个 package 中有多个 library crate，那么在编译时，cargo 也需要知道应该编译哪个 crate，这将使得编译过程变得更复杂。

总的来说，限制一个 package 中只有一个 library crate 是为了简化编译和依赖管理的过程，使得 Rust 的 package 管理系统更易于使用。

[lib]
name = "foo"           # The name of the target.
path = "src/lib.rs"    # The source file of the target.
test = true            # Is tested by default.
doctest = true         # Documentation examples are tested by default.
bench = true           # Is benchmarked by default.
doc = true             # Is documented by default.
plugin = false         # Used as a compiler plugin (deprecated).
proc-macro = false     # Set to `true` for a proc-macro library.
harness = true         # Use libtest harness.
edition = "2015"       # The edition of the target.
crate-type = ["lib"]   # The crate types to generate.
required-features = [] # Features required to build this target (N/A for lib).

pub mod math {
    pub mod arithmetic;
}

use cat::math;

fn main() {
    let sum = math::arithmetic::add(1, 2);

    println!("sum = {}", sum);
}

use cat::math::arithmetic;

fn main() {
    let sum = arithmetic::add(1, 2);

    println!("Hello, jump {}", sum);
}

pub mod outer_mod {
    pub mod inner_mod {
        // This function is visible within `outer_mod`
        pub(in crate::outer_mod) fn outer_mod_visible_fn() {}
        // Same as above, this is only valid in the 2015 edition.
        pub(in outer_mod) fn outer_mod_visible_fn_2015() {}

        // This function is visible to the entire crate
        pub(crate) fn crate_visible_fn() {}

        // This function is visible within `outer_mod`
        pub(super) fn super_mod_visible_fn() {
            // This function is visible since we're in the same `mod`
            inner_mod_visible_fn();
        }

        // This function is visible only within `inner_mod`,
        // which is the same as leaving it private.
        pub(self) fn inner_mod_visible_fn() {}
    }
    pub fn foo() {
        inner_mod::outer_mod_visible_fn();
        inner_mod::crate_visible_fn();
        inner_mod::super_mod_visible_fn();

        // This function is no longer visible since we're outside of `inner_mod`
        // Error! `inner_mod_visible_fn` is private
        //inner_mod::inner_mod_visible_fn();
    }
}

fn bar() {
    // This function is still visible since we're in the same crate
    outer_mod::inner_mod::crate_visible_fn();

    // This function is no longer visible since we're outside of `outer_mod`
    // Error! `super_mod_visible_fn` is private
    //outer_mod::inner_mod::super_mod_visible_fn();

    // This function is no longer visible since we're outside of `outer_mod`
    // Error! `outer_mod_visible_fn` is private
    //outer_mod::inner_mod::outer_mod_visible_fn();

    outer_mod::foo();
}

fn main() { bar() }

use std::fmt::Result;
use std::io::Result as IoResult;

fn f1() -> Result {}
fn f2() -> IoResult {}

use std::cmp::Ordering;
use std::io;

use std::{cmp::Ordering, io};

use std::io;
use std::io::Write;

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

use std::collections::*;

[dependencies]
rand = "0.7.0"

use rand::prelude::*;

fn main() {
    let r: bool = random(); // OK，直接使用
    println!("r = {}", r);

    let r: i32 = rand::random();  // 常规用法：通过 rand Crate name 调用
    println!("r = {}", r);
}