LENGUAJE DE PROGRAMACIÓN RUST

Prólogo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xix
Prefacio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xxi
Agradecimientos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xxiii
Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .xxv
Capítulo 1. Empezamos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
Capítulo 2. Programación de un juego de adivinanzas . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Capítulo 3. Conceptos de programación habituales. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Capítulo 4. Comprensión de la propiedad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
Capítulo 5. Uso de structs para estructurar datos relacionados . . . . . . . . . . . . . . . . . . . . . 91
Capítulo 6. Enums y coincidencia de patrones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
Capítulo 7. Gestión de proyectos en expansión con paquetes, crates y módulos . . . . . . . . 127
Capítulo 8. Colecciones típicas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
Capítulo 9. Gestión de errores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
Capítulo 10. Tipos genéricos, traits y lifetimes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
Capítulo 11. Escritura de pruebas automatizadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229
Capítulo 12. Proyecto de E/S: construcción de un programa de línea de comandos . . . . . 259
Capítulo 13. Características de los lenguajes funcionales: iteradores y closures . . . . . . . . 291
Capítulo 14. Más sobre Cargo y Crates.io . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315
Capítulo 15. Punteros inteligentes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335
Capítulo 16. Concurrencia sin preocupación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 375
Capítulo 17. Características de la programación orientada a objetos . . . . . . . . . . . . . . . 399
Capítulo 18. Patrones y coincidencias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 423
Capítulo 19. Características avanzadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 447
Capítulo 20. Proyecto final: creación de un servidor web multihilo . . . . . . . . . . . . . . . . . 491
Apéndice A. Palabras clave . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 529
Apéndice B. Operadores y símbolos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 533
Apéndice C. Traits derivables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 541
Apéndice D. Herramientas útiles de desarrollo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 547
Apéndice E. Ediciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 551

Descubra el mundo de Rust, el revolucionario lenguaje de programación de sistemas de código abierto que combina eficiencia con ergonomía. Le permitirá mejorar la productividad y evitar las molestias habituales con los lenguajes más sencillos. Este libro es un referente internacional y gran guía para navegar por las características y capacidades únicas de Rust. Escrito por Klabnik y Nichols, antiguos miembros del Rust Core Team, este manual le introducirá desde los conceptos más básicos hasta las técnicas más avanzadas. Le permitirá escribir software más rápido y confiable. - Aprenderá las innovadoras características de Rust, como la propiedad, el préstamo, los tiempos de vida, los genéricos, los traits y los objetos trait para comunicar las restricciones de su programa al compilador. - Conocerá los punteros inteligentes y multihilo, y cómo la propiedad interactúa con ellos para permitir una concurrencia segura. - Asimilará cómo utilizar Cargo, el gestor de paquetes integrado en Rust, para compilar, documentar el código y gestionar las dependencias. - Interiorizará las mejores maneras para probar, gestionar errores, refactorizar y aprovechar la concordancia expresiva de patrones. Además de los innumerables ejemplos de código, encontrará tres capítulos dedicados a la elaboración de proyectos completos: un juego numérico de adivinanzas, la implementación en Rust de una herramienta de línea de comandos y un servidor multihilo. Este libro de programación es esencial para todo desarrollador, tanto si está buscando iniciar su viaje en Rust como si busca perfeccionar sus habilidades. ¡Embárquese en este viaje y domine Rust! SOBRE LOS AUTORES: Steve Klabnik fue jefe del equipo de documentación de Rust y uno de sus principales desarrolladores. Klabnik es un conferenciante habitual y un prolífico colaborador de código abierto. Carol Nichols es miembro del equipo de Rust Crates.io y antigua miembro del Rust Core Team. Nichols es cofundadora de Integer 32, la primera consultoría de software del mundo centrada en Rust, y también ha organizado la Rust Belt Rust Conference.