Glosario de Rust

Lifetime de los datos que viven durante toda la ejecución del programa, como los literales de texto.

Slice de string: una vista prestada e inmutable de texto UTF-8. Los literales como "hola" son &str. Es el tipo ideal para parámetros que solo leen texto.

Atributo que marca una función como test. cargo test las ejecuta todas y muestra cuáles pasan y cuáles fallan.

Versión atómica de Rc: un puntero con contador de referencias que se puede compartir de forma segura entre hilos.

Colección de longitud fija con elementos del mismo tipo, por ejemplo [i32; 5]. Vive en el stack. Si necesitas que crezca, usa Vec.

Macro que comprueba que dos valores son iguales y hace panic mostrando ambos si no lo son. assert! comprueba una condición booleana.

Sintaxis para escribir código asíncrono que no bloquea mientras espera (red, disco…). Necesita un runtime como Tokio para ejecutarse.

Parte del compilador que comprueba que todas las referencias cumplen las reglas de préstamo y no viven más que los datos a los que apuntan.

Crear una referencia a un valor. Reglas: en cada momento puedes tener una referencia mutable o cualquier número de referencias inmutables, pero no ambas.

Smart pointer que guarda un valor en el heap. Se usa para tipos recursivos, valores grandes o trait objects (Box<dyn Trait>).

Mecanismo para enviar mensajes entre hilos: varios productores, un consumidor. Se crea con std::sync::mpsc::channel().

El gestor de proyectos y paquetes de Rust. Crea proyectos (cargo new), compila (cargo build), ejecuta (cargo run), lanza los tests (cargo test) y descarga las dependencias declaradas en Cargo.toml.

Fichero de configuración de un paquete de Cargo, en formato TOML. Contiene el nombre, la versión, la edición de Rust y la lista de dependencias.

El linter oficial de Rust (cargo clippy). Detecta errores comunes y sugiere formas más idiomáticas de escribir tu código.

Trait que permite crear una copia profunda explícita de un valor con .clone(), por ejemplo para duplicar un String con sus datos del heap.

Función anónima que puede capturar variables de su entorno: |x| x + 1. Implementa uno o varios de los traits Fn, FnMut y FnOnce.

Consumidor que transforma un iterador en una colección, como un Vec, un String o un HashMap.

Declara una constante: un valor fijo conocido en tiempo de compilación, siempre con tipo explícito y escrito en MAYÚSCULAS por convención.

Trait de los tipos que se copian bit a bit en lugar de moverse: enteros, flotantes, bool, char y tuplas de estos. Tras asignarlos, la variable original sigue siendo válida.

La unidad de compilación de Rust: un binario (con función main) o una biblioteca. Los crates publicados se comparten en crates.io.

El registro oficial de paquetes (crates) de la comunidad de Rust. Cargo descarga de ahí las dependencias de tus proyectos.

Referencia que apunta a memoria ya liberada. Es un error clásico en C y C++; en Rust el compilador lo impide.

Trait para mostrar un valor pensado para programadores con {:?} o {:#?}. Se suele obtener con #[derive(Debug)].

Atributo #[derive(...)] que implementa automáticamente traits comunes como Debug, Clone, Copy, PartialEq o Default para tus tipos.

Trait para mostrar un valor de forma legible para el usuario con {}. Hay que implementarlo a mano para tus tipos.

Momento en que Rust libera un valor, automáticamente al salir su dueño de ámbito. También es el trait que permite ejecutar código de limpieza en ese momento.

Versión del lenguaje que elige cada crate (2015, 2018, 2021, 2024). Permite introducir cambios incompatibles sin romper el código antiguo: crates de distintas ediciones funcionan juntos.

Tipo que puede ser una de varias variantes, y cada variante puede llevar datos distintos. Junto con match, es una de las herramientas más potentes de Rust.

Código que se evalúa y produce un valor, como 5 + 1, un bloque { } o un if. La última expresión de una función sin punto y coma es su valor de retorno.

Función de un bloque impl que no recibe self. Se llama con Tipo::funcion(); el ejemplo típico es el constructor Tipo::new().

Parámetros de tipo (como T) que permiten escribir funciones, structs y enums que funcionan con muchos tipos distintos sin duplicar código.

Colección que asocia claves con valores. Está en std::collections. Su API entry permite insertar o actualizar de forma muy cómoda.

Zona de memoria para datos de tamaño variable o desconocido en compilación, como el contenido de un String o un Vec. Rust lo libera cuando el dueño sale de ámbito.

Unidad de ejecución que corre en paralelo con las demás. En Rust se crea con std::thread::spawn y se espera con join.

Forma abreviada de un match cuando solo te interesa un patrón, por ejemplo if let Some(x) = opcion { … }.

Bloque donde se definen los métodos y funciones asociadas de un tipo, o donde se implementa un trait para él (impl Trait for Tipo).

Capacidad del compilador para deducir el tipo de una variable a partir de su valor y de cómo se usa, sin que tengas que escribirlo.

Valor que produce una secuencia de elementos mediante el método next. Los adaptadores (map, filter…) son perezosos y los consumidores (collect, sum…) los ejecutan.

Palabra clave para declarar una variable. Por defecto la variable es inmutable: no se puede reasignar.

Ámbito durante el que una referencia es válida. Se anota con un apóstrofo ('a) cuando el compilador no puede deducir cómo se relacionan varias referencias.

Código que genera código en tiempo de compilación. Se reconocen por el signo de exclamación: println!, vec!, format!, panic!. Pueden recibir un número variable de argumentos.

Expresión que compara un valor con una serie de patrones y ejecuta la rama del primero que encaja. Es exhaustiva: debe cubrir todos los casos.

Función definida en un bloque impl cuyo primer parámetro es self, &self o &mut self. Se llama con la sintaxis valor.metodo().

Forma de organizar el código en espacios de nombres con mod. Controla la visibilidad: todo es privado salvo lo marcado con pub.

Proceso por el que el compilador genera una versión concreta del código genérico para cada tipo usado. Por eso los genéricos no tienen coste en ejecución.

Palabra clave que, delante de un closure, hace que tome la propiedad de las variables que captura en lugar de tomarlas prestadas.

Transferencia de la propiedad de un valor a otra variable o función. Tras el movimiento, la variable original ya no se puede usar.

Modificador que hace mutable una variable (let mut x) o una referencia (&mut x), permitiendo cambiar su valor.

Cerrojo de exclusión mutua: garantiza que solo un hilo a la vez accede al dato que protege. Se accede con lock().

Aplicado a un Result (u Option), extrae el valor si es Ok (o Some) y, si es Err (o None), lo devuelve inmediatamente desde la función actual.

Enum de la biblioteca estándar que representa un valor opcional: Some(valor) o None. Es la alternativa segura a null.

Sistema con el que Rust gestiona la memoria: cada valor tiene un único dueño, solo puede haber un dueño a la vez y el valor se libera cuando el dueño sale de su ámbito.

Macro que detiene el programa con un mensaje de error. Se usa para errores irrecuperables o bugs, por ejemplo acceder a un índice fuera de rango.

Comprobar la forma de un valor y extraer sus partes a la vez. Se usa en match, if let, while let, let y en los parámetros de las funciones.

Modificador que hace visible un elemento (función, struct, campo, módulo…) fuera del módulo en el que se define.

Secuencia de valores: 1..5 va del 1 al 4 (excluye el final) y 1..=5 incluye el 5. Se usa mucho en bucles for y en slices.

Puntero con contador de referencias que permite que un valor tenga varios dueños en un mismo hilo. El valor se libera cuando desaparece el último.

Tipo que permite mutar un valor aunque solo tengas referencias inmutables (mutabilidad interior), comprobando las reglas de préstamo en tiempo de ejecución.

Puntero que permite usar un valor sin tomar su propiedad. &T es una referencia inmutable y &mut T una mutable. Las referencias siempre son válidas.

Enum para operaciones que pueden fallar: Ok(valor) si todo fue bien o Err(error) si no. Obliga a gestionar el error de forma explícita.

Lenguaje de programación de sistemas, compilado y con tipado estático, que garantiza la seguridad de memoria sin recolector de basura gracias al ownership y al borrow checker. Lo creó Graydon Hoare y lo impulsó Mozilla; hoy lo mantiene la Rust Foundation.

El compilador de Rust. Convierte tu código fuente (.rs) en un ejecutable. Normalmente no lo llamas directamente: lo usa Cargo por ti.

Formateador oficial de código Rust (cargo fmt). Aplica un estilo uniforme para que todo el código de un proyecto se vea igual.

Instalador y gestor de versiones de Rust. Permite instalar el compilador, actualizarlo (rustup update) y cambiar entre los canales stable, beta y nightly.

Self (con mayúscula) es un alias del tipo dentro de su bloque impl. self (minúscula) es la instancia sobre la que se llama un método.

Traits marcadores que indican si un tipo se puede mover a otro hilo (Send) o compartir entre hilos por referencia (Sync). El compilador los comprueba por ti.

Instrucción que realiza una acción pero no devuelve valor, como let x = 5;. Añadir punto y coma a una expresión la convierte en sentencia.

Declarar una nueva variable con el mismo nombre que otra anterior usando let. La nueva «tapa» a la antigua y puede tener incluso otro tipo.

Referencia a una porción contigua de una colección, como &v[1..3] o &s[0..4]. No tiene propiedad de los datos.

Zona de memoria rápida donde se guardan los valores de tamaño conocido en compilación, como los enteros o los punteros. Se libera automáticamente al salir de cada función.

Cadena de texto UTF-8 que puede crecer y que es dueña de sus datos, guardados en el heap. Se crea con String::from, .to_string() o format!.

Tipo propio que agrupa varios valores con nombre (campos). También existen tuple structs (campos sin nombre) y unit structs (sin campos).

Tipo que representa un único valor: enteros (i32, u8, usize…), flotantes (f64, f32), booleanos (bool) y caracteres (char).

Conjunto de métodos que un tipo puede implementar para declarar que tiene cierto comportamiento. Es parecido a las interfaces de otros lenguajes.

Restricción sobre un genérico que exige que implemente ciertos traits, por ejemplo T: Display o where T: Clone + Debug.

Valor de un tipo desconocido en compilación que implementa un trait, usado detrás de un puntero como Box<dyn Trait>. Permite mezclar tipos distintos en una misma colección.

Agrupa un número fijo de valores que pueden ser de tipos distintos: (i32, f64, char). Se accede a sus elementos con .0, .1… o desestructurando.

El tipo vacío, con un único valor: (). Es lo que devuelven las funciones que no devuelven nada útil.

Bloque o función donde se permiten operaciones que el compilador no puede verificar, como desreferenciar punteros crudos. Se usa poco y con mucho cuidado.

Método de Option y Result que devuelve el valor de dentro o hace panic si no lo hay. expect hace lo mismo con un mensaje propio.

Palabra clave que trae una ruta al ámbito actual para no tener que escribirla completa, por ejemplo use std::collections::HashMap.

Codificación de texto en la que cada carácter ocupa de 1 a 4 bytes. Los String y &str de Rust siempre son UTF-8 válido; por eso no se indexan por posición.

Vector: lista de elementos del mismo tipo que puede crecer, guardada en el heap. Se crea con Vec::new() o con la macro vec![].