Cargo: El gestor de paquetes y sistema de construcción de Rust

Aunque el compilador rustc es el motor que transforma el código fuente en binarios, trabajar directamente con él para proyectos reales sería ineficiente. Para gestionar dependencias, compilar tests, generar documentación o configurar parámetros de optimización, Rust utiliza Cargo. Cargo es el sistema de construcción (build system) y gestor de paquetes oficial que automatiza todo el ciclo de vida del desarrollo.

Cuando inicias un proyecto con cargo new nombre_proyecto, Cargo crea una estructura de directorios estandarizada: un archivo Cargo.toml (donde se definen las dependencias y metadatos mediante el formato TOML) y una carpeta src/ que contiene el código fuente. Si el objetivo es crear una librería reutilizable en lugar de un ejecutable, se utiliza cargo new --lib.

El flujo de trabajo con Cargo se basa en comandos específicos:
– cargo check: Es la herramienta más utilizada durante el desarrollo. Verifica si el código es válido sin generar un binario, lo que lo hace extremadamente rápido.
– cargo build: Compila el código y genera un ejecutable en la carpeta target/debug/. Este modo incluye símbolos de depuración pero no está optimizado para velocidad.
– cargo build --release: Compila el código con optimizaciones de alto nivel para producción, depositando el binario en target/release/.
– cargo run: Un comando “todo en uno” que compila (si es necesario) y ejecuta el programa inmediatamente.
– cargo clean: Elimina la carpeta target/, borrando todos los artefactos de compilación anteriores para liberar espacio o realizar una compilación desde cero.

Si intentas compilar un proyecto con dependencias externas usando solo rustc, el proceso fallará porque el compilador no sabrá dónde encontrar las librerías externas. Cargo resuelve esto descargando automáticamente las versiones correctas desde crates.io.

// Este archivo debe situarse en src/main.rs dentro de un proyecto creado con 'cargo new'
// Representa la lógica principal de un binario de Rust.

fn main() {
    // Declaramos una variable de tipo string slice (&str)
    let saludo: &str = "Hola, Rust!";
    
    // Declaramos un entero de 32 bits (i32)
    let valor_numerico: i32 = 100;

    // Imprimimos en consola usando la macro println!
    println!("Mensaje: {}", saludo);
    println!("El valor es: {}", valor_numerico);

    // Realizamos una operación simple para verificar la ejecución
    let resultado = sumar(valor_numerico, 50);
    
    println!("La suma de {} + 50 es: {}", valor_numerico, resultado);
}

// Definición de una función que recibe dos i32 y devuelve un i32
fn sumar(a: i32, b: i32) -> i32 {
    a + b
}

Explicación del Código

– fn main(): Es la función principal del programa. Cuando ejecutas cargo run, el sistema busca este punto de entrada para iniciar la ejecución.
– let saludo: &str: Define una variable llamada saludo cuyo tipo es una referencia a una cadena de texto (&str).
– let valor_numerico: i32: Declara una variable llamada valor_numerico de tipo entero de 32 bits.
– println!: Es una macro de Rust que permite imprimir texto formateado en la terminal.
– sumar(a: i32, b: i32) -> i32: Es una función que acepta dos parámetros, a y b, ambos de tipo i32, y retorna un valor de tipo i32 tras realizar la suma.
– resultado: Almacena el valor devuelto por la función sumar para ser impreso posteriormente.

N° 6