Rust is a multi-paradigm programming language like C++ syntax that was designed for performance and safety, especially safe concurrency by using a borrow checker and ownership to validate references. The self and super keywords provided by Rust can be used in the path to remove ambiguity when accessing items like functions.
Example:
Rust
// Rust program for Super & Self Keywords fn function_with_same_name() {
println!("called `function_with_same_name()`
which is in the outermost scope");
} mod cool_mod {
pub fn function_with_same_name() {
println!("called `cool_mod::function_with_same_name()`
which is inside the `cool_mod` module in the outermost scope");
}
} mod my_mod {
fn function_with_same_name() {
println!("called `my_mod::function_with_same_name()`
which is inside the `my_mod` module");
}
mod cool_mod {
pub fn function_with_same_name() {
println!("called `my_mod::cool_mod::
function_with_same_name()` which is inside the
`cool_mod` module which is in turn inside `my_mod` module");
}
}
pub fn indirect_call() {
// Let's access all the functions named
//`function_with_same_name` from this scope!
print!( "called `my_mod::indirect_call()`, that\n> " );
// The `self` keyword refers to the current module
// scope - in this case `my_mod`.
// Calling `self::function_with_same_name()` and
// calling `function_with_same_name()` directly both give
// the same result, because they refer to the same function.
self ::function_with_same_name();
function_with_same_name();
// We can also use `self` to access
// another module inside `my_mod`:
// We have `cool_mod` module inside `my_mod`
// module which contains `function_with_same_name`
self ::cool_mod::function_with_same_name();
// The `super` keyword refers to the parent scope
// (outside the `my_mod` module).
super ::function_with_same_name();
}
} fn main() {
my_mod::indirect_call();
} |
Output:
Explanation:
- We start by creating a function named ‘function_with_same_name’ (we choose this name to make it easier for you to understand that we are using the same name for all the functions).
- Then we create a module named ‘cool_mod’ which contains a public function also named ‘function_with_same_name’.
- After that, we create another module named ‘my_mod’ which also contains a module called ‘cool_mod’ which in turn also contains a public function named ‘function_with_same_name’.
- ‘my_mod’ also contains function named ‘function_with_same_name’ and a function named ‘indirect_call’.
- Now we will see what is happening inside the ‘indirect_call’ function.The `self` keyword refers to the current module scope – in this case, `my_mod` which means that when we call ‘function_with_same_name()’ using self keyword it calls the ‘function_with_same_name()’ that is present in the ‘my_mod’ module.
- After that, when we call ‘function_with_same_name()’ without using the self keyword, the output remains the same because they refer to the same function in this scope.
- Now we call ‘function_with_same_name()’ of ‘cool_mod’ module using self keyword.
- Now using super keyword we call ‘function_with_same_name()’ which calls the function named ‘function_with_same_name’ in the parent scope .
- As you can see how self and super keywords make our jobs easier.
Article Tags :
Recommended Articles