How can I include a module from another file from the same project?

Question

By following this guide I created a Cargo project.

src/main.rs

fn main() {
    hello::print_hello();
}

mod hello {
    pub fn print_hello() {
        println!("Hello, world!");
    }
}

which I run using

cargo build && cargo run

and it compiles without errors. Now I'm trying to split the main module in two but cannot figure out how to include a module from another file.

My project tree looks like this

├── src
    ├── hello.rs
    └── main.rs

and the content of the files:

src/main.rs

use hello;

fn main() {
    hello::print_hello();
}

src/hello.rs

mod hello {
    pub fn print_hello() {
        println!("Hello, world!");
    }
}

When I compile it with cargo build I get

error[E0432]: unresolved import `hello`
 --> src/main.rs:1:5
  |
1 | use hello;
  |     ^^^^^ no `hello` external crate

I tried to follow the compiler's suggestions and modified main.rs to:

#![feature(globs)]

extern crate hello;

use hello::*;

fn main() {
    hello::print_hello();
}

But this still doesn't help much, now I get this:

error[E0463]: can't find crate for `hello`
 --> src/main.rs:3:1
  |
3 | extern crate hello;
  | ^^^^^^^^^^^^^^^^^^^ can't find crate

Is there a trivial example of how to include one module from the current project into the project's main file?

Answer 1

You don't need the mod hello in your hello.rs file. Code in any file but the crate root (main.rs for executables, lib.rs for libraries) is automatically namespaced in a module.

To include the code from hello.rs in your main.rs, use mod hello;. It gets expanded to the code that is in hello.rs (exactly as you had before). Your file structure continues the same, and your code needs to be slightly changed:

main.rs:

mod hello;

fn main() {
    hello::print_hello();
}

hello.rs:

pub fn print_hello() {
    println!("Hello, world!");
}

Answer 2

If you wish to have nested modules...

Rust 2018

It's no longer required to have the file mod.rs (although it is still supported). The idiomatic alternative is to name the file the name of the module:

$ tree src
src
├── main.rs
├── my
│   ├── inaccessible.rs
│   └── nested.rs
└── my.rs

main.rs

mod my;

fn main() {
    my::function();
}

my.rs

pub mod nested; // if you need to include other modules

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

Rust 2015

You need to put a mod.rs file inside your folder of the same name as your module. Rust by Example explains it better.

$ tree src
src
├── main.rs
└── my
    ├── inaccessible.rs
    ├── mod.rs
    └── nested.rs

main.rs

mod my;

fn main() {
    my::function();
}

mod.rs

pub mod nested; // if you need to include other modules

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

Answer 3

I really like Gardener's response. I've been using the suggestion for my module declarations.

./src
├── main.rs
├── other_utils
│   └── other_thing.rs
└── utils
    └── thing.rs

File main.rs

#[path = "utils/thing.rs"] mod thing;
#[path = "other_utils/other_thing.rs"] mod other_thing;

fn main() {
  thing::foo();
  other_thing::bar();
}

File utils/thing.rs

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

File other_utils/other_thing.rs

#[path = "../utils/thing.rs"] mod thing;

pub fn bar() {
  println!("bar");
  thing::foo();
}

Answer 4

In a non main.rs (or lib.rs) file if you want to include from a file in the same directory then the code below works. The key is to use the word super:: for the include. (This is how I rewrote the answer of rodo without using path.)

Directory tree:

src
├── main.rs
├── my.rs
└── my
    ├── a.rs
    └── b.rs

To include a.rs in b.rs:

File src/my/a.rs

pub fn function() {
    println!("src/my/a.rs/function()");
}

File src/my/b.rs

use super::b::function;

fn f2() {
    function();
}

File src/my.rs

mod a;
mod b;

File src/main.rs

mod my;

Answer 5

As of 2022

├── src
├── main.rs
├── scripts
│   └── func.rs
└── scripts.rs

If I want to call the functions from the func.rs file (which are inside the scripts folder), I created a so-called "linking" file in the root directory the same as the folder's name (it's not necessary to have the linking file name and the folder name the same).

Content of file scripts/func.rs:

pub fn sayHello(){
    println!("Hello, World!");
}

In the scripts.rs file I have:

pub(crate) mod func;

Then in my main.rs file I have called the sayHello() function as below:

mod scripts;
fn main() {
    scripts::func::sayHello();
}

Answer 6

There's sort of two cases to this question, and the answers I've seen so far only cover one case: when you have a main.rs, and a.rs, and a b.rs, all in the same directory, but you want to use functions from a.rs or b.rs in main.rs, but I haven't seen anyone cover the opposite case, so I'll do that here.

Given main.rs, a.rs, and b.rs all in the same directory, and you want to use functions from B in A, or B in A:

In main.rs

mod a;
mod b;

use crate::a::*;
use crate::b::*;

// To call a function from a.rs, do:
a::my_function_from_a();

In a.rs

use crate::b;

// To call a function from b.rs, do:
super::b::my_function_from_b();

The super keyword in a.rs is where the magic happens. Annoyingly, the behavior is different than the Ruby version of super.

If you don't use the super keyword you'll get the dreaded: [E0433] use of undeclared crate or module.