Organización de Rust
Cualquier lenguaje de programación que no pueda organizar código es difícil de dominar; casi ningún producto de software se compila a partir de un solo archivo fuente.
Hasta ahora, todos los programas de este tutorial se han escrito en un solo archivo, principalmente para facilitar el aprendizaje de la sintaxis y los conceptos de Rust.
Para un proyecto de ingeniería, organizar el código es muy importante.
En Rust hay tres conceptos importantes de organización: crate, paquete y módulo.
Crate
Una crate es un archivo de programa binario o un archivo de biblioteca, y existe dentro de un paquete.
Una crate tiene una estructura de árbol; su raíz es el programa compilado a partir del archivo fuente que el compilador compila al comenzar a ejecutarse.
Nota: un «archivo de programa binario» no es necesariamente un «archivo ejecutable binario»; solo se puede determinar que es un archivo que contiene el lenguaje de máquina del objetivo, y el formato del archivo varía según el entorno de compilación.
Paquete
Cuando usamos Cargo para ejecutar el comando new y crear un proyecto de Rust, se crea un archivo Cargo.toml en el directorio del proyecto. La esencia de un proyecto es un paquete; un paquete debe ser gestionado por un archivo Cargo.toml, que describe la información básica del paquete y sus dependencias.
Un paquete puede contener como máximo una crate de biblioteca, puede contener cualquier cantidad de crates binarias, pero debe contener al menos una crate (ya sea de biblioteca o binaria).
Después de crear el paquete con el comando cargo new, se genera un archivo fuente main.rs en el directorio src. Cargo, por defecto, considera este archivo como la raíz de la crate binaria; la crate binaria compilada tendrá el mismo nombre que el paquete.
Módulo
Para un proyecto de software, a menudo organizamos según las normas de organización del lenguaje de programación utilizado; la estructura principal para organizar módulos suele ser un árbol. La unidad principal con la que Java organiza los módulos funcionales es la clase, mientras que la forma principal en que JavaScript organiza los módulos es mediante function.
Las unidades de organización de estos lenguajes avanzados pueden contenerse en capas, como la estructura de directorios de un sistema de archivos. En Rust, la unidad de organización es el módulo.
mod nation {
mod government {
fn govern() {}
}
mod congress {
fn legislate() {}
}
mod court {
fn judicial() {}
}
}
Este es un programa que describe un estado de derecho: la nación (nation) incluye el gobierno (government), el congreso (congress) y el tribunal (court), que tienen funciones ejecutiva, legislativa y judicial, respectivamente. Podemos convertirlo en una estructura de árbol:
nation ├── government │ └── govern ├── congress │ └── legislate └── court └── judicial
En un sistema de archivos, la estructura de directorios suele usar una barra inclinada en la cadena de ruta para indicar la posición de un objeto. El separador de rutas en Rust es:: 。
Las rutas se dividen en rutas absolutas y rutas relativas. Las rutas absolutas se describen comenzando desde la palabra clave crate. Las rutas relativas se describen comenzando desde self, super o un identificador. Por ejemplo:
crate::nation::government::govern();
es la ruta absoluta que describe la función govern; la ruta relativa se puede expresar como:
nation::government::govern();
Ahora puedes intentar definir una estructura de módulos similar en un programa fuente y usar rutas en la función principal.
Si lo haces, seguramente descubrirás que algo no está bien: el módulo government y las funciones que contiene son privados (private), y no se te permite acceder a ellos.
Permisos de acceso
Rust tiene dos permisos de acceso simples: público (public) y privado (private).
De forma predeterminada, si no se añade un modificador, el acceso a los miembros de un módulo será privado.
Si se desea usar el permiso público, se necesita la palabra clave pub.
Un módulo privado solo puede ser accedido desde una posición al mismo nivel o de nivel inferior; no se puede acceder desde fuera de él.Ejemplo
pub mod government {
pub fn govern() {}
}
mod congress {
pub fn legislate() {}
}
mod court {
fn judicial() {
super::congress::legislate();
}
}
}
fn main() {
nation::government::govern();
}
Este programa puede compilarse. Observa el método de acceso a super dentro del módulo court.
Si se define una estructura en un módulo, además de que la estructura en sí es privada, sus campos también son privados de forma predeterminada. Por lo tanto, si se desea usar la estructura y sus campos, se necesita la declaración pub:
Ejemplo
pub struct Breakfast {
pub toast: String,
seasonal_fruit: String,
}
impl Breakfast {
pub fn summer(toast: &str) -> Breakfast {
Breakfast {
toast: String::from(toast),
seasonal_fruit: String::from("peaches"),
}
}
}
}
pub fn eat_at_restaurant() {
let mut meal = back_of_house::Breakfast::summer("Rye");
meal.toast = String::from("Wheat");
println!("I'd like {} toast please", meal.toast);
}
fn main() {
eat_at_restaurant()
}
Resultado de ejecución:
I'd like Wheat toast please
Las variantes de una enumeración pueden contener campos, pero no tienen propiedades similares:
Ejemplo
pub enum Person {
King {
name: String
},
Queen
}
}
fn main() {
let person = SomeModule::Person::King{
name: String::from("Blue")
};
match person {
SomeModule::Person::King {name} => {
println!("{}", name);
}
_ => {}
}
}
Resultado de ejecución:
Blue
Módulos difíciles de encontrar
Los desarrolladores que han usado Java a menudo odian el bloque de clase más externo al programar: su nombre es idéntico al nombre del archivo, porque representa el contenedor del archivo. Aunque es engorroso, tenemos que escribirlo una vez para enfatizar que «esta clase es la clase contenida en el archivo».
Sin embargo, tiene algunas ventajas: al menos hace que los desarrolladores sean plenamente conscientes de la existencia del envoltorio de la clase y puede describir claramente la relación de herencia de la clase.
En Rust, los módulos son como los envoltorios de clase de Java, pero se puede escribir una función principal justo al comienzo del archivo. ¿Cómo se explica esto?
El contenido de cada archivo de Rust es un módulo «difícil de encontrar».
Usemos dos archivos para revelar esto:
Archivo main.rs
mod second_module;
fn main() {
println!("This is the main module.");
println!("{}", second_module::message());
}
Archivo second_module.rs
pub fn message() -> String {
String::from("This is the 2nd module.")
}
Resultado de ejecución:
This is the main module. This is the 2nd module.
La palabra clave use
La palabra clave use puede introducir identificadores de módulos en el ámbito actual:
Ejemplo
pub mod government {
pub fn govern() {}
}
}
use crate::nation::government::govern;
fn main() {
govern();
}
Este programa puede compilarse.
Porque la palabra clave use importa el identificador govern al módulo actual, por lo que se puede usar directamente.
Esto resuelve el problema de que las rutas de módulos locales sean demasiado largas.
Por supuesto, en algunos casos existen dos nombres iguales que también necesitan importarse. Podemos usar la palabra clave as para añadir un alias al identificador:
Ejemplo
pub mod government {
pub fn govern() {}
}
pub fn govern() {}
}
use crate::nation::government::govern;
use crate::nation::govern as nation_govern;
fn main() {
nation_govern();
govern();
}
Aquí hay dos funciones govern, una en nation y otra en government. Usamos as para poner el alias nation_govern a la de nation. Ambos nombres pueden usarse al mismo tiempo.
La palabra clave use puede combinarse con la palabra clave pub:
Ejemplo
pub mod government {
pub fn govern() {}
}
pub use government::govern;
}
fn main() {
nation::govern();
}
Referenciar la biblioteca estándar
Diccionario oficial de la biblioteca estándar de Rust:https://doc.rust-lang.org/stable/std/all.html
Después de aprender los conceptos de este capítulo, podemos importar fácilmente bibliotecas del sistema para desarrollar programas de manera conveniente:
Ejemplo
fn main() {
println!("{}", (PI / 2.0).sin());
}
Resultado de ejecución:
1
Todos los módulos de la biblioteca del sistema se importan de forma predeterminada, por lo que al usarlos solo necesitas la palabra clave use para simplificar la ruta y poder usarlos cómodamente.
Otras extensiones