1. El Lenguaje de Programación Rust
  2. Prefacio
  3. Introducción
  4. 1. Empezando
    1. 1.1. Instalación
    2. 1.2. ¡Hola, Mundo!
    3. 1.3. ¡Hola, Cargo!
  5. 2. Programando un juego de adivinanzas
  6. 3. Conceptos Comunes de Programación
    1. 3.1. Variables y Mutabilidad
    2. 3.2. Tipos de Datos
    3. 3.3. Funciones
    4. 3.4. Comentarios
    5. 3.5. Flujo de Control
  7. 4. Entendiendo el Ownership
    1. 4.1. ¿Qué es el Ownership?
    2. 4.2. Referencias y Prestamos
    3. 4.3. El Tipo Slice
  8. 5. Usando Structs para Estructurar Datos Relacionados
    1. 5.1. Definiendo e Instanciando Structs
    2. 5.2. Un Programa de Ejemplo Usando Structs
    3. 5.3. Sintaxis de Métodos
  9. 6. Enums y Pattern Matching
    1. 6.1. Definiendo un Enum
    2. 6.2. El operador de control de flujo match
    3. 6.3. Flujo de Control Conciso con if let y let else
  10. 7. Administrando Proyectos en Crecimiento con Paquetes, Crates y Módulos
    1. 7.1. Paquetes y Crates
    2. 7.2. Definiendo módulos para controlar el scope y la privacidad
    3. 7.3. Paths para referirse a un item en el árbol de módulos
    4. 7.4. Incluyendo rutas al Scope con la palabra clave use
    5. 7.5. Separando Módulos en Diferentes Archivos
  11. 8. Colecciones comunes
    1. 8.1. Almacenando listas de valores con vectores
    2. 8.2. Almacenando texto codificado en UTF-8 con Strings
    3. 8.3. Almacenar Claves con Valores Asociados en HashMaps
  12. 9. Manejo de Errores
    1. 9.1. Errores irrecuperables con panic!
    2. 9.2. Errores recuperables con Result
    3. 9.3. panic! o no panic!
  13. 10. Tipos Genéricos, Traits y Lifetimes
    1. 10.1. Tipos de Datos Genéricos
    2. 10.2. Traits: Definiendo Comportamiento Compartido
    3. 10.3. Validando Referencias con Lifetimes
  14. 11. Escribiendo Tests Automatizados
    1. 11.1. Cómo Escribir Tests
    2. 11.2. Controlando Cómo Los Tests Son Ejecutados
    3. 11.3. Organización De Los Tests
  15. 12. Un proyecto de I/O: Construyendo un programa de línea de comandos
    1. 12.1. Aceptando argumentos de línea de comandos
    2. 12.2. Leyendo un archivo
    3. 12.3. Refactorizando para mejorar la modularidad y el manejo de errores
    4. 12.4. Desarrollando la funcionalidad de la biblioteca con T.D.D.
    5. 12.5. Trabajando con Variables de Entorno
    6. 12.6. Escribiendo mensajes de error estándar en lugar del output estándar
  16. 13. Características De Lenguajes Funcionales: Iteradores y Closures
    1. 13.1. Closures: Funciones anónimas que capturan su entorno
    2. 13.2. Procesando una serie de elementos con Iteradores
    3. 13.3. Mejorando nuestro proyecto I/O
    4. 13.4. Comparando Performance: Bucles vs. Iteradores
  17. 14. Más sobre Cargo y Crates.io
    1. 14.1. Personalizando Compilaciones con Perfiles de Lanzamiento
    2. 14.2. Publicando un Crate a Crates.io
    3. 14.3. Cargo Workspaces
    4. 14.4. Instalando Binarios con cargo install
    5. 14.5. Extendiendo Cargo con Comandos Personalizados
  18. 15. Smart Pointers
    1. 15.1. Usando Box<T> para Apuntar a Datos en el Heap
    2. 15.2. Tratando los Smart Pointers como Referencias Regulares con el Trait Deref
    3. 15.3. Ejecutando Código al Limpiar con el Trait Drop
    4. 15.4. Rc<T>, el Smart Pointer de Conteo de Referencias
    5. 15.5. RefCell<T> y el Patrón de Mutabilidad Interior
    6. 15.6. Referencias Circulares Pueden Fugar Memoria
  19. 16. Concurrencia sin miedo
    1. 16.1. Usando Threads para Ejecutar Código Simultáneamente
    2. 16.2. Usando el Pasaje de Mensajes para Transferir Datos entre Hilos
    3. 16.3. Concurrencia con Estado Compartido
    4. 16.4. Concurrencia extensible con los traits Sync y Send
  20. 17. Fundamentos de la Programación Asíncrona: Async, Await, Futures y Streams
    1. 17.1. Futures y la sintaxis Async
    2. 17.2. Aplicando Concurrencia Con Async
    3. 17.3. Trabajar con cualquier número de futuros
    4. 17.4. Streams
    5. 17.5. Profundizando en los Traits para Async
    6. 17.6. Futuros, tareas e hilos
  21. 18. Rust como un Lenguaje de Programación Orientado a Objetos
    1. 18.1. Características de Lenguajes Orientados a Objetos
    2. 18.2. Usando Trait Objects que Permiten Valores de Diferentes Tipos
    3. 18.3. Implementando un Patrón de Diseño Orientado a Objetos
  22. 19. Patterns and Matching
    1. 19.1. Todos los lugares donde se pueden usar Patterns
    2. 19.2. Refutabilidad: Si un Pattern Puede Fallar al Hacer Match
    3. 19.3. Sintaxis de los Patterns
  23. 20. Características Avanzadas
    1. 20.1. Rust Inseguro
    2. 20.2. Traits Avanzados
    3. 20.3. Tipos Avanzados
    4. 20.4. Funciones y Closures Avanzados
    5. 20.5. Macros
  24. 21. Proyecto Final: Construyendo un Servidor Web Multithread
    1. 21.1. Construyendo un Servidor Web de un Solo Hilo
    2. 21.2. Convirtiendo Nuestro Servidor de un solo Hilo en un Servidor Multihilo
    3. 21.3. Apagado y limpieza eficientes
  25. 22. Apéndice
    1. 22.1. A - Palabras claves
    2. 22.2. B - Operadores y Símbolos
    3. 22.3. C - Traits derivables
    4. 22.4. D - Herramientas de desarrollo útiles
    5. 22.5. E - Ediciones
    6. 22.6. F - Traducciones del libro
    7. 22.7. G - Cómo se hace Rust y “Rust Nightly”

El Lenguaje de Programación Rust

Apéndice F: Traducciones del libro

Para recursos en idiomas distintos al inglés. La mayoría aún están en progreso; consulte la etiqueta de traducciones para ayudar o informarnos sobre una nueva traducción.

  • Português (BR)
  • Português (PT)
  • 简体中文: KaiserY/trpl-zh-cn, gnu4cn/rust-lang-Zh_CN
  • 正體中文
  • Українська
  • Español, alternate, esta versión
  • Русский
  • 한국어
  • 日本語
  • Français
  • Polski
  • Cebuano
  • Tagalog
  • Esperanto
  • ελληνική
  • Svenska
  • Farsi, Persian (FA)
  • Deutsch
  • हिंदी
  • ไทย
  • Danske