use, super, self

A module can bring symbols from another module into scope with use. You will typically see something like this at the top of each module:

1. ```
   use std::collections::HashSet;
   ```
2. ```
   use std::process::abort;
   ```

Paths

Paths are resolved as follows:

  1. As a relative path:

  2. foo or self::foo refers to foo in the current module,

  3. super::foo refers to foo in the parent module.

  4. As an absolute path:

  5. crate::foo refers to foo in the root of the current crate,

  6. bar::foo refers to foo in the bar crate.

This slide should take about 8 minutes.

  • It is common to “re-export” symbols at a shorter path. For example, the top-level lib.rs in a crate might have

``` 1. mod storage;

  1. pub use storage::disk::DiskStorage;
  2. pub use storage::network::NetworkStorage; ```

making DiskStorage and NetworkStorage available to other crates with a convenient, short path. - For the most part, only items that appear in a module need to be use‘d. However, a trait must be in scope to call any methods on that trait, even if a type implementing that trait is already in scope. For example, to use the read_to_string method on a type implementing the Read trait, you need to use std::io::Read. - The use statement can have a wildcard: use std::io::*. This is discouraged because it is not clear which items are imported, and those might change over time.