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

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!");
}

---

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()`");
}

---

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();
}

---

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;

---

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();
}

---

its a faily simple approach in solving this, you need to add mod into the main.rs file, for its to be accessible throughout the file tree

---