Rust: palabras clave Super y Self

Rust es un lenguaje de programación multiparadigma como la sintaxis de C++ que fue diseñado para el rendimiento y la seguridad, especialmente la concurrencia segura mediante el uso de un verificador de préstamos y la propiedad para validar las referencias. Las palabras clave self y super proporcionadas por Rust se pueden usar en la ruta para eliminar la ambigüedad al acceder a elementos como funciones.

Ejemplo:

// 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();
}

Producción:

 

Explicación:

• Comenzamos creando una función llamada ‘función_con_mismo_nombre’ (elegimos este nombre para que sea más fácil de entender que estamos usando el mismo nombre para todas las funciones).
• Luego creamos un módulo llamado ‘cool_mod’ que contiene una función pública también llamada ‘function_with_same_name’.
• Después de eso, creamos otro módulo llamado ‘my_mod’ que también contiene un módulo llamado ‘cool_mod’ que a su vez también contiene una función pública llamada ‘function_with_same_name’.
• ‘my_mod’ también contiene una función llamada ‘function_with_same_name’ y una función llamada ‘indirect_call’.
• Ahora veremos qué sucede dentro de la función ‘indirect_call’. La palabra clave ‘self’ se refiere al alcance del módulo actual; en este caso, ‘my_mod’, lo que significa que cuando llamamos a ‘function_with_same_name()’ usando la palabra clave self, llama al ‘function_with_same_name()’ que está presente en el módulo ‘my_mod’.
• Después de eso, cuando llamamos a ‘function_with_same_name()’ sin usar la palabra clave self, el resultado sigue siendo el mismo porque se refieren a la misma función en este ámbito.
• Ahora llamamos a ‘function_with_same_name()’ del módulo ‘cool_mod’ usando la palabra clave self.
• Ahora, al usar la palabra clave super, llamamos a ‘function_with_same_name()’, que llama a la función denominada ‘function_with_same_name’ en el ámbito principal.
• Como puede ver, las palabras clave propias y súper facilitan nuestro trabajo.