El Lenguaje de Programación Rust

📚 Resumen del contenido

Una guía introductoria completa sobre Rust, que cubre conceptos de programación de sistemas, seguridad de memoria, concurrencia y la herramienta de Rust (Cargo, rustup). Transita desde la sintaxis básica hasta la creación de proyectos completos como un servidor web multihilo.

Domina el arte de la programación de sistemas segura, rápida y concurrente con la guía definitiva de Rust.

Autor: Steve Klabnik y Carol Nichols, con contribuciones de la Comunidad Rust

Agradecimientos: Contribuciones de la Comunidad Rust; publicado en formato impreso y ebook por No Starch Press.

🎯 Objetivos de aprendizaje

1. Instalar y gestionar correctamente herramientas de Rust mediante rustup en diferentes sistemas operativos.
2. Escribir, compilar y ejecutar un programa Rust básico, identificando los componentes anatómicos centrales del código.
3. Usar Cargo para crear estructuras de proyecto estandarizadas, gestionar compilaciones y producir binarios optimizados para lanzamientos.
4. Capturar y almacenar entradas de usuario mientras se maneja la mutabilidad de variables y posibles fallos de E/S.
5. Integrar dependencias externas usando Cargo y gestionar compilaciones reproducibles mediante Cargo.lock.
6. Implementar lógica de juego usando inferencia de tipos, análisis de cadenas, bucles y el operador de flujo de control match.
7. Distinguir entre constantes y sombreado de variables para gestionar inmutabilidad de datos y ámbito.
8. Implementar correctamente tipos escalares (enteros, flotantes, booleanos, caracteres) y compuestos (tuplas, arreglos).
9. Distinguir entre sentencias y expresiones para definir funciones con valores de retorno específicos.
10. Distinguir entre memoria de pila y memoria de montón y explicar cómo Rust gestiona los datos en el montón.

🔹 Lección 1: Comenzando con Rust

Resumen: Esta lección proporciona una introducción completa al ecosistema de Rust, centrada en la configuración del entorno y el flujo fundamental de trabajo de un desarrollador de Rust. Los estudiantes pasarán desde la instalación del lenguaje mediante rustup hasta escribir un programa manual "Hola, mundo", y finalmente dominarán Cargo, el sistema de compilación oficial y gestor de paquetes de Rust, para la gestión profesional de proyectos y optimización de lanzamientos.

Resultados del aprendizaje:

• Instalar y gestionar correctamente herramientas de Rust mediante rustup en diferentes sistemas operativos.
• Escribir, compilar y ejecutar un programa Rust básico, identificando los componentes anatómicos centrales del código.
• Usar Cargo para crear estructuras de proyecto estandarizadas, gestionar compilaciones y producir binarios optimizados para lanzamientos.

🔹 Lección 2: Práctico: Programando un juego de adivinanzas

Resumen: Esta lección guía a los desarrolladores a través de la construcción de un juego CLI funcional en Rust. Cubre conceptos fundamentales de programación de sistemas, incluyendo el procesamiento de entrada de usuario, la integración de crates externas para generar números aleatorios y el enfoque único de Rust hacia la seguridad de memoria y el manejo de errores mediante el tipo Result y el patrón de coincidencia. Al final, los alumnos tendrán una aplicación robusta que maneja entradas inválidas y garantiza compilaciones reproducibles.

Resultados del aprendizaje:

• Capturar y almacenar entradas de usuario mientras se maneja la mutabilidad de variables y posibles fallos de E/S.
• Integrar dependencias externas usando Cargo y gestionar compilaciones reproducibles mediante Cargo.lock.
• Implementar la lógica del juego usando inferencia de tipos, análisis de cadenas, bucles y el operador de flujo de control match.

🔹 Lección 3: Conceptos comunes de programación

Resumen: Esta lección aborda los bloques fundamentales de la programación en Rust, centrándose en cómo se almacenan y manipulan los datos. Explora las sutilezas del sombreado de variables y las constantes, la categorización de datos en tipos escalares y compuestos, las reglas estructurales de las funciones y la lógica que gobierna el flujo de control y la ejecución repetitiva.

Resultados del aprendizaje:

• Distinguir entre constantes y sombreado de variables para gestionar inmutabilidad de datos y ámbito.
• Implementar correctamente tipos escalares (enteros, flotantes, booleanos, caracteres) y compuestos (tuplas, arreglos).
• Distinguir entre sentencias y expresiones para definir funciones con valores de retorno específicos.

🔹 Lección 4: Entendiendo la propiedad y la memoria

Resumen: Esta lección explora el enfoque único de Rust para la gestión de memoria mediante su sistema de Propiedad. En lugar de depender de un recolector de basura o gestión manual de memoria, Rust utiliza un conjunto de reglas verificadas en tiempo de compilación para garantizar la seguridad de la memoria. Este capítulo cubre los mecanismos de la pila y el montón, el ciclo de vida de los datos y cómo las referencias y rebanadas proporcionan acceso seguro y eficiente a la memoria sin transferir propiedad.

Resultados del aprendizaje:

• Distinguir entre memoria de pila y memoria de montón y explicar cómo Rust gestiona los datos en el montón.
• Aplicar las tres reglas de Propiedad para predecir la validez y ámbito de las variables.
• Demostrar la diferencia entre operaciones Move, Clone y Copy.

🔹 Lección 5: Estructuras: Gestión de datos relacionados

Resumen: Esta lección explora cómo agrupar datos relacionados en tipos personalizados usando estructuras (structs) para crear código más significativo y organizado. Cubre la definición e instanciación de varias formas de structs (clásicas, tupla y similares a unidades), la gestión de la propiedad de datos dentro de estas estructuras y la mejora de structs mediante traits derivados como Debug y métodos personalizados definidos mediante bloques impl.

Resultados del aprendizaje:

• Definir e instanciar structs usando campos nombrados, sintaxis abreviada y sintaxis de actualización.
• Distinguir entre structs clásicas, structs de tupla y structs similares a unidades e identificar sus casos de uso.
• Implementar el trait Debug y usar el macro dbg! para inspeccionar datos de struct.

🔹 Lección 6: Enumeraciones y coincidencia de patrones

Resumen: Esta lección explora cómo Rust utiliza enumeraciones (enums) para definir tipos enumerando sus variantes posibles, ofreciendo una forma más flexible de agrupar constantes relacionadas y datos que las structs solas. Cubre el papel crítico del enum Option para eliminar errores de punteros nulos y demuestra cómo los constructores match y if let proporcionan un poderoso flujo de control exhaustivo para manejar patrones complejos de datos de forma segura.

Resultados del aprendizaje:

• Definir enums con diversos tipos de datos e implementar métodos en ellos usando bloques impl.
• Explicar los beneficios de seguridad del enum Option<T> frente a valores nulos tradicionales.
• Construir expresiones match exhaustivas que vinculen valores internos de variantes y usen marcadores generales.

🔹 Lección 7: Módulos, Paquetes y Crates

Resumen: Esta lección explora cómo Rust organiza el código para mejorar la legibilidad y reutilización mediante su sistema de módulos. Cubre la creación de una jerarquía de módulos, la aplicación de reglas de privacidad para controlar la visibilidad de elementos y el uso de rutas y palabras clave como use y pub para gestionar el ámbito y crear interfaces limpias.

Resultados del aprendizaje:

• Organizar el código en una estructura jerárquica usando módulos y el árbol de módulos.
• Referenciar elementos de código usando rutas absolutas y relativas.
• Controlar la visibilidad de funciones, módulos y campos usando la palabra clave pub y reglas de privacidad.

🔹 Lección 8: Colecciones comunes

Resumen: Esta lección explora las colecciones de la biblioteca estándar de Rust, centrándose específicamente en Vectores, Cadenas y Mapas Hash. Estas estructuras de datos se almacenan en el montón, lo que permite que crezcan o disminuyan durante la ejecución, y la lección detalla cómo las reglas de propiedad y préstamo de Rust garantizan la seguridad de la memoria y el rendimiento al gestionar estas listas de valores, texto codificado en UTF-8 y asociaciones clave-valor.

Resultados del aprendizaje:

• Implementar listas dinámicas usando Vec<T> y gestionar su ciclo de vida mediante el comprobador de préstamos.
• Manipular texto codificado en UTF-8 usando el tipo String, navegando por las complejidades de su representación interna y concatenación.
• Aplicar HashMap<K, V> para almacenar y actualizar datos asociados de forma eficiente usando la API Entry y consideraciones personalizadas de hashing.

🔹 Lección 9: Estrategias de manejo de errores

Resumen: Esta lección explora la filosofía robusta de manejo de errores de Rust, que distingue entre errores recuperables y no recuperables. Los estudiantes aprenderán a usar el macro panic! para errores fatales, el enum Result para fallos manejables y el operador ? para simplificar la propagación de errores. Además, la lección cubre cómo usar el sistema de tipos de Rust para forzar la validación de datos y mantener la integridad del programa.

Resultados del aprendizaje:

• Identificar cuándo usar panic! no recuperable frente a Result recuperable según el criterio de "estado incorrecto".
• Utilizar rastros de llamadas para depurar el origen de errores no recuperables.
• Implementar propagación de errores usando el operador ? y modificar la función main para soportar retornos de errores.

🔹 Lección 10: Genéricos, Traits y Vidas

Resumen: Esta lección explora las herramientas de Rust para la abstracción efectiva: Genéricos para reducir la duplicación de código entre tipos, Traits para definir comportamientos compartidos (interfaces) y Vidas para asegurar la seguridad de la memoria sin gestión manual. Juntas, estas características permiten a los desarrolladores escribir código de alto rendimiento y reutilizable, validado por el compilador para evitar referencias colgantes y errores de tipo.

Resultados del aprendizaje:

• Definir y usar parámetros de tipo genérico en funciones, structs y enums para manejar múltiples tipos de datos.
• Implementar comportamientos compartidos usando Traits y restricciones de Traits para limitar tipos genéricos.
• Aplicar anotaciones de Vida y reglas de eliminación para gestionar la validez de referencias y satisfacer al comprobador de préstamos.

🔹 Lección 11: Escritura de pruebas automatizadas

Resumen: Esta lección explora la implementación y organización de pruebas automatizadas en Rust. Cubre los requisitos estructurales de una función de prueba, el uso de macros de afirmación para verificar lógica y las diferencias técnicas entre pruebas unitarias e integradas. Los alumnos también entenderán cómo controlar el comportamiento del ejecutor de pruebas de Rust para gestionar el flujo de ejecución y la visibilidad.

Resultados del aprendizaje:

• Definir la estructura y metadatos requeridos para una función de prueba válida en Rust.
• Implementar comprobaciones de igualdad y verificaciones de estado de pánico para asegurar la confiabilidad del código.
• Configurar el ejecutor de pruebas para ejecución paralela o consecutiva y visibilidad de la salida del programa.

🔹 Lección 12: Proyecto de E/S: Herramienta de línea de comandos

Resumen: Esta lección guía a los desarrolladores en la creación de una herramienta de línea de comandos funcional (una versión simplificada de grep) en Rust. Se enfoca en la transición de un script de un solo archivo a un binario modular y listo para producción, destacando el análisis seguro de argumentos, la entrada/salida de archivos y la separación de preocupaciones entre la lógica de la librería y la interfaz de línea de comandos. Los alumnos implementarán un manejo robusto de errores y desarrollarán características usando Desarrollo Dirigido por Pruebas (TDD), gestionando el estado de la aplicación mediante variables de entorno.

Resultados del aprendizaje:

• Capturar y transformar argumentos de línea de comandos en objetos de configuración estructurados.
• Refactorizar el código para seguir el principio de Separación de Preocupaciones en proyectos binarios.
• Implementar la lógica central usando un ciclo de Desarrollo Dirigido por Pruebas (TDD) con anotaciones de vida.

🔹 Lección 13: Características funcionales: Iteradores y Cierres

Resumen: Esta lección explora las características de programación funcional de Rust, centrándose específicamente en cierres (closures) e iteradores. Los cierres son funciones anónimas que pueden capturar su entorno, gobernadas por los traits Fn, mientras que los iteradores ofrecen una forma perezosa y eficiente de procesar secuencias de elementos. Juntos, estas características permiten código expresivo que sigue el principio de "abstracción sin costo" de Rust, a menudo empatando o superando el rendimiento de bucles tradicionales.

Resultados del aprendizaje:

• Definir funciones anónimas (cierres) y explicar cómo capturan variables de su entorno mediante préstamo o movimiento.
• Distinguir entre los tres traits Fn (Fn, FnMut y FnOnce) y entender cómo el compilador infiere el tipo de cierre.
• Implementar el trait Iterator usando el método next y distinguir entre adaptadores consumidores y adaptadores de iteradores.

🔹 Lección 14: Cargo avanzado y Crates.io

Resumen: Esta lección explora las características avanzadas del gestor de paquetes de Rust, Cargo, y su ecosistema, Crates.io. Se centra en optimizar compilaciones mediante perfiles de lanzamiento, crear documentación profesional con pruebas integradas y dominar la arquitectura de APIs públicas. Además, cubre el ciclo de vida de un crate —desde publicación y versionado hasta gestionar proyectos multi-paquete mediante workspaces y extender la funcionalidad nativa de Cargo.

Resultados del aprendizaje:

• Configurar Perfiles de Lanzamiento para equilibrar velocidad de compilación y rendimiento en tiempo de ejecución.
• Generar y verificar comentarios de documentación que sirven como guías para usuarios y pruebas automatizadas.
• Diseñar una API pública conveniente usando reexportaciones (pub use) para desacoplar la estructura interna del uso externo.

🔹 Lección 15: Punteros inteligentes

Resumen: Esta lección explora los Punteros Inteligentes de Rust: estructuras de datos que actúan como punteros pero llevan metadatos adicionales y capacidades. Nos enfocamos en gestionar asignaciones en el montón con Box<T>, habilitar propiedad compartida con Rc<T> y eludir las estrictas reglas de préstamo mediante el patrón de Mutabilidad Interna con RefCell<T>. Además, cubrimos los traits Deref y Drop que subyacen al comportamiento de punteros inteligentes y la limpieza de recursos.

Resultados del aprendizaje:

• Implementar estructuras de datos recursivas usando Box<T> para proporcionar indirección y tamaños de memoria conocidos.
• Personalizar el comportamiento de punteros y gestión de recursos usando los traits Deref y Drop.
• Gestionar múltiples propietarios y mutabilidad verificada en tiempo de ejecución combinando Rc<T> y RefCell<T>.

🔹 Lección 16: Concurrencia sin temor

Resumen: Esta lección explora la filosofía de "Concurrencia sin temor" de Rust, demostrando cómo el lenguaje aprovecha sus sistemas de propiedad y tipos para convertir la programación concurrente de un campo minado en una certeza en tiempo de compilación. Cubre la creación de hilos, la comunicación segura mediante pasaje de mensajes, la gestión de estado compartido usando mutexes y los traits fundamentales que definen la seguridad de los hilos.

Resultados del aprendizaje:

• Crear y gestionar hilos usando spawn y join, resolviendo conflictos de propiedad con la palabra clave move.
• Implementar concurrencia mediante pasaje de mensajes usando canales mpsc para transferir datos de forma segura entre hilos.
• Gestionar estado compartido entre múltiples hilos usando Mutex<T> para exclusión mutua y Arc<T> para contaje de referencias seguro para hilos.

🔹 Lección 17: Programación orientada a objetos en Rust

Resumen: Esta lección explora cómo Rust implementa principios básicos de programación orientada a objetos (POO), centrándose específicamente en encapsulación y polimorfismo. Detalla los mecanismos de objetos de trait para manejar colecciones heterogéneas y los compromisos entre dispatch estático y dinámico. Finalmente, compara la implementación del patrón Estado clásico con un enfoque más idiomático de Rust de codificar estados y comportamientos directamente en el sistema de tipos.

Resultados del aprendizaje:

• Implementar encapsulación en Rust usando módulos y modificadores de visibilidad para ocultar el estado interno.
• Utilizar objetos de trait para lograr polimorfismo y entender las implicaciones de rendimiento del dispatch estático frente al dinámico.
• Aplicar el patrón Estado para gestionar comportamientos complejos de objetos y transiciones entre estados.

🔹 Lección 18: Patrones y coincidencia avanzados

Resumen: Esta lección explora la profundidad del sistema de coincidencia de patrones de Rust, avanzando más allá de brazos simples de match hacia extracción sofisticada de datos y flujo de control. Los estudiantes dominarán la distinción entre patrones irrefutables y refutables, aprenderán a desestructurar estructuras anidadas complejas y utilizarán sintaxis avanzada como guardas de match y vinculaciones para escribir código más expresivo y seguro.

Resultados del aprendizaje:

• Distinguir entre patrones irrefutables y refutables y aplicarlos a los constructos adecuados de Rust (por ejemplo, let vs. if let).
• Desestructurar structs, enums y tuplas para extraer datos específicos en variables locales.
• Emplear sintaxis de patrones avanzada, incluyendo rangos, múltiples patrones, ignorar valores y vinculaciones @ para coincidencia condicional compleja.

🔹 Lección 19: Funcionalidades avanzadas y Rust inseguro

Resumen: Esta lección explora los "superpoderes" de Rust que permiten a los desarrolladores saltarse ciertas restricciones del compilador y crear abstracciones altamente flexibles. Cubre el uso de Rust inseguro para manipulación de memoria de bajo nivel, técnicas avanzadas de traits para relaciones de tipos complejas y las potentes capacidades de metaprogramación de Macros Declarativos y Procedimentales.

Resultados del aprendizaje:

• Distinguir entre Rust seguro y los "superpoderes" inseguros necesarios para manipulación de punteros directos y llamadas a funciones inseguras.
• Implementar patrones de trait avanzados incluyendo Tipos Asociados, Sobrecarga de Operadores, Supertraits y el patrón Newtype.
• Diferenciar llamadas a métodos usando Sintaxis de Calificación Total y gestionar tipos complejos como Tipos de Tamaño Dinámico (DSTs) y Alias de Tipo.

🔹 Lección 20: Proyecto final: Servidor web multihilo

Resumen: Esta lección guía el desarrollo de un servidor web de alto rendimiento usando primitivas de red y concurrencia de Rust. Cubre la transición de un listener TCP básico a un sistema multihilo sofisticado que utiliza un grupo de hilos personalizado. Los estudiantes aprenderán a gestionar flujos de bajo nivel, implementar pasaje de mensajes basado en trabajadores para distribuir tareas y asegurar la estabilidad del sistema mediante un mecanismo de apagado ordenado.

Resultados del aprendizaje:

• Establecer y gestionar conexiones TCP: Vincular un servidor a un puerto local y manejar flujos de bytes entrantes.
• Analizar y responder solicitudes HTTP: Leer datos de solicitud cruda y construir respuestas HTTP válidas con líneas de estado y cuerpos HTML.
• Arquitectar un grupo de hilos personalizado: Usar canales mpsc y primitivas de sincronización (Arc, Mutex) para distribuir tareas entre un número finito de hilos.

🔹 Lección 21: Apéndices de Rust: Herramientas y referencias

Resumen: Esta lección proporciona una referencia técnica completa para el lenguaje de programación Rust, centrándose en su sintaxis densa, herramientas de desarrollo automatizadas y proceso evolutivo de lanzamientos. Los estudiantes aprenderán a navegar la sintaxis cargada de símbolos de Rust, implementar comportamientos estándar mediante traits derivables y aprovechar la herramientería del ecosistema para mantener una alta calidad de código y seguir la filosofía de "estabilidad sin estancamiento" del lenguaje.

Resultados del aprendizaje:

• Identificar e interpretar la sintaxis: Descodificar operadores de Rust, símbolos relacionados con rutas y restricciones genéricas usando tablas de referencia estandarizadas.
• Implementar comportamientos estándar: Automatizar la implementación de traits Debug, Clone, Eq, Ord y Hash usando el atributo derive.
• Optimizar el flujo de desarrollo: Utilizar rustfmt, rustfix y Clippy para formatear, reparar y analizar código según las normas de la comunidad.