super and self

The super and self keywords can be used in the path to remove ambiguity
when accessing items and to prevent unnecessary hardcoding of paths.

  1. fn function() {
  2.     println!("called `function()`");
  3. }
  5. mod cool {
  6.     pub fn function() {
  7.         println!("called `cool::function()`");
  8.     }
  9. }
  11. mod my {
  12.     fn function() {
  13.         println!("called `my::function()`");
  14.     }
  16.     mod cool {
  17.         pub fn function() {
  18.             println!("called `my::cool::function()`");
  19.         }
  20.     }
  22.     pub fn indirect_call() {
  23.         // Let's access all the functions named `function` from this scope!
  24.         print!("called `my::indirect_call()`, that\n> ");
  26.         // The `self` keyword refers to the current module scope - in this case `my`.
  27.         // Calling `self::function()` and calling `function()` directly both give
  28.         // the same result, because they refer to the same function.
  29.         self::function();
  30.         function();
  32.         // We can also use `self` to access another module inside `my`:
  33.         self::cool::function();
  35.         // The `super` keyword refers to the parent scope (outside the `my` module).
  36.         super::function();
  38.         // This will bind to the `cool::function` in the *crate* scope.
  39.         // In this case the crate scope is the outermost scope.
  40.         {
  41.             use cool::function as root_function;
  42.             root_function();
  43.         }
  44.     }
  45. }
  47. fn main() {
  48.     my::indirect_call();
  49. }