How do you use parent module imports in Rust?

Question

If you have a directory structure like this:

src/main.rs
src/module1/blah.rs
src/module1/blah2.rs
src/utils/logging.rs

How do you use functions from other files?

From the Rust tutorial, it sounds like I should be able to do this:

main.rs

mod utils { pub mod logging; }
mod module1 { pub mod blah; }

fn main() {
    utils::logging::trace("Logging works");
    module1::blah::doit();
}

logging.rs

pub fn trace(msg: &str) {
    println!(": {}\n", msg);
}

blah.rs

mod blah2;
pub fn doit() {
    blah2::doit();
}

blah2.rs

mod utils { pub mod logging; }
pub fn doit() {
    utils::logging::trace("Blah2 invoked");
}

However, this produces an error:

error[E0583]: file not found for module `logging`
 --> src/main.rs:1:21
  |
1 | mod utils { pub mod logging; }
  |                     ^^^^^^^
  |
  = help: name the file either logging.rs or logging/mod.rs inside the directory "src/utils"

It appears that importing down the path, i.e. from main to module1/blah.rs works, and importing peers, i.e. blah2 from blah works, but importing from the parent scope doesn't.

If I use the magical #[path] directive, I can make this work:

blah2.rs

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

pub fn doit() {
    logging::trace("Blah2 invoked");
}

Do I really have to manually use relative file paths to import something from a parent scope level? Isn't there some better way of doing this in Rust?

In Python, you use from .blah import x for the local scope, but if you want to access an absolute path you can use from project.namespace.blah import x.

Answer 1

I'm coming from Python and am new to Rust. I was also stumped by Rust's imports, but I think I have a good way of explaining via comparison.

The original project structure

src/main.rs
src/module1/blah.rs
src/module1/blah2.rs
src/utils/logging.rs

Summary

1. In the folder of your submodule, create a mod.rs and make your desired modules public. You must do this for each level if your submodule is nested in many others.
2. In the root (main.rs if binary or lib.rs if package), import the top-level parent containing your submodule.
3. In the importing module, import with use crate::.

Explanation

1. mod.rs is like __init__.py but is required for cross-module imports and is fairly strict.

While Python is forgiving if we were to import utils.logging without a utils/__init__.py, Rust is not. If we want to access anything in utils/, then we need a utils/mod.rs that declares logging as a publicly accessible module.

// src/utils/mod.rs

pub mod logging;

Let's say you also had a src/utils/formatters/numbers.rs,

// src/utils/testing/mod.rs

pub mod formatters;

// src/utils/mod.rs

// Now we can access the logging module with `utils::logging`
// and the numbers module with `utils::formatters::numbers`
pub mod logging;
pub mod formatters;

2. The root must import it, even if it isn't used in the root.

Like Python, we have to import the module for it to be brought into scope. Unlike Python, this must occur in the root of the program or library (main.rs or lib.rs) before the module can be used anywhere else.

In Python, it's okay to call import utils.logging from within src/module1/blah.py without an import utils in src/__init__.py. In Rust, that second import is required, even if the import isn't used in main.rs or lib.rs.

// src/main.rs or src/lib.rs

// This will look in utils/mod.rs and import all of its public modules,
// which will propagate down to their nested public modules
pub mod utils;

3. mod, use and crate::

Coming now is the biggest difference between Python and Rust import systems. Python has one import keyword: import. Rust, however, has two: mod and use.

If we want to use the module we made accessible in steps 1 and 2, we have to import it with use crate::<module path here>.

// src/module1/blah2.rs

// Imports all public modules in src/utils/mod.rs
// and makes them accessible with `utils::<submodule path>`
use crate::utils;

pub fn doit() {
    utils::logging::trace("Blah2 invoked");
}

More Detail

mod vs use

mod declares a block of code as a module, but does not make it usable. use creates a functional reference that you can... use.

crate::

Why is the crate:: required? It's like a self: purely for internal use.

mod.rs: The Alternative

According to the Rust book, mod.rs is the old way of doing things. The new way is to create a .rs file with the same name as your folder (e.g. src/utils.rs) and declare the public modules there. I like the distinctness of a module declaration file like mod.rs or __init__.py because it removes any ambiguity as to what is/should be in that file, but this is just a preference.

Answer 2

Answers here were unclear for me so I will put my two cents for future Rustaceans.

All you need to do is to declare all files via mod in src/main.rs (and fn main of course).

// src/main.rs

mod module1 {
    pub mod blah;
    pub mod blah2;
}
mod utils {
    pub mod logging;
}

fn main () {
    module1::blah::doit();
}

Make everything public with pub you need to use externally (copy-pasted original src/utils/logging.rs). And then simply use declared modules via crate::.

// src/module1/blah.rs

use crate::utils::logging;
// or `use crate::utils` and `utils::logging::("log")`, however you like

pub fn doit() {
  logging::trace("Logging works");
}

Think of crate:: as ~/ where ~ is the src folder of your cargo project. There's also a keyword super:: to access from current directory (like ./).

---

p.s. I shuffled functions a bit for a cleaner answer.

Answer 3

I realize this is a very old post and probably wasn't using 2018. However, this can still be really tricky and I wanted to help those out that were looking.

Because Pictures are worth a thousand words I made this simple for code splitting.

Then as you probably guessed they all have an empty pub fn some_function().

We can further expand on this via the changes to main

The additional changes to nested_mod

Let's now go back and answer the question: We added blah1 and blah2 to the mod_1 We added a utils with another mod logging inside it that calls some fn's. Our mod_1/mod.rs now contains:

pub mod blah.rs
pub mod blah2.rs

We created a utils/mod.rs used in main containing:

pub mod logging

Then a directory called logging/with another mod.rs where we can put fns in logging to import.

Source also here https://github.com/DavidWhit/Rust_Modules

Also Check Chapters 7 for libs example and 14.3 that further expands splitting with workspaces in the Rust Book. Good Luck!

Answer 4

I'm assuming you want to declare utils and utils::logging at the top level, and just wish to call functions from them inside module1::blah::blah2. The declaration of a module is done with mod, which inserts it into the AST and defines its canonical foo::bar::baz-style path, and normal interactions with a module (away from the declaration) are done with use.

// main.rs

mod utils {
    pub mod logging { // could be placed in utils/logging.rs
        pub fn trace(msg: &str) {
            println!(": {}\n", msg);
        }
    }
}

mod module1 {
    pub mod blah { // in module1/blah.rs
        mod blah2 { // in module1/blah2.rs
            // *** this line is the key, to bring utils into scope ***
            use crate::utils;

            pub fn doit() {
                utils::logging::trace("Blah2 invoked");
            }
        }

        pub fn doit() {
            blah2::doit();
        }
    }
}

fn main() {
    utils::logging::trace("Logging works");
    module1::blah::doit();
}

The only change I made was the use crate::utils; line in blah2 (in Rust 2015 you could also use use utils or use ::utils). Also see the second half of this answer for more details on how use works. The relevant section of The Rust Programming Language is a reasonable reference too, in particular these two subsections:

• Separating Modules into Different Files
• Bringing Paths into Scope with the use Keyword

Also, notice that I write it all inline, placing the contents of foo/bar.rs in mod foo { mod bar { <contents> } } directly, changing this to mod foo { mod bar; } with the relevant file available should be identical.

(By the way, println(": {}\n", msg) prints two new lines; println! includes one already (the ln is "line"), either print!(": {}\n", msg) or println!(": {}", msg) print only one.)

---

It's not idiomatic to get the exact structure you want, you have to make one change to the location of blah2.rs:

src
├── main.rs
├── module1
│   ├── blah
│   │   └── blah2.rs
│   └── blah.rs
└── utils
    └── logging.rs

main.rs

mod utils {
    pub mod logging;
}

mod module1 {
    pub mod blah;
}

fn main() {
    utils::logging::trace("Logging works");
    module1::blah::doit();
}

utils/logging.rs

pub fn trace(msg: &str) { 
    println!(": {}\n", msg); 
}

module1/blah.rs

mod blah2;

pub fn doit() {
    blah2::doit();
}

module1/blah/blah2.rs (the only file that requires any changes)

// this is the only change

// Rust 2015
// use utils; 

// Rust 2018    
use crate::utils;

pub fn doit() {
    utils::logging::trace("Blah2 invoked");
}

Answer 5

I'm going to answer this question too, for anyone else who finds this and is (like me) totally confused by the difficult-to-comprehend answers.

It boils down to two things I feel are poorly explained in the tutorial:

• The mod blah; syntax imports a file for the compiler. You must use this on all the files you want to compile.

• As well as shared libraries, any local module that is defined can be imported into the current scope using use blah::blah;.

A typical example would be:

src/main.rs
src/one/one.rs
src/two/two.rs

In this case, you can have code in one.rs from two.rs by using use:

use two::two;  // <-- Imports two::two into the local scope as 'two::'

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

However, main.rs will have to be something like:

use one::one::bar;        // <-- Use one::one::bar 
mod one { pub mod one; }  // <-- Awkwardly import one.rs as a file to compile.

// Notice how we have to awkwardly import two/two.rs even though we don't
// actually use it in this file; if we don't, then the compiler will never
// load it, and one/one.rs will be unable to resolve two::two.
mod two { pub mod two; }  

fn main() {
    bar();
}

Notice that you can use the blah/mod.rs file to somewhat alleviate the awkwardness, by placing a file like one/mod.rs, because mod x; attempts x.rs and x/mod.rs as loads.

// one/mod.rs
pub mod one.rs

You can reduce the awkward file imports at the top of main.rs to:

use one::one::bar;       
mod one; // <-- Loads one/mod.rs, which loads one/one.rs.
mod two; // <-- This is still awkward since we don't two, but unavoidable.    

fn main() {
    bar();
}

There's an example project doing this on Github.

It's worth noting that modules are independent of the files the code blocks are contained in; although it would appear the only way to load a file blah.rs is to create a module called blah, you can use the #[path] to get around this, if you need to for some reason. Unfortunately, it doesn't appear to support wildcards, aggregating functions from multiple files into a top-level module is rather tedious.

Answer 6

If you create a file called mod.rs, rustc will look at it when importing a module. I would suggest that you create the file src/utils/mod.rs, and make its contents look something like this:

pub mod logging;

Then, in main.rs, add a statement like this:

use utils::logging;

and call it with

logging::trace(...);

or you could do

use utils::logging::trace;

...

trace(...);

Basically, declare your module in the mod.rs file, and use it in your source files.