Module 将模块作为参数传递的正确方法是什么？

我有一个模块文件（

src/map/map.rs

）：

以及

map

模块文件（

src/map/mod.rs

）：

导入main.rs，如下所示：

mod map;

use map::*;
use map::gen;

let (map, (player_x, player_y)) = Map::new(MAP_WIDTH, MAP_HEIGHT).generate_with(gen::dungeon::basic);

我希望能够像这样使用它：

mod map;

use map::*;
use map::gen;

let (map, (player_x, player_y)) = Map::new(MAP_WIDTH, MAP_HEIGHT).generate_with(gen::dungeon::basic);

我得到的错误是：

[cargo]预期值，找到模块'gen:：dungeon:：basic'：不是值[E]

---

一个完整的。

如评论中所述，模块不是这样一个具体的概念；你试图做的是不可能的

相反，您可以传递可以是值的内容：

mod basic {
    pub fn generate() -> u8 {
        0
    }
}

mod advanced {
    pub fn generate() -> u8 {
        42
    }
}

fn play_the_game(generator: fn() -> u8) {
    let dungeon = generator();
    println!("{}", dungeon);
}

fn main() {
    play_the_game(basic::generate);
    play_the_game(advanced::generate);
}

您还可以引入trait并将实现类型作为泛型传递：

trait DungeonGenerator {
    fn generate() -> u8;
}

mod basic {
    use DungeonGenerator;

    pub struct Basic;

    impl DungeonGenerator for Basic {
        fn generate() -> u8 {
            0
        }
    }
}

mod advanced {
    use DungeonGenerator;

    pub struct Advanced;

    impl DungeonGenerator for Advanced {
        fn generate() -> u8 {
            42
        }
    }
}

fn play_the_game<G>()
where
    G: DungeonGenerator,
{
    let dungeon = G::generate();
    println!("{}", dungeon);
}

fn main() {
    play_the_game::<basic::Basic>();
    play_the_game::<advanced::Advanced>();
}

trait地下城生成器{
fn generate（）->u8；
}
mod basic{
使用地下城生成器；
pub-struct-Basic；
基础的impl地下城生成器{
fn generate（）->u8{
0
}
}
}
国防部高级{
使用地下城生成器；
pub-struct-Advanced；
先进的impl地下城生成器{
fn generate（）->u8{
42
}
}
}
fn玩游戏（）
哪里
G:地下城生成器，
{
让dungeon=G:：generate（）；
println！（“{}”，地牢）；
}
fn main（）{
玩游戏：：（）；
玩游戏：：（）；
}

如评论中所述，模块不是这样的具体概念；你试图做的是不可能的

相反，您可以传递可以是值的内容：

mod basic {
    pub fn generate() -> u8 {
        0
    }
}

mod advanced {
    pub fn generate() -> u8 {
        42
    }
}

fn play_the_game(generator: fn() -> u8) {
    let dungeon = generator();
    println!("{}", dungeon);
}

fn main() {
    play_the_game(basic::generate);
    play_the_game(advanced::generate);
}

您还可以引入trait并将实现类型作为泛型传递：

trait DungeonGenerator {
    fn generate() -> u8;
}

mod basic {
    use DungeonGenerator;

    pub struct Basic;

    impl DungeonGenerator for Basic {
        fn generate() -> u8 {
            0
        }
    }
}

mod advanced {
    use DungeonGenerator;

    pub struct Advanced;

    impl DungeonGenerator for Advanced {
        fn generate() -> u8 {
            42
        }
    }
}

fn play_the_game<G>()
where
    G: DungeonGenerator,
{
    let dungeon = G::generate();
    println!("{}", dungeon);
}

fn main() {
    play_the_game::<basic::Basic>();
    play_the_game::<advanced::Advanced>();
}

trait地下城生成器{
fn generate（）->u8；
}
mod basic{
使用地下城生成器；
pub-struct-Basic；
基础的impl地下城生成器{
fn generate（）->u8{
0
}
}
}
国防部高级{
使用地下城生成器；
pub-struct-Advanced；
先进的impl地下城生成器{
fn generate（）->u8{
42
}
}
}
fn玩游戏（）
哪里
G:地下城生成器，
{
让dungeon=G:：generate（）；
println！（“{}”，地牢）；
}
fn main（）{
玩游戏：：（）；
玩游戏：：（）；
}

模块不是值，而是函数。您应该将函数作为参数。模块不是值，而是函数。你应该把函数作为参数。我决定使用第二个，因为我觉得它更适合API。我决定使用第二个，因为我觉得它更适合API。