Sintaxis de Rust

Rust es un lenguaje de programación de sistemas que combina rendimiento excepcional con seguridad de memoria. Su sintaxis está diseñada para prevenir errores comunes de programación mientras mantiene un control preciso sobre los recursos del sistema.

Fundamentos de la sintaxis

La sintaxis de Rust se caracteriza por su expresividad y su enfoque en la prevención de errores en tiempo de compilación. A diferencia de otros lenguajes, Rust utiliza un sistema de tipos estricto que garantiza la seguridad sin sacrificar el rendimiento.

fn main() {
    println!("¡Hola, mundo!");
}

Este ejemplo muestra la estructura básica de un programa Rust. La función main es el punto de entrada de cualquier programa ejecutable, y println! es una macro que imprime texto en la consola.

Variables y mutabilidad

En Rust, las variables son inmutables por defecto, lo que significa que una vez asignado un valor, no puede cambiar. Esta característica fundamental ayuda a prevenir errores de programación comunes.

let x = 5;
let mut y = 10;

// x = 6; // Error: no se puede reasignar una variable inmutable
y = 15; // Correcto: y es mutable

Para hacer una variable mutable, debemos usar la palabra clave mut. Esta decisión consciente hace que el código sea más predecible y seguro.

Tipos de datos básicos

Rust proporciona varios tipos de datos primitivos que cubren las necesidades más comunes de programación:

let entero: i32 = 42;
let flotante: f64 = 3.14;
let booleano: bool = true;
let caracter: char = 'R';
let cadena: &str = "Rust";

Los tipos numéricos en Rust son específicos en cuanto a su tamaño y signo. Por ejemplo, i32 representa un entero con signo de 32 bits, mientras que u32 representa un entero sin signo del mismo tamaño.

Funciones y parámetros

Las funciones en Rust se definen usando la palabra clave fn. La sintaxis es clara y expresiva, permitiendo especificar tipos de parámetros y valores de retorno:

fn sumar(a: i32, b: i32) -> i32 {
    a + b // Expresión de retorno (sin punto y coma)
}

fn saludar(nombre: &str) {
    println!("Hola, {}", nombre);
}

Una característica importante es que las expresiones no llevan punto y coma al final cuando son el valor de retorno de una función. El punto y coma convierte una expresión en una declaración.

Estructuras de control

Rust proporciona las estructuras de control habituales con una sintaxis limpia y consistente:

let numero = 7;

if numero < 5 {
    println!("Menor que 5");
} else if numero == 5 {
    println!("Igual a 5");
} else {
    println!("Mayor que 5");
}

Los bucles en Rust incluyen loop, while y for, cada uno optimizado para diferentes casos de uso:

// Bucle infinito
loop {
    println!("¡Para siempre!");
    break; // Salir del bucle
}

// Bucle condicional
let mut contador = 0;
while contador < 3 {
    println!("Contador: {}", contador);
    contador += 1;
}

// Iteración sobre rangos
for i in 0..5 {
    println!("Número: {}", i);
}

Ownership y referencias

El sistema de ownership es uno de los aspectos más distintivos de Rust. Cada valor tiene un único propietario, y cuando el propietario sale del ámbito, el valor se libera automáticamente:

let s1 = String::from("hola");
let s2 = s1; // s1 ya no es válido (movimiento)

// println!("{}", s1); // Error: s1 fue movido

let s3 = String::from("mundo");
let s4 = &s3; // Referencia, s3 sigue siendo válido
println!("{} {}", s3, s4); // Ambos son válidos

Las referencias permiten usar un valor sin tomar posesión de él. Rust distingue entre referencias inmutables (&T) y mutables (&mut T), garantizando que no haya condiciones de carrera en tiempo de compilación.

Pattern matching

El pattern matching en Rust es extremadamente expresivo, especialmente con la expresión match:

let numero = 3;

match numero {
    1 => println!("Uno"),
    2 | 3 => println!("Dos o tres"),
    4..=10 => println!("Entre cuatro y diez"),
    _ => println!("Otro número"),
}

Esta característica permite desestructurar datos complejos y manejar diferentes casos de manera elegante y segura.

Macros y metaprogramación

Las macros en Rust se identifican por el símbolo ! y proporcionan capacidades de metaprogramación. A diferencia de las funciones, las macros operan sobre el código fuente antes de la compilación:

println!("El valor es: {}", 42);
vec![1, 2, 3, 4]; // Macro para crear vectores

La sintaxis de Rust equilibra la expresividad con la seguridad, proporcionando herramientas que permiten escribir código eficiente mientras se previenen errores comunes. Su sistema de tipos y las reglas de ownership pueden parecer restrictivas inicialmente, pero estas características son fundamentales para garantizar la seguridad y el rendimiento que caracterizan al lenguaje.