How do I “use” or import a local Rust file? [duplicate]

by

There are basically two (main) ways in Rust to include code from somewhere else:

1. “Including” internal code

If your include_me.rs belongs to your project, you should move it to the same folder main.rs lies in:

└── src
    ├── include_me.rs
    └── main.rs

Then you can write this in your main.rs:

mod include_me;

fn main() {
    // Call a function defined in the other file (module)
    include_me::some_function();
}

A mod declaration makes the Rust compiler look for the corresponding .rs files automatically!

So everything that belongs to your project, belongs in the same folder (or a subfolder thereof) as the folder where main.rs (or lib.rs) is lying. The files are then “included” via the module system. To read a good introduction into modules, please read the chapter on modules in the Rust book. You could also check out Rust by Example on that topic. The module system is pretty central and thus important to learning Rust.

2. “Including” external code

If your include_me.rs is something that doesn’t belong to your actual project, but is rather a collection of useful things you are using in multiple projects, it should be seen as a library. To include code of such external libraries, you have to include it as an extern crate. And to make your life easier, you really want to use Cargo!

So let’s prepare your include_me.rs as Cargo library project. You need the following file structure (which is automatically generated by cargo new my_library --lib):

. my_library
  ├── Cargo.toml
  └── src
      └── lib.rs

Now copy all the contents from include_me.rs into lib.rs (it is just convention to call the root file of a library project lib.rs). Let’s say that the my_library folder’s full path is ~/code/my_library.

Now let’s prepare your main project’s Cargo project. It has a similar file
structure (but a main.rs instead of lib.rs, because it’s a executable-project, not a library-project):

. my_project
├── Cargo.toml
└── src
    └── main.rs

To declare your dependency on my_library, you have to put this into your Cargo.toml:

[package]
name = "my_project"
version = "0.1.0"
authors = ["you"]
edition = "2018"

[dependencies]
my_library = { path = "~/code/my_library" }

You can also use relative paths ("../my_library"), but it only makes sense if you know that the two projects always stay where they are, relative to one another (like if they are both managed in the same repository).

Now you can, in your main.rs, write:

use my_library::some_function;

fn main() {
    // Call a function defined in the other file (extern crate)
    some_function();
}

If you want to upload any of those two projects, you have to interact with crates.io (or another crates registry, if your company has one), but this is another topic.

(Note: some time ago, it was necessary to write extern crate my_library; inside main.rs. This is not necessary anymore, but you might find old code with extern crate declarations.)

Any other ways?

Yes, but you shouldn’t use those. There is the include!() macro which allows you to verbatim include other files, just like the #include from C-land. However, it is strongly discouraged to use this in situations where the module system would be able to solve your problem. include!() is only useful in very special situations, often linked to a more complex build system which generates code.

More Related Contents:

  1. How do I import from a sibling module?
  2. How to include files from same directory in a module using Cargo/Rust?
  3. How to use custom packages
  4. Is it possible to import a whole directory in sass using @import?
  5. Can variables be used in import statements for Sass files?
  6. When using SASS how can I import a file from a different directory?
  7. Angular2 & TypeScript importing of node_modules
  8. Relative import from parent directory
  9. Proper way to return a new string in Rust
  10. Double mutable borrow error in a loop happens even with NLL on
  11. How to return a reference to a sub-value of a value that is under a mutex?
  12. In Rust, what’s the difference between “shadowing” and “mutability”?
  13. How to use struct self in member method closure
  14. How do I convert a C string into a Rust string and back via FFI?
  15. How to import initial data to database with Hibernate?
  16. How can I import an Excel file into SQL Server? [closed]
  17. Is there a way to create a function pointer to a method in Rust?
  18. Return an async function from a function in Rust
  19. How to implement `serde::Serialize` for a boxed trait object?
  20. Borrow two mutable values from the same HashMap
  21. Python, doing conditional imports the right way
  22. Expected bound lifetime parameter, found concrete lifetime [E0271]
  23. How do I perform iterator computations over iterators of Results without collecting to a temporary vector?
  24. Creating a vector of zeros for a specific size
  25. How to check release / debug builds using cfg in Rust?
  26. What is the difference between immutable and const variables in Rust?
  27. What does it mean to instantiate a Rust generic with an underscore?
  28. Can I import from multiple packages all at once in Scala?
  29. How to print structs and arrays?
  30. Can Rust optimise away the bit-wise copy during move of an object someday?

Leave a Comment