Rust by Example

println!("Entering block");

{

// This is equivalent to `use deeply::nested::function as function`.

// This `function()` will shadow the outer one.

use crate::deeply::nested::function;

// `use` bindings have a local scope. In this case, the

// shadowing of `function()` is only in this block.

function();

println!("Leaving block");

}

function();

}

הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

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.

fn function() {

println!("called `function()`");

}

mod cool {

pub fn function() {

println!("called `cool::function()`");

}

}

mod my {

fn function() {

println!("called `my::function()`");

}

mod cool {

pub fn function() {

println!("called `my::cool::function()`");

}

}

pub fn indirect_call() {

// Let's access all the functions named `function` from this scope!

print!("called `my::indirect_call()`, that\n> ");

// The `self` keyword refers to the current module scope - in this case `my`.

// Calling `self::function()` and calling `function()` directly both give

// the same result, because they refer to the same function.

self::function();

function();

// We can also use `self` to access another module inside `my`:

self::cool::function();

// The `super` keyword refers to the parent scope (outside the `my` module).

super::function();

// This will bind to the `cool::function` in the *crate* scope.

// In this case the crate scope is the outermost scope.

{

use crate::cool::function as root_function;

root_function();

}

}

}

fn main() {

my::indirect_call();

}

הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

File hierarchy