I used to just do use modulename – then, as my application grew, I found it more and more difficult to find the source to functions (without turning to grep) – some of the other code floating around the office still uses a one-subroutine-per-file, which has its own set of problems, but it makes it … Read more
In order for an item to be exported from a library crate, there must be at least one path leading to it in which every component is public. This means that all you need to make an item public within your crate but not exported from the crate (I’ll call this “internal” from now on, … Read more
I can’t really recommend this solution work-around but it does function. Rather than exporting an object, you use named exports each member. In another file, import the first module’s named exports into an object and export that object as default. Also export all the named exports from the first module using export * from ‘./file1’; … Read more
Let’s start from the beginning. Look at the Package Layout chapter in The Cargo Book. As you can see, your package can contain lot of stuff: a binary (something you can run) or multiple binaries, a single library (shared code), example(s), benchmark(s), integration tests. Package layout Not all of the possibilities are listed here, just … Read more
Macros within the same crate New method (since Rust 1.32, 2019-01-17) foo::bar!(); // works mod foo { macro_rules! bar { () => () } pub(crate) use bar; // <– the trick } foo::bar!(); // works With the pub use, the macro can be used and imported like any other item. And unlike the older method, … Read more
In a mainish module (main.rs, lib.rs, or subdir/mod.rs), you need to write mod a; for all other modules that you want to use in your whole project (or in the subdir). In any other module, you need to write use a; or use a::foo; You’re far from the only person to be confused by this, … Read more
You’ll have to include b.rs somewhere, typically with mod b;. If b is a child of a (instead of being a sibling of a), there are two ways to do this: Recommended: rename a.rs into a/mod.rs and b.rs into a/b.rs. Then you can mod b; in a/mod.rs. Instead, you can just #[path = “b.rs”] mod … Read more
Rust’s module system is actually incredibly flexible and will let you expose whatever kind of structure you want while hiding how your code is structured in files. I think the key here is to make use of pub use, which will allow you to re-export identifiers from other modules. There is precedent for this in … Read more