Para compilar un programa en Rust, puedes usar la herramienta cargo.

Paso 1. Crear un proyecto

1. En tu terminal, escribe cargo new hello-rust.

2. Cargo creará un directorio hello-rust con los
archivos Cargo.toml, src, y main.rs.
3. En src/main.rs escribe el código de tu aplicación.
Paso 2. Compilar el programa

1. Para compilar el programa, escribe cargo build.

2. El resultado se encontrará en target/debug/.
3. Para compilar con optimizaciones, escribe cargo build --release.
4. El resultado se encontrará en target/release/.
Paso 3. Ejecutar el programa

1. Muévete al directorio del proyecto.

2. Escribe cargo run en tu terminal.
Otras cosas que puedes hacer

 Revisar el proyecto en busca de errores con cargo check.

 Añadir dependencias a tu aplicación editando Cargo.toml.
 Encontrar bibliotecas en crates.io, el registro de paquetes para
proyectos Rust.
Rust es un lenguaje de programación compilado, de propósito general y
multiparadigma.

El futuro del óxido en 2025 [Principales tendencias y

predicciones]
Última actualización: 29 de noviembre de 2024



Rust se ha consolidado como un nuevo rival en el cambiante mundo
de los lenguajes de programación . Es un lenguaje innovador que se
está haciendo notar rápidamente, atrayendo a los desarrolladores
gracias a su asombroso rendimiento, su robusta seguridad de memoria
y sus dinámicas funciones concurrentes.
Pero ¿qué ocurre realmente en Rust y cuáles son algunos de los
posibles desarrollos futuros? Este artículo profundizará en un
análisis exhaustivo de las principales fortalezas de Rust,
destacará las tendencias actuales que lo configuran de cara al
futuro y predecirá el comportamiento de las futuras versiones.

¿Qué es Rust?
Rust es un lenguaje de programación multiparadigma que está
ganando terreno gracias a su combinación única de potencia y
seguridad. Prioriza un rendimiento excepcional; su velocidad bruta es
comparable a la de C o C++. Sin embargo, a diferencia de estos
lenguajes, Rust garantiza la seguridad mediante la
comprobación de memoria en tiempo de compilación, lo que
elimina errores que podrían causar fallos. Todas estas cualidades
lo hacen ideal para desarrolladores que desean crear aplicaciones de
alto rendimiento fiables en múltiples ámbitos, como el desarrollo web y
los sistemas embebidos, el aprendizaje automático o la creación de
juegos.

Estado actual de Rust

Rust se ha hecho un nombre en el mundo de la programación al atraer
a los desarrolladores con sus atractivas ventajas:
 Velocidad y rendimiento: las aplicaciones Rust pueden
igualar a C y C++ en términos de rendimiento bruto, lo que
las hace ideales para tareas computacionalmente intensivas
como el desarrollo de juegos, la programación de sistemas y el
comercio de alta frecuencia.
 Seguridad de memoria: Rust se basa en un sistema de
propiedad como aspecto fundamental. Esto significa que
todas las asignaciones de memoria dentro del programa
deben realizarse en tiempo de compilación. Como resultado,
los desbordamientos de búfer y los punteros colgantes ya no
son posibles, lo que lo hace más seguro que nunca.
 Concurrencia: Gracias a su modelo de propiedad, canales y
mutex, entre otros, Rust facilita el desarrollo de programas
concurrentes sin competencia. También facilita programas
multihilo que se ejecutan en varios núcleos de forma
eficiente.
 Características modernas del lenguaje: El lenguaje ha
incorporado diversas características modernas, como la
coincidencia de patrones, cierres y genéricos, en su
amplio conjunto. Estas características contribuyen a mejorar la
legibilidad, la expresividad y la facilidad de mantenimiento del
código.
  Código abierto e impulsado por la comunidad: Rust es
un proyecto de código abierto próspero con una comunidad
apasionada y activa. Esto fomenta el desarrollo continuo, una
gran cantidad de bibliotecas y herramientas, y una excelente
documentación.

Análisis de la última versión

La última versión estable, Rust 1.76 (al 11 de marzo de 2024) . A
continuación, se ofrece un análisis más profundo de algunas de las
características y mejoras clave introducidas en Rust 1.76:
 Estabilidad de la ABI (Interfaz Binaria de Aplicación): La
nueva versión incorpora el determinismo de la ABI para
Rust , lo que garantiza la interoperabilidad entre diferentes
versiones del lenguaje. Esto simplifica el desarrollo y la
distribución de bibliotecas de Rust.
 Intrínsecos SIMD (Instrucción Única, Múltiples Datos)
Ampliados: Esto también significa que la biblioteca estándar
cuenta con más intrínsecos para brindar a los desarrolladores
que desean un control preciso sobre las operaciones
SIMD. Esto puede mejorar aún más el rendimiento en el código
vectorizado.
 Manejo de errores mejorado: El manejo de errores continúa
evolucionando con la macro try_blocks!. Los códigos
complejos se simplifican al usar esta macro durante el manejo
de errores.
 Tiempos de compilación más rápidos: las optimizaciones
nunca terminan para el equipo de compilación de Rust y hay
mejoras notables en los tiempos de compilación para muchos
proyectos realizados por Rust 1.76.
 Enfoque en la experiencia del desarrollador: El equipo de
Rust ha seguido prestando atención a la experiencia del
desarrollador. Esta versión simplifica los mensajes de error y
mejora la documentación y las herramientas para los usuarios,
entre otras cosas.

Todo este progreso continúa consolidando el lugar de Rust como un

lenguaje de programación maduro y potente, preparado para
problemas de programación complejos.
Comparación de Rust con otros lenguajes
Si bien Rust brilla con su combinación única de características ,
es valioso comprender cómo se compara con otros lenguajes
populares:
C/C++
 Similitudes: Ambos lenguajes priorizan el rendimiento y
ofrecen un control detallado sobre la gestión de la memoria.
 Diferencias:
 o Seguridad de la memoria: el sistema de
propiedad de Rust refuerza la seguridad de la
memoria en el momento de la compilación,
eliminando toda una categoría de errores
predominantes en C/C++.
o Curva de aprendizaje: el sistema de
propiedad de Rust tiene una curva de
aprendizaje más pronunciada en comparación
con C/C++.
Java
 Similitudes: Ambos son lenguajes maduros con amplios
ecosistemas y un fuerte apoyo de la comunidad.
 Diferencias:
o Rendimiento: Rust generalmente supera a
Java en velocidad y uso de memoria.
o Concurrencia: el sistema de propiedad de
Rust simplifica la escritura de código
concurrente seguro, mientras que Java requiere
más esfuerzo manual.
Ir
 Similitudes: Ambos priorizan la concurrencia y ofrecen
recolección de basura, lo que simplifica la gestión de la
memoria.
 Diferencias:
o Rendimiento: Rust puede lograr un mejor
rendimiento que Go en algunos casos,
especialmente para tareas de bajo nivel.
o Programación de sistemas: Rust es más
adecuado para la programación de sistemas
debido a su control de memoria de grano fino.

Las principales tendencias que moldean el futuro del óxido

1. Integración con WASM (WebAssembly)
WASM es revolucionario y significa que la fusión de Rust y WASM será
fluida. En consecuencia, los desarrolladores podrán crear aplicaciones
web de alto rendimiento que se ejecuten directamente en
navegadores, superando así los límites del desarrollo web. Esto
significa que, con el tiempo, se crearán experiencias web más
interactivas y de mayor rendimiento utilizando Rust y WASM.

2. Sistemas integrados
Dada su eficiencia y seguridad de memoria, muchos
desarrolladores optan por usar Rust en sistemas embebidos
con recursos limitados. Este uso de Rust podría ser más frecuente
en dispositivos IoT , wearables y sistemas en tiempo real que requieren
un funcionamiento rápido y fiable.
3. Aprendizaje automático (ML) e inteligencia artificial (IA)
Rust también ofrece ventajas para desarrollar aplicaciones
de aprendizaje automático e inteligencia artificial que gestionan
estructuras de datos complejas o gestionan la memoria de forma
eficiente. En el futuro, se utilizarán más bibliotecas y conjuntos de
herramientas para Rust, diseñados para computación científica o de
aprendizaje profundo.

4. DevOps y desarrollo en la nube

El uso de los principios de DevOps junto con las
infraestructuras en la nube requiere herramientas fiables y
escalables. Por lo tanto, será necesario desarrollar estas herramientas
en el lenguaje de programación Rust. Es posible que veamos más
soluciones de automatización de infraestructura y gestión de
configuración escritas en Rust.

5. Desarrollo de juegos
Las exigencias de la industria de los videojuegos, que buscan
constantemente mejorar el rendimiento y la seguridad de la memoria,
se complementan a la perfección con las fortalezas de Rust. Por lo
tanto, se esperan más motores de juego y herramientas de
desarrollo de software similares desarrollados con Rust , lo que
mejorará la fluidez de las operaciones durante los juegos, entre otras
cosas.

6. Centrarse en la experiencia del desarrollador

La comunidad de Rust trabaja continuamente para mejorar la
experiencia del desarrollador. Esto incluye mejoras en las
herramientas, la documentación y las bibliotecas. Esperamos
mejores mensajes de error, herramientas más intuitivas como
Cargo y un flujo de trabajo de desarrollo más fluido en futuras
versiones de Rust.

7. Interoperabilidad con otros lenguajes

Se trabaja para garantizar la compatibilidad de Rust con otros
lenguajes, como C y C++. La integración de los componentes de
Rust en el código existente permite a los programadores crear
aplicaciones híbridas que aprovechan tanto Rust como otros lenguajes.

Prediciendo el futuro: Inclusiones de funciones en las próximas

versiones de Rust
Si bien es difícil saber con exactitud qué novedades habrá en cuanto a
las versiones de Rust, existen algunas indicaciones en las que podemos
confiar, basadas en las tendencias actuales y los debates en la
comunidad. Aquí presentamos algunas características que
podrían surgir en los próximos años.

1. Funciones mejoradas en tiempo de compilación

 Genéricos Constantes Avanzados: Los genéricos
constantes permiten definir constantes en tiempo de
compilación. Es posible que veamos futuras extensiones de
esta función, lo que permitirá capacidades de
metaprogramación más complejas.
 Evaluación de funciones en tiempo de compilación: se
podría explorar la capacidad de evaluar funciones en tiempo
de compilación, lo que potencialmente conduciría a
optimizaciones del rendimiento y reducciones del tamaño del
código.

2. Manejo de errores mejorado

 Manejo de errores de grano fino: el manejo de errores de
Rust ya es sólido, pero podría haber más mejoras para un
control más granular sobre la propagación y el manejo de
errores.
 Tipos de error personalizados con características: la
capacidad de definir tipos de error personalizados con
características asociadas podría ofrecer más flexibilidad y
seguridad de tipos al tratar con errores.

3. Funciones avanzadas del lenguaje

 Mejoras en la coincidencia de patrones: La coincidencia
de patrones es una potente función de Rust. Podríamos ver
extensiones para la coincidencia de patrones en estructuras de
datos más complejas o la introducción de la comprobación
exhaustiva de patrones.
 Macros 2.0: Las macros son una herramienta poderosa para
la generación de código en Rust. Una posible iteración de
" Macros 2.0 " podría introducir mejoras en la higiene, la
seguridad y la expresividad.

4. Centrarse en la experiencia del desarrollador

 Integración de IDE mejorada: espere una
mejor integración entre Rust y las IDE más populares , lo
que dará como resultado una experiencia de desarrollo más
fluida con funciones como finalización de
código , refactorización y mejoras de depuración .
 Proceso de compilación simplificado: el sistema de
compilación de Cargo podría simplificarse aún más para que la
configuración del proyecto y la gestión de dependencias sean
aún más fáciles de usar.
  Documentación y tutoriales mejorados: La comunidad de
Rust es conocida por su excelente documentación. Esperamos
seguir invirtiendo en documentación y tutoriales de alta
calidad para facilitar el aprendizaje de los nuevos
desarrolladores.

5. Evolución de las características de concurrencia

 Iteradores asíncronos: La programación asíncrona cobra
cada vez mayor importancia. Podríamos ver la introducción de
iteradores asíncronos para simplificar el trabajo con flujos de
datos asíncronos.
 Compatibilidad con el modelo de actores: El modelo de
actores es un patrón de concurrencia popular. Posibles
versiones futuras de Rust podrían incorporar compatibilidad
con actores a nivel de lenguaje, simplificando así el desarrollo
de sistemas concurrentes y tolerantes a fallos.

Sin embargo, el equipo de Rust implementará las funciones más

urgentes gracias a la comunidad y a los comentarios, ya que
son solo estimaciones. Con esta información, puedes anticipar los
desarrollos futuros de Rust y aprovechar al máximo sus capacidades de
desarrollo.

Conclusión
En conclusión, Rust parece estar listo para despegar en el
cambiante mundo de los lenguajes de programación. Para una
amplia gama de tareas de desarrollo, es la opción ideal gracias a su
rendimiento inigualable, robustez ante errores de memoria y
concurrencia. Desde aplicaciones web de alto rendimiento hasta
tecnologías blockchain seguras y sistemas en tiempo real, Rust permite
a los desarrolladores crear software sólido, fiable y productivo. Su
orientación centrada en la experiencia del desarrollador, junto
con una comunidad de apoyo próspera y una hoja de ruta
repleta de desarrollos emocionantes, impulsan el futuro de
Rust. Si buscas un lenguaje que trascienda los límites del desarrollo de
software, no busques más: Rust lo es. Se trata de invertir en tu
futuro, permitiéndote producir código excelente línea a línea.
Debes leer:
 El futuro de Angular JS en 2024 [Principales tendencias
y predicciones]
 El futuro de React en 2024 [Principales tendencias y
predicciones]
 El futuro de PHP en 2024 [Principales tendencias y
predicciones]
El lenguaje de programación Rust
por Steve Klabnik, Carol Nichols y Chris Krycho, con contribuciones de la
comunidad Rust

Esta versión del texto asume que estás usando Rust 1.82.0 (publicado el
17 de octubre de 2024) o una versión posterior. Consulta la sección
“Instalación” del Capítulo 1 para instalar o actualizar Rust.

El formato HTML está disponible en línea

en https://doc.rust-lang.org/stable/book/ y fuera de línea con
instalaciones de Rust realizadas con rustup; ejecutar rustup doc --
bookpara abrir.

También están disponibles varias traducciones comunitarias.

Este texto está disponible en formato de libro de bolsillo y libro
electrónico en No Starch Press .

🚨 ¿Quieres una experiencia de aprendizaje más interactiva?

Prueba una versión diferente del libro Rust, que incluye:
cuestionarios, resaltado, visualizaciones y más : https://rust-
book.cs.brown.edu

Prefacio
No siempre fue tan claro, pero el lenguaje de programación Rust se trata
fundamentalmente de empoderamiento : no importa qué tipo de código
estés escribiendo ahora, Rust te permite llegar más lejos y programar
con confianza en una variedad más amplia de dominios que antes.

Tomemos, por ejemplo, el trabajo a “nivel de sistemas” que se ocupa de

los detalles de bajo nivel de la gestión de la memoria, la representación
de datos y la concurrencia. Tradicionalmente, este ámbito de la
programación se considera arcano, accesible sólo para unos pocos
elegidos que han dedicado los años necesarios a aprender para evitar
sus infames trampas. E incluso quienes lo practican lo hacen con
cautela, para que su código no quede expuesto a vulnerabilidades, fallos
o corrupción.

Rust derriba estas barreras eliminando los viejos obstáculos y

proporcionando un conjunto de herramientas amigables y pulidas para
ayudarte en el camino. Los programadores que necesitan “meterse de
lleno” en el control de nivel inferior pueden hacerlo con Rust, sin asumir
el riesgo habitual de fallos o agujeros de seguridad, y sin tener que
aprender los puntos finos de una cadena de herramientas caprichosa.
Mejor aún, el lenguaje está diseñado para guiarte de forma natural hacia
un código confiable que sea eficiente en términos de velocidad y uso de
memoria.
Los programadores que ya trabajan con código de bajo nivel pueden
usar Rust para aumentar sus ambiciones. Por ejemplo, introducir
paralelismo en Rust es una operación de riesgo relativamente bajo: el
compilador detectará los errores clásicos por ti. Y puedes abordar
optimizaciones más agresivas en tu código con la confianza de que no
introducirás fallas o vulnerabilidades accidentalmente.

Pero Rust no se limita a la programación de sistemas de bajo nivel. Es lo

suficientemente expresivo y ergonómico como para hacer que las
aplicaciones CLI, los servidores web y muchos otros tipos de código sean
bastante agradables de escribir (encontrarás ejemplos simples de ambos
más adelante en el libro). Trabajar con Rust te permite desarrollar
habilidades que se transfieren de un dominio a otro; puedes aprender
Rust escribiendo una aplicación web y luego aplicar esas mismas
habilidades para apuntar a tu Raspberry Pi.

Este libro aprovecha al máximo el potencial de Rust para empoderar a

sus usuarios. Es un texto amigable y accesible que tiene como objetivo
ayudarte a mejorar no solo tu conocimiento de Rust, sino también tu
alcance y confianza como programador en general. ¡Así que sumérgete,
prepárate para aprender y bienvenido a la comunidad de Rust!
— Nicholas Matsakis y Aaron Turon

Introducción
Nota: Esta edición del libro es la misma que The Rust Programming
Language, disponible en formato impreso y de libro electrónico en No
Starch Press .

Bienvenido a The Rust Programming Language , un libro introductorio

sobre Rust. El lenguaje de programación Rust le ayuda a escribir
software más rápido y más confiable. La ergonomía de alto nivel y el
control de bajo nivel suelen estar en conflicto en el diseño de lenguajes
de programación; Rust desafía ese conflicto.

Al equilibrar una poderosa capacidad técnica y una excelente

experiencia para desarrolladores, Rust le brinda la opción de controlar
detalles de bajo nivel (como el uso de memoria) sin todas las molestias
tradicionalmente asociadas con dicho control.

¿Para quién es el óxido?

El óxido es ideal para muchas personas por diversas razones. Veamos
algunos de los grupos más importantes.

Equipos de desarrolladores
Rust está demostrando ser una herramienta productiva para la
colaboración entre grandes equipos de desarrolladores con distintos
niveles de conocimiento de programación de sistemas. El código de bajo
nivel es propenso a diversos errores sutiles, que en la mayoría de los
demás lenguajes solo se pueden detectar mediante pruebas exhaustivas
y una revisión cuidadosa del código por parte de desarrolladores
experimentados. En Rust, el compilador cumple una función de guardián
al negarse a compilar código con estos errores elusivos, incluidos los
errores de concurrencia. Al trabajar junto con el compilador, el equipo
puede dedicar su tiempo a centrarse en la lógica del programa en lugar
de buscar errores.

Rust también aporta herramientas de desarrollo contemporáneas al

mundo de la programación de sistemas:
 Cargo, el administrador de dependencias y herramienta de
compilación incluidos, hace que agregar, compilar y administrar
dependencias sea sencillo y consistente en todo el ecosistema
Rust.
 La herramienta de formato Rustfmt garantiza un estilo de
codificación consistente entre los desarrolladores.
 El analizador de óxido potencia la integración del entorno de
desarrollo integrado (IDE) para completar código y enviar
mensajes de error en línea.

Al utilizar estas y otras herramientas en el ecosistema Rust, los

desarrolladores pueden ser productivos mientras escriben código a nivel
de sistema.

Estudiantes
Rust está dirigido a estudiantes y a quienes estén interesados en
aprender sobre conceptos de sistemas. Con Rust, muchas personas han
aprendido sobre temas como el desarrollo de sistemas operativos. La
comunidad es muy acogedora y está dispuesta a responder las
preguntas de los estudiantes. A través de iniciativas como este libro, los
equipos de Rust quieren hacer que los conceptos de sistemas sean más
accesibles para más personas, especialmente para aquellos que son
nuevos en la programación.

Empresas
Cientos de empresas, grandes y pequeñas, utilizan Rust en producción
para una variedad de tareas, incluidas herramientas de línea de
comandos, servicios web, herramientas DevOps, dispositivos integrados,
análisis y transcodificación de audio y video, criptomonedas,
bioinformática, motores de búsqueda, aplicaciones de Internet de las
cosas, aprendizaje automático e incluso partes importantes del
navegador web Firefox.

Desarrolladores de código abierto

Rust es para personas que desean desarrollar el lenguaje de
programación, la comunidad, las herramientas para desarrolladores y las
bibliotecas de Rust. Nos encantaría que contribuyeras al lenguaje Rust.

Personas que valoran la velocidad y la estabilidad

Rust es para aquellos que buscan velocidad y estabilidad en un lenguaje.
Por velocidad, nos referimos tanto a la rapidez con la que se puede
ejecutar el código de Rust como a la velocidad a la que Rust permite
escribir programas. Las comprobaciones del compilador de Rust
garantizan la estabilidad mediante la incorporación de funciones y la
refactorización. Esto contrasta con el frágil código heredado de los
lenguajes sin estas comprobaciones, que los desarrolladores suelen
tener miedo de modificar. Al esforzarse por lograr abstracciones de coste
cero, funciones de nivel superior que se compilan en código de nivel
inferior tan rápido como el código escrito manualmente, Rust se
esfuerza por hacer que el código seguro sea también código rápido.

El lenguaje Rust espera dar soporte también a muchos otros usuarios;

los mencionados aquí son solo algunos de los principales interesados. En
general, la mayor ambición de Rust es eliminar las desventajas que los
programadores han aceptado durante décadas al ofrecer
seguridad y productividad, velocidad y ergonomía. Pruebe Rust y vea si
sus opciones funcionan para usted.

Para quién es este libro

Este libro asume que has escrito código en otro lenguaje de
programación, pero no hace ninguna suposición sobre cuál. Hemos
intentado que el material sea ampliamente accesible para personas con
una amplia variedad de antecedentes en programación. No dedicamos
mucho tiempo a hablar sobre qué es la programación o cómo pensar en
ella. Si eres completamente nuevo en programación, te resultará más
útil leer un libro que proporcione específicamente una introducción a la
programación.

Cómo utilizar este libro

En general, este libro supone que se lee en secuencia, de principio a fin.
Los capítulos posteriores se basan en conceptos de los capítulos
anteriores, y es posible que los capítulos anteriores no profundicen en
los detalles de un tema en particular, sino que vuelvan a abordarlo en un
capítulo posterior.
En este libro encontrarás dos tipos de capítulos: capítulos conceptuales
y capítulos de proyectos. En los capítulos conceptuales, aprenderás
sobre un aspecto de Rust. En los capítulos de proyectos, crearemos
juntos pequeños programas, aplicando lo que has aprendido hasta
ahora. Los capítulos 2, 12 y 21 son capítulos de proyectos; el resto son
capítulos conceptuales.

El capítulo 1 explica cómo instalar Rust, cómo escribir un programa de

“¡Hola, mundo!” y cómo usar Cargo, el administrador de paquetes y la
herramienta de compilación de Rust. El capítulo 2 es una introducción
práctica a la escritura de un programa en Rust, en la que se crea un
juego de adivinanzas de números. Aquí cubrimos conceptos a un alto
nivel y los capítulos posteriores brindarán detalles adicionales. Si desea
ensuciarse las manos de inmediato, el capítulo 2 es el lugar para eso. El
capítulo 3 cubre las características de Rust que son similares a las de
otros lenguajes de programación y en el capítulo 4 aprenderá sobre el
sistema de propiedad de Rust. Si es un estudiante particularmente
meticuloso que prefiere aprender cada detalle antes de pasar al
siguiente, es posible que desee omitir el capítulo 2 e ir directamente al
capítulo 3, volviendo al capítulo 2 cuando desee trabajar en un proyecto
aplicando los detalles que ha aprendido.

El capítulo 5 analiza las estructuras y los métodos, y el capítulo 6 cubre

las enumeraciones, match las expresiones y la if letconstrucción del flujo
de control. Usarás estructuras y enumeraciones para crear tipos
personalizados en Rust.

En el Capítulo 7, aprenderá sobre el sistema de módulos de Rust y sobre

las reglas de privacidad para organizar su código y su Interfaz de
Programación de Aplicaciones (API) pública. El Capítulo 8 analiza algunas
estructuras de datos de recopilación comunes que proporciona la
biblioteca estándar, como vectores, cadenas y mapas hash. El Capítulo 9
explora la filosofía y las técnicas de manejo de errores de Rust.

El capítulo 10 profundiza en los genéricos, los rasgos y los tiempos de

vida, que le brindan el poder de definir código que se aplica a múltiples
tipos. El capítulo 11 trata sobre las pruebas, que incluso con las
garantías de seguridad de Rust son necesarias para garantizar que la
lógica de su programa sea correcta. En el capítulo 12, crearemos nuestra
propia implementación de un subconjunto de funcionalidades de
la grepherramienta de línea de comandos que busca texto dentro de los
archivos. Para esto, utilizaremos muchos de los conceptos que
discutimos en los capítulos anteriores.

El capítulo 13 explora los cierres y los iteradores: características de Rust

que provienen de los lenguajes de programación funcional. En el capítulo
14, examinaremos Cargo en mayor profundidad y hablaremos sobre las
mejores prácticas para compartir sus bibliotecas con otros. El capítulo 15
analiza los punteros inteligentes que proporciona la biblioteca estándar y
las características que habilitan su funcionalidad.

En el Capítulo 16, repasaremos diferentes modelos de programación

concurrente y hablaremos sobre cómo Rust te ayuda a programar en
múltiples subprocesos sin miedo. En el Capítulo 17, nos basaremos en
eso explorando la sintaxis async y await de Rust y el modelo de
concurrencia liviano que admiten.

El capítulo 18 analiza cómo los modismos de Rust se comparan con los

principios de programación orientada a objetos con los que quizás esté
familiarizado.

El capítulo 19 es una referencia sobre patrones y su comparación, que

son formas poderosas de expresar ideas en los programas de Rust. El
capítulo 20 contiene una gran variedad de temas avanzados de interés,
incluidos Rust no seguro, macros y más sobre duraciones de vida,
características, tipos, funciones y cierres.

En el Capítulo 21, completaremos un proyecto en el que

implementaremos un servidor web multiproceso de bajo nivel.

Finalmente, algunos apéndices contienen información útil sobre el

lenguaje en un formato más parecido a una referencia. El Apéndice A
cubre las palabras clave de Rust, el Apéndice B cubre los operadores y
símbolos de Rust, el Apéndice C cubre los rasgos derivables
proporcionados por la biblioteca estándar, el Apéndice D cubre algunas
herramientas de desarrollo útiles y el Apéndice E explica las ediciones de
Rust. En el Apéndice F, puede encontrar traducciones del libro y en el
Apéndice G cubriremos cómo se crea Rust y qué es Rust Nightly.

No hay una forma incorrecta de leer este libro: si quieres saltarte algo,
¡hazlo! Es posible que tengas que volver a los capítulos anteriores si
tienes alguna duda. Pero haz lo que te resulte más conveniente.

Una parte importante del proceso de aprendizaje de Rust es aprender a

leer los mensajes de error que muestra el compilador: estos te guiarán
hacia un código que funcione. Por ello, proporcionaremos muchos
ejemplos que no se compilan junto con el mensaje de error que mostrará
el compilador en cada situación. Ten en cuenta que si ingresas y
ejecutas un ejemplo aleatorio, ¡puede que no se compile! Asegúrate de
leer el texto circundante para ver si el ejemplo que estás intentando
ejecutar está destinado a generar un error. Ferris también te ayudará a
distinguir el código que no está destinado a funcionar:
 Ferris Significado

¡Este código no se compila!

¡Este código causa pánico!

Este código no produce el

comportamiento deseado.
En la mayoría de las situaciones, lo guiaremos a la versión correcta de
cualquier código que no se compile.

Código fuente
Los archivos fuente a partir de los cuales se genera este libro se pueden
encontrar en GitHub .

Empezando
¡Comencemos tu viaje con Rust! Hay mucho que aprender, pero todo
viaje comienza en algún lugar. En este capítulo, analizaremos lo
siguiente:
 Instalación de Rust en Linux, macOS y Windows
 Escribir un programa que imprimeHello, world!
 Uso cargodel administrador de paquetes y sistema de compilación
de Rust

Instalación
El primer paso es instalar Rust. Lo descargaremos a través de rustup,
una herramienta de línea de comandos para administrar las versiones de
Rust y las herramientas asociadas. Necesitarás una conexión a Internet
para la descarga.

Nota: Si prefiere no usarlo rustuppor algún motivo, consulte la página

Otros métodos de instalación de Rust para obtener más opciones.

Los siguientes pasos instalan la última versión estable del compilador de

Rust. Las garantías de estabilidad de Rust aseguran que todos los
ejemplos del libro que se compilan seguirán compilándose con versiones
más nuevas de Rust. El resultado puede variar levemente entre
versiones porque Rust suele mejorar los mensajes de error y las
advertencias. En otras palabras, cualquier versión más nueva y estable
de Rust que instales siguiendo estos pasos debería funcionar como se
espera con el contenido de este libro.

Notación de línea de comandos

En este capítulo y a lo largo del libro, mostraremos algunos comandos
utilizados en la terminal. Las líneas que debe ingresar en una terminal
comienzan con $. No necesita escribir el $carácter; es el indicador de
línea de comandos que se muestra para indicar el comienzo de cada
comando. Las líneas que no comienzan con $generalmente muestran el
resultado del comando anterior. Además, los ejemplos específicos de
PowerShell usarán >en lugar de $.

Instalación rustupen Linux o macOS

Si usa Linux o macOS, abra una terminal e ingrese el siguiente comando:

$ curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh

El comando descarga un script e inicia la instalación de

la rustup herramienta, que instala la última versión estable de Rust. Es
posible que se le solicite su contraseña. Si la instalación se realiza
correctamente, aparecerá la siguiente línea:

Rust is installed now. Great!

También necesitarás un enlazador , que es un programa que Rust usa

para unir sus salidas compiladas en un solo archivo. Es probable que ya
tengas uno. Si recibes errores de enlazador, debes instalar un
compilador de C, que normalmente incluirá un enlazador. El compilador
de AC también es útil porque algunos paquetes comunes de Rust
dependen del código C y necesitarán un compilador de C.
En macOS, puedes obtener un compilador de C ejecutando:

$ xcode-select –install

Los usuarios de Linux generalmente deben instalar GCC o Clang, según

la documentación de su distribución. Por ejemplo, si usa Ubuntu, puede
instalar el build-essentialpaquete.

Instalación rustupen Windows

En Windows, vaya a https://www.rust-lang.org/tools/install y siga las
instrucciones para instalar Rust. En algún momento de la instalación, se
le solicitará que instale Visual Studio. Esto proporciona un enlazador y
las bibliotecas nativas necesarias para compilar programas. Si necesita
más ayuda con este paso,
consulte https://rust-lang.github.io/rustup/installation/windows-
msvc.html

En el resto de este libro se utilizan comandos que funcionan tanto

en cmd.exe como en PowerShell. Si existen diferencias específicas,
explicaremos cuál se debe utilizar.
Solución de problemas
Para comprobar si tienes Rust instalado correctamente, abre un shell e
ingresa esta línea:

$ rustc –version

Debería ver el número de versión, el hash de confirmación y la fecha de

confirmación de la última versión estable que se ha publicado, en el
siguiente formato:
rustc x.y.z (abcabcabc yyyy-mm-dd)

Si ves esta información, ¡has instalado Rust correctamente! Si no ves

esta información, comprueba que Rust esté en %PATH%la variable de tu
sistema de la siguiente manera.
En Windows CMD, utilice:

> echo %PATH%

En PowerShell, utilice:
> echo $env:Path
En Linux y macOS, utilice:
$ echo $PATH

Si todo esto es correcto y Rust sigue sin funcionar, hay varios lugares
donde puedes obtener ayuda. Descubre cómo ponerte en contacto con
otros rustáceos (un apodo ridículo con el que nos llamamos) en la página
de la comunidad .

Actualización y desinstalación
Una vez que se instala Rust a través de rustup, es fácil actualizar a una
versión recién lanzada. Desde el shell, ejecute el siguiente script de
actualización:

$ rustup update

Para desinstalar Rust y rustup, ejecute el siguiente script de

desinstalación desde su shell:

$ rustup self uninstall

Documentación local
La instalación de Rust también incluye una copia local de la
documentación para que puedas leerla sin conexión. Ejecuta rustup
docpara abrir la documentación local en tu navegador.

Cada vez que la biblioteca estándar proporciona un tipo o una función y

no está seguro de qué hace o cómo usarlo, utilice la documentación de
la interfaz de programación de aplicaciones (API) para averiguarlo.
Editores de texto y entornos de desarrollo integrados
Este libro no hace suposiciones sobre qué herramientas se utilizan para
crear código en Rust. ¡Casi cualquier editor de texto servirá! Sin
embargo, muchos editores de texto y entornos de desarrollo integrados
(IDE) tienen soporte integrado para Rust. Siempre puedes encontrar una
lista bastante actualizada de muchos editores e IDE en la página de
herramientas del sitio web de Rust.

¡Hola Mundo!
Ahora que has instalado Rust, es hora de escribir tu primer programa en
Rust. Es tradicional, cuando se aprende un nuevo lenguaje, escribir un
pequeño programa que imprima el texto Hello, world!en la pantalla, así
que haremos lo mismo aquí.
Nota: Este libro presupone un conocimiento básico de la línea de
comandos. Rust no exige nada específico sobre la edición o las
herramientas o sobre dónde se encuentra el código, por lo que si
prefiere utilizar un entorno de desarrollo integrado (IDE) en lugar de la
línea de comandos, no dude en utilizar su IDE favorito. Muchos IDE
tienen ahora cierto grado de compatibilidad con Rust; consulte la
documentación del IDE para obtener más detalles. El equipo de Rust se
ha centrado en permitir una gran compatibilidad con IDE a través
de rust-analyzer. Consulte el Apéndice D para obtener más detalles.

Creación de un directorio de proyectos

Comenzarás creando un directorio para almacenar tu código de Rust. A
Rust no le importa dónde se encuentra tu código, pero para los ejercicios
y proyectos de este libro, te sugerimos crear un directorio de
proyectos en tu directorio de inicio y guardar todos tus proyectos allí.
Abra una terminal e ingrese los siguientes comandos para crear un
directorio de proyectos y un directorio para el proyecto “¡Hola, mundo!”
dentro del directorio de proyectos .

Para Linux, macOS y PowerShell en Windows, ingrese esto:

$ mkdir ~/projects
$ cd ~/projects
$ mkdir hello_world
$ cd hello_world
Para Windows CMD, ingrese esto:
> mkdir "%USERPROFILE%\projects"
> cd /d "%USERPROFILE%\projects"
> mkdir hello_world
> cd hello_world
Cómo escribir y ejecutar un programa en Rust
A continuación, crea un nuevo archivo fuente y llámalo main.rs . Los
archivos de Rust siempre terminan con la extensión .rs . Si usas más de
una palabra en el nombre del archivo, la convención es usar un guión
bajo para separarlas. Por ejemplo, usa hello_world.rs en lugar
de helloworld.rs .

Ahora abra el archivo main.rs que acaba de crear e ingrese el código del
Listado 1-1.
Nombre del archivo: main.rs

fn main() {
println!("Hello, world!");
}

Listado 1-1: Un programa que imprimeHello, world!

Guarde el archivo y vuelva a la ventana de su terminal en el
directorio ~/projects/hello_world . En Linux o macOS, ingrese los
siguientes comandos para compilar y ejecutar el archivo:

$ rustc main.rs
$ ./main
Hello, world!

En Windows, ingrese el comando .\main.exeen lugar de ./main:

> rustc main.rs
> .\main.exe
Hello, world!

Independientemente del sistema operativo que utilice, la cadena Hello,

world!debería imprimirse en la terminal. Si no ve este resultado,
consulte la sección “Solución de problemas” de la sección Instalación
para obtener ayuda.
Si Hello, world!lo has impreso, ¡felicitaciones! Has escrito oficialmente
un programa en Rust. Eso te convierte en un programador en Rust.
¡Bienvenido!

Anatomía de un programa Rust

Repasemos en detalle este programa “¡Hola, mundo!”. Aquí está la
primera pieza del rompecabezas:

fn main() {

Estas líneas definen una función denominada main. La mainfunción es

especial: siempre es el primer código que se ejecuta en cada programa
ejecutable de Rust. Aquí, la primera línea declara una función
denominada mainque no tiene parámetros y no devuelve nada. Si
hubiera parámetros, irían dentro de los paréntesis ().

El cuerpo de la función está envuelto en {}. Rust requiere llaves

alrededor de todos los cuerpos de las funciones. Es un buen estilo
colocar la llave de apertura en la misma línea que la declaración de la
función, agregando un espacio en el medio.

Nota: Si desea mantener un estilo estándar en todos los proyectos de

Rust, puede utilizar una herramienta de formateo automática
llamada rustfmtpara formatear su código en un estilo particular (más
información rustfmten el Apéndice D ). El equipo de Rust ha incluido esta
herramienta con la distribución estándar de Rust, tal como rustcestá, por
lo que ya debería estar instalada en su computadora.

El cuerpo de la mainfunción contiene el siguiente código:

println!("Hello, world!");

Esta línea hace todo el trabajo de este pequeño programa: imprime

texto en la pantalla. Hay cuatro detalles importantes que se deben tener
en cuenta aquí.

En primer lugar, println!llama a una macro de Rust. Si hubiera llamado a

una función, se habría ingresado como println(sin el !). Analizaremos las
macros de Rust con más detalle en el Capítulo 20. Por ahora, solo
necesita saber que usar a ! significa que está llamando a una macro en
lugar de a una función normal y que las macros no siempre siguen las
mismas reglas que las funciones.

En segundo lugar, se ve la "Hello, world!"cadena. Pasamos esta cadena

como argumento a println!y la cadena se imprime en la pantalla.

En tercer lugar, terminamos la línea con un punto y coma ( ;), lo que

indica que esta expresión ha terminado y que la siguiente está lista para
comenzar. La mayoría de las líneas de código de Rust terminan con un
punto y coma.

Compilar y ejecutar son pasos separados

Acaba de ejecutar un programa recién creado, así que examinemos cada
paso del proceso.

Antes de ejecutar un programa Rust, debes compilarlo usando el

compilador Rust ingresando el rustccomando y pasándole el nombre de
tu archivo fuente, de esta manera:
$ rustc main.rs

Si tienes conocimientos previos de C o C++, notarás que esto es similar

a gcc o clang. Después de compilar correctamente, Rust genera un
ejecutable binario.

En Linux, macOS y PowerShell en Windows, puedes ver el ejecutable

ingresando el lscomando en tu shell:

$ ls
main main.rs

En Linux y macOS, verás dos archivos. Con PowerShell en Windows,

verás los mismos tres archivos que verías con CMD. Con CMD en
Windows, ingresarías lo siguiente:

> dir /B %= the /B option says to only show the file names =%
main.exe
main.pdb
main.rs

Aquí se muestra el archivo de código fuente con la extensión .rs , el

archivo ejecutable ( main.exe en Windows, pero main en todas las
demás plataformas) y, si se utiliza Windows, un archivo que contiene
información de depuración con la extensión .pdb . Desde aquí, se
ejecuta el archivo main o main.exe , de la siguiente manera:

$ ./main # or .\main.exe on Windows

Si su archivo main.rs es su programa “¡Hola, mundo!”, esta línea se

imprime Hello, world!en su terminal.

Si estás más familiarizado con un lenguaje dinámico, como Ruby, Python

o JavaScript, es posible que no estés acostumbrado a compilar y ejecutar
un programa como pasos separados. Rust es un lenguaje compilado con
anticipación , lo que significa que puedes compilar un programa y darle
el ejecutable a otra persona, y esta puede ejecutarlo incluso sin tener
Rust instalado. Si le das a alguien un archivo .rb , .py o .js , necesita
tener instalada una implementación de Ruby, Python o JavaScript
(respectivamente). Pero en esos lenguajes, solo necesitas un comando
para compilar y ejecutar tu programa. Todo es una compensación en el
diseño del lenguaje.

Compilar con rustces suficiente para programas simples, pero a medida

que tu proyecto crezca, querrás administrar todas las opciones y facilitar
la compartición de tu código. A continuación, te presentaremos la
herramienta Cargo, que te ayudará a escribir programas reales en Rust.

¡Hola, Cargo!
Cargo es el sistema de compilación y el administrador de paquetes de
Rust. La mayoría de los habitantes de Rust utilizan esta herramienta
para administrar sus proyectos de Rust porque Cargo se encarga de
muchas tareas por usted, como compilar su código, descargar las
bibliotecas de las que depende su código y compilar esas bibliotecas. (A
las bibliotecas de las que su código necesita las
denominamos dependencias ).

Los programas Rust más simples, como el que hemos escrito hasta
ahora, no tienen dependencias. Si hubiéramos creado el proyecto "Hello,
world!" con Cargo, solo utilizaría la parte de Cargo que se encarga de
crear el código. A medida que escribas programas Rust más complejos,
irás añadiendo dependencias y, si empiezas un proyecto con Cargo,
añadir dependencias será mucho más fácil.

Como la gran mayoría de proyectos de Rust utilizan Cargo, el resto de

este libro asume que tú también lo estás utilizando. Cargo viene
instalado con Rust si usaste los instaladores oficiales que se comentaron
en la sección “Instalación” . Si instalaste Rust por otros medios, verifica
si Cargo está instalado ingresando lo siguiente en tu terminal:

$ cargo –version

Si ves un número de versión, ¡la tienes! Si ves un error, como command

not found, consulta la documentación de tu método de instalación para
determinar cómo instalar Cargo por separado.

Creando un proyecto con Cargo

Creemos un nuevo proyecto con Cargo y veamos en qué se diferencia de
nuestro proyecto original “¡Hola, mundo!”. Vuelve al directorio de
proyectos (o donde hayas decidido guardar el código). Luego, en
cualquier sistema operativo, ejecuta lo siguiente:

$ cargo new hello_cargo

$ cd hello_cargo

El primer comando crea un nuevo directorio y un proyecto

llamado hello_cargo . Hemos llamado a nuestro proyecto hello_cargo y
Cargo crea sus archivos en un directorio con el mismo nombre.
Vaya al directorio hello_cargo y enumere los archivos. Verá que Cargo
generó dos archivos y un directorio para nosotros: un
archivo Cargo.toml y un directorio src con un archivo main.rs dentro.

También se ha inicializado un nuevo repositorio Git junto con un

archivo .gitignore . Los archivos Git no se generarán si se ejecuta cargo
newdentro de un repositorio Git existente; puede anular este
comportamiento utilizando cargo new --vcs=git.

Nota: Git es un sistema de control de versiones común. Puedes

cambiar cargo newpara usar un sistema de control de versiones
diferente o ningún sistema de control de versiones usando la --
vcsbandera. Ejecutar cargo new --helppara ver las opciones disponibles.

Abra Cargo.toml en el editor de texto que prefiera. Debería verse similar

al código del Listado 1-2.
Nombre del archivo: Cargo.toml
[package]

name = "hello_cargo"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at

https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
Listado 1-2: Contenido de Cargo.toml generado porcargo new
Este archivo está en formato TOML ( Tom's Obvious, Minimal Language ),
que es el formato de configuración de Cargo.

La primera línea, [package], es un encabezado de sección que indica

que las siguientes instrucciones configuran un paquete. A medida que
agreguemos más información a este archivo, agregaremos otras
secciones.

Las siguientes tres líneas establecen la información de configuración que

Cargo necesita para compilar tu programa: el nombre, la versión y la
edición de Rust que se utilizará. Hablaremos de la editionclave
en el Apéndice E.

La última línea, [dependencies], es el comienzo de una sección para que

enumeres cualquiera de las dependencias de tu proyecto. En Rust, los
paquetes de código se conocen como crates . No necesitaremos ningún
otro crate para este proyecto, pero sí en el primer proyecto del Capítulo
2, por lo que utilizaremos esta sección de dependencias.
Ahora abre src/main.rs y echa un vistazo:
Nombre del archivo: src/main.rs

fn main() {
println!("Hello, world!");
}

Cargo ha generado un programa “¡Hola, mundo!” para usted, ¡tal como

el que escribimos en el Listado 1-1! Hasta ahora, las diferencias entre
nuestro proyecto y el proyecto que Cargo generó son que Cargo colocó
el código en el directorio src y tenemos un archivo de
configuración Cargo.toml en el directorio superior.

Cargo espera que los archivos de origen se encuentren dentro del

directorio src . El directorio de proyecto de nivel superior es solo para
archivos README, información de licencia, archivos de configuración y
cualquier otra cosa que no esté relacionada con el código. El uso de
Cargo le ayuda a organizar sus proyectos. Hay un lugar para todo y todo
está en su lugar.

Si iniciaste un proyecto que no utiliza Cargo, como hicimos con el

proyecto “¡Hola, mundo!”, puedes convertirlo en un proyecto que sí
utilice Cargo. Mueve el código del proyecto al directorio src y crea un
archivo Cargo.toml apropiado . Una forma sencilla de obtener ese
archivo Cargo.toml es ejecutar cargo init, que lo creará
automáticamente.

Construcción y gestión de un proyecto de carga

Ahora veamos qué es diferente cuando creamos y ejecutamos el
programa "Hola mundo" con Cargo. Desde el directorio hello_cargo , crea
tu proyecto ingresando el siguiente comando:

$ cargo build
Compiling hello_cargo v0.1.0 (file:///projects/hello_cargo)
Finished dev [unoptimized + debuginfo] target(s) in 2.85 secs

Este comando crea un archivo ejecutable

en target/debug/hello_cargo (o target\debug\hello_cargo.exe en
Windows) en lugar de en el directorio actual. Debido a que la
compilación predeterminada es una compilación de depuración, Cargo
coloca el binario en un directorio llamado debug . Puede ejecutar el
ejecutable con este comando:
$ ./target/debug/hello_cargo # or .\target\debug\hello_cargo.exe on
Windows
Hello, world!

Si todo va bien, Hello, world!debería imprimir en la terminal. cargo

buildLa primera vez que se ejecuta Cargo, también crea un nuevo
archivo en el nivel superior: Cargo.lock . Este archivo lleva un registro de
las versiones exactas de las dependencias en su proyecto. Este proyecto
no tiene dependencias, por lo que el archivo es un poco escaso. Nunca
necesitará cambiar este archivo manualmente; Cargo administra su
contenido por usted.

Acabamos de crear un proyecto con cargo buildy lo ejecutamos

con ./target/debug/hello_cargo, pero también podemos usar cargo
runpara compilar el código y luego ejecutar el ejecutable resultante,
todo en un solo comando:

$ cargo run
Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs
Running `target/debug/hello_cargo`
Hello, world!

Usarlo cargo runes más conveniente que tener que recordar

ejecutar cargo buildy luego usar la ruta completa al binario, por eso la
mayoría de los desarrolladores usan cargo run.

Tenga en cuenta que esta vez no vimos ningún resultado que indicara
que Cargo estaba compilando hello_cargo. Cargo se dio cuenta de que
los archivos no habían cambiado, por lo que no volvió a compilar, sino
que simplemente ejecutó el binario. Si hubiera modificado su código
fuente, Cargo habría reconstruido el proyecto antes de ejecutarlo y
habría visto este resultado:

$ cargo run
Compiling hello_cargo v0.1.0 (file:///projects/hello_cargo)
Finished dev [unoptimized + debuginfo] target(s) in 0.33 secs
Running `target/debug/hello_cargo`
Hello, world!

Cargo también proporciona un comando llamado cargo check. Este

comando verifica rápidamente el código para asegurarse de que se
compile, pero no produce un ejecutable:

$ cargo check
Checking hello_cargo v0.1.0 (file:///projects/hello_cargo)
Finished dev [unoptimized + debuginfo] target(s) in 0.32 secs
¿Por qué no querrías un ejecutable? A menudo, cargo checkes mucho
más rápido que cargo buildporque se salta el paso de producir un
ejecutable. Si estás comprobando continuamente tu trabajo mientras
escribes el código, el uso de cargo checkacelerará el proceso de avisarte
si tu proyecto todavía se está compilando. Por eso, muchos rustaceanos
ejecutan cargo checkperiódicamente mientras escriben su programa
para asegurarse de que se compila. Luego, lo ejecutan cargo
buildcuando están listos para usar el ejecutable.

Resumamos lo que hemos aprendido hasta ahora sobre Cargo:

 Podemos crear un proyecto usando cargo new.
 Podemos construir un proyecto usando cargo build.
 Podemos construir y ejecutar un proyecto en un solo paso
usando cargo run.
 Podemos construir un proyecto sin producir un binario para
verificar errores usando cargo check.
 En lugar de guardar el resultado de la compilación en el mismo
directorio que nuestro código, Cargo lo almacena en el
directorio target/debug .

Una ventaja adicional de usar Cargo es que los comandos son los
mismos sin importar en qué sistema operativo estés trabajando. Por lo
tanto, en este punto, ya no brindaremos instrucciones específicas para
Linux y macOS en comparación con Windows.

Construyendo para la liberación

Cuando tu proyecto finalmente esté listo para su lanzamiento, puedes
usar cargo build --releasepara compilarlo con optimizaciones. Este
comando creará un ejecutable en target/release en lugar
de target/debug . Las optimizaciones hacen que tu código Rust se
ejecute más rápido, pero al activarlas se alarga el tiempo que tarda tu
programa en compilarse. Es por eso que hay dos perfiles diferentes: uno
para desarrollo, cuando quieres reconstruir de manera rápida y
frecuente, y otro para construir el programa final que le darás a un
usuario que no se reconstruirá repetidamente y que se ejecutará lo más
rápido posible. Si estás evaluando el tiempo de ejecución de tu código,
asegúrate de ejecutar cargo build --releasey evaluar con el ejecutable
en target/release .

La carga como convención

En el caso de proyectos sencillos, Cargo no aporta mucho valor en
comparación con el uso de rustc, pero demostrará su valor a medida que
sus programas se vuelvan más complejos. Una vez que los programas
crecen hasta tener varios archivos o necesitan una dependencia, es
mucho más fácil dejar que Cargo coordine la compilación.
Aunque el hello_cargoproyecto es simple, ahora utiliza muchas de las
herramientas reales que usarás en el resto de tu carrera en Rust. De
hecho, para trabajar en cualquier proyecto existente, puedes usar los
siguientes comandos para extraer el código usando Git, cambiar al
directorio de ese proyecto y compilar:
$ git clone example.org/someproject
$ cd someproject
$ cargo build
Para obtener más información sobre Cargo, consulte su documentación .

Resumen
¡Ya has empezado con buen pie tu aventura en Rust! En este capítulo,
has aprendido a:
 Instale la última versión estable de Rust usandorustup
 Actualizar a una versión más nueva de Rust
 Abrir la documentación instalada localmente
 Escriba y ejecute un programa “¡Hola, mundo!”
usando rustcdirectamente
 Cree y ejecute un nuevo proyecto utilizando las convenciones de
Cargo

Este es un buen momento para crear un programa más sustancial que

nos permita acostumbrarnos a leer y escribir código Rust. Por eso, en el
Capítulo 2, crearemos un programa de juego de adivinanzas. Si prefieres
comenzar aprendiendo cómo funcionan los conceptos de programación
comunes en Rust, consulta el Capítulo 3 y luego vuelve al Capítulo 2.

Instalación Rust
Instalar Rust
Usando rustup (recomendado)
Parece que estás usando Windows. Para empezar a usar Rust, descarga
el instalador, ejecútalo y sigue las instrucciones que aparecen en
pantalla. Es posible que tengas que instalar las Visual Studio C++ Build
tools cuando se te pida. Si no estás usando Windows, ve a "Other
Installation Methods"

DESCARGA RUSTUP-INIT.EXE (32 BITS)

DESCARGA RUSTUP-INIT.EXE (64 BITS)

Subsistema de Windows para Linux

Si utilizas el Subsistema de Windows para Linux (WSL), ejecuta el

siguiente comando en tu terminal y sigue las instrucciones que aparecen
en pantalla para instalar Rust.

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Notas sobre la instalación de Rust
Comienza

Si estás empezando con Rust y te gustaría una guía más detallada, visita
nuestra pagina cómo empezar.
Gestión del conjunto de herramientas con rustup

Rust es instalado y gestionado por la herramienta rustup. Rust tiene

un proceso rápido de lanzamiento de 6 semanas y soporta un gran
número de plataformas, así que hay muchas compilaciones de Rust
disponibles en cualquier momento. rustup gestiona éstas compilaciones
de forma consistente en cada plataforma que soporta Rust, habilitando
la instalación de Rust de los canales de versiones beta y nightly, así
como soporte para destinos adicionales de compilación cruzada.

Si has instalado rustup en el pasado, puedes actualizar tu instalación

ejecutando rustup update.

Para más información visita la documentación de rustup.

Configurar la variable de entorno PATH

En el entorno de desarrollo de Rust, todas las herramientas son

instaladas en el directorio ~/.cargo/bin y aquí es donde encontrarás el
conjunto de herramientas de Rust, incluyendo rustc, cargo, and rustup.

Por consiguiente, es habitual para los desarrolladores de Rust incluir

este directorio en su variable de entorno PATH. Durante la
instalación rustup intentará configurar la variable PATH. Debido a las
diferencias entre plataformas, consolas de comandos y errores
en rustup, las modificaciones de la variable PATH podrían no tener
efecto hasta que la consola sea reiniciada o el usuario cierre su sesión, o
incluso no funcionar después de todo.

Si después de la instalación, la ejecución derustc --version en la consola

falla, esta es la razón más probable.

Desinstalar Rust

Si en algún momento quieres desinstalar Rust, puedes ejecutar rustup

self uninstall. ¡Eso sí, te echaremos de menos!

Rust es un lenguaje de programación compilado, multiparadigma y

estático. Se considera una versión moderna de C y C++, y se utiliza para
desarrollar sistemas operativos.
Características

 Es fuertemente tipado, lo que significa que los tipos de todas las

variables deben conocerse en tiempo de compilación.
 Utiliza una sintaxis similar a la de C++.
 Cuenta con principios de seguridad para garantizar que los
programadores escriban código estable y extensible.
 Soporta programación funcional pura, por procedimientos,
imperativa y orientada a objetos.
 Garantiza el acceso seguro a la memoria y previene
comportamientos indefinidos.
Usos

 Se ha utilizado en el desarrollo de sistemas operativos.

 Es un lenguaje de propósito general.
Para aprender Rust

 Puedes probar los ejemplos de código del archivo rust-tutorial.rs.

 También puedes usar Rust Playground directamente en tu
navegador.
 Puedes ver videos en YouTube sobre cómo aprender a usar Rust.
Fuentes TechTarget, OpenWebinars, Wikipedia, CodiLime, Código
Facilito.

+++++++++++++++++++++++++++++++++++
Rust (lenguaje de programación)
47 idiomas
 Artículo
 Discusión
 Leer
 Editar
 Ver historial
Herramientas

Rust
Desarrollador(es)
Rust Project
https://www.rust-lang.org/
Información general
Exte .rs .rlib
nsio
nes
com
unes
Para multiparadigma, imperativo, orientad
digm o a
a objetos, procedural, concurrente, fun
cional, compilado, propósito general
Apar 2010
eció
en
Dise Graydon Hoare
ñado
 por
Últi 1.84.0[1] (09 de enero de 2025 (3
ma meses y 6 días))
versi
ón
esta
ble
Siste estático, fuerte, inferido, estructural
ma
de
tipos
Influi Alef, C#, C++, Camlp4, Common
do Lisp, Cyclone, Erlang, Haskell, Herme
por s, Limbo, Napier, Napier88, Newsque
ak, NIL, Ruby, Sather, Standard
ML, Ocaml, Racket, Swift
Ha C#, Elm, Idris, Swift
influi
do a
Siste Linux, macOS, Windows, FreeBSD, O
ma penBSD,[2] Redox, Android, iOS[3]
oper
ativo
Lice Licencia Apache 2.0 o Licencia MIT[4]
ncia
[editar datos en Wikidata]
Rust es un lenguaje de programación compilado, de propósito
general y multiparadigma (aunque no soporta las características de los
mismos en su totalidad) que está siendo desarrollado por Fundación
Rust. Es un lenguaje de programación multiparadigmático que soporta
programación funcional pura, por
procedimientos, imperativa y orientada a objetos.

Según la política de Mozilla,[5] Rust es desarrollado de forma totalmente

abierta y busca la opinión y contribución de la comunidad. El diseño del
lenguaje se ha ido perfeccionando a través de las experiencias en el
desarrollo del motor de navegador Servo,[6] y el propio compilador de
Rust. Aunque es desarrollado y patrocinado por Mozilla y Samsung, es
un proyecto comunitario. Una gran parte de las contribuciones proceden
de los miembros de la comunidad.[7]

Para el 2020 es uno de los lenguajes de programación más usados a la

hora de trabajar con criptomonedas y crear nodos para minar
criptoactivos.[8] En 2022, Rust se convirtió en el tercer lenguaje de
programación usado en el núcleo Linux, después de C y ensamblador.[9]

Descripción
[editar]
El objetivo de Rust es ser un buen lenguaje para la creación de grandes
programas del lado del cliente y del servidor que se ejecuten en
Internet. Esto ha llevado a un conjunto de características con un énfasis
en la seguridad, el control de distribución de la memoria y la
concurrencia. Se espera que el rendimiento de código seguro sea más
lento que C++, si el rendimiento es la única consideración, pero si lo
comparamos con el código C++ hecho para que tome precauciones
comparables a las que toma Rust, este último puede ser incluso más
rápido.[10]

La sintaxis de Rust es similar a la de C y C++, con bloques de código

delimitados por llaves y estructuras de control de flujo tales
como if , else , do , while y for . No todas las estructuras de C y C++
están presentes, además, otras (como la palabra clave match para
ramificación multidireccional) serán menos familiares para
programadores que vienen de estos lenguajes.

El sistema está diseñado para tener un acceso seguro a la memoria, y

no permite punteros nulos o punteros colgantes.[11][12] Los valores de los
datos sólo se pueden inicializar a través de un conjunto fijo de formas,
las cuales requieren que sus entradas hayan sido ya inicializadas. [13]

El sistema de tipos soporta un mecanismo similar a las interfaces de

tipos, llamado "traits", inspirados directamente por el lenguaje Haskell.
Esta es una facilidad para el polimorfismo que soporta distintos tipos de
argumentos (polimorfismo ad-hoc), lograda mediante la adición de
restricciones para escribir declaraciones de variables. Otras
características de Haskell, como el polimorfismo de diferente tipo
(higher-kinded), no están soportadas.

Rust cuenta con inferencia de tipos, para las variables declaradas con la
palabra clave let. Tales variables no requieren ser inicializadas con un
valor asignado con el fin de determinar su tipo. A tiempo de compilación
produce un error si cualquier rama de código falla al asignar un valor a
la variable.[14] Las funciones pueden recibir parámetros genéricos pero
deben ser delimitados expresamente por los traits, no hay manera de
dejar fuera de declaraciones de tipo sin dejar de hacer uso de los
métodos y operadores de los parámetros.

La concurrencia es soportada a través de tareas simples, similares a los

encontrados en Erlang y otros lenguajes basado en actores. En dichos
sistemas, las tareas se comunican a través del paso de mensajes, en
lugar de compartir los datos directamente. Por motivos de rendimiento,
es posible enviar datos sin copiar, usar cajas únicas. Las cajas únicas
son la garantía de tener un solo propietario, y puede ser liberada por la
tarea de enviar para su uso por el receptor.

El sistema de objetos de Rust se basa en implementaciones, traits y

tipos estructurados. Las implementaciones cumplen una función similar
a la de las clases en otros lenguajes, y se definen con la palabra clave
impl. Herencia y polimorfismo son proporcionados por los traits,
permiten que los métodos se definan y se mezclen en las
implementaciones. Los tipos estructurados se utilizan para definir los
campos. Implementaciones y rasgos no pueden definir los campos
propios, y sólo los traits proporcionar herencia, con el fin de evitar
el problema del diamante de C++.

Historia
[editar]

Los usuarios de Rust se refieren a sí mismos

como rustáceos y usan a Ferris como su mascota
El lenguaje surgió a partir de un proyecto personal iniciado en 2006 por
el empleado de Mozilla, Graydon Hoare,[15] quien afirmó que el proyecto
posiblemente recibió su nombre de la familia de hongos de la roya. [16]
Mozilla comenzó a patrocinar el proyecto en 2009[15] y lo anunció en
2010.[17][18] El mismo año, el trabajo pasó del compilador inicial (escrito
en OCaml) al compilador autohospedado escrito en Rust.[19] Denominado
rustc, se compiló con éxito en 2011.[20] rustc usa LLVM como su back
end.

La primera versión pre-alfa numerada del compilador de Rust se produjo

en enero de 2012.[21] Rust 1.0, la primera versión estable, se publicó el
15 de mayo de 2015.[22][23] Después de 1.0, las versiones estables se
publican cada seis semanas, mientras que las nuevas funcionalidades se
desarrollan en las versiones diarias (en inglés, nightly) y luego se
prueban con versiones alfa y beta que duran seis semanas. [24]

Junto con la escritura estática convencional, antes de la versión 0.4, Rust

también admitía typestates. El sistema typestate modeló aserciones
antes y después de las sentencias del programa, mediante el uso de una
checksentencia especial. Las discrepancias se pueden descubrir en el
momento de la compilación, en lugar de cuando se ejecuta un
programa, como podría ser el caso de las aserciones en código C o C +
+. El concepto typestate no era exclusivo de Rust, ya que se introdujo
por primera vez en el lenguaje NIL.[25] Los typestates se eliminaron
porque en la práctica se usaban poco, aunque la misma función aún se
puede lograr con un patrón de marca.[26]

El estilo del sistema de objetos cambió considerablemente en las

versiones 0.2, 0.3 y 0.4 de Rust. La versión 0.2 introdujo clases por
primera vez, y la versión 0.3 agregó varias características, incluidos
destructores y polimorfismo mediante el uso de interfaces. En Rust 0.4,
se agregaron rasgos como un medio para proporcionar herencia; las
interfaces se unificaron con rasgos y se eliminaron como una
característica separada. Las clases también se eliminaron, reemplazadas
por una combinación de implementaciones y tipos estructurados.

Comenzando en Rust 0.9 y terminando en Rust 0.11, Rust tenía dos

tipos de punteros incorporados: ~y @, simplificando el modelo de
memoria central. Reimplementó esos tipos de puntero en la biblioteca
estándar como Boxy (ahora eliminado) Gc.

En enero de 2014, antes de la primera versión estable, Rust 1.0, el

editor en jefe de Dr. Dobb's, Andrew Binstock, comentó sobre las
posibilidades de Rust de convertirse en un competidor de C ++ y de los
otros lenguajes próximos D, Go y Nim (entonces Nimrod). Según
Binstock, mientras que Rust era "ampliamente visto como un lenguaje
notablemente elegante", la adopción se ralentizó porque cambió
repetidamente entre versiones.[27]

Rust fue el tercer lenguaje de programación más querido en la encuesta

anual de Stack Overflow de 2015[28] y ocupó el primer lugar en 2016-
2020.[29][30][31][32][33]

El lenguaje se menciona en El libro de Mozilla como "metal oxidado". [34]

Creación de Fundación Rust

[editar]
En agosto de 2020, Mozilla despidió a 250 de sus 1000 empleados en
todo el mundo como parte de una reestructuración corporativa
provocada por el impacto a largo plazo de la pandemia de COVID-19. El
equipo detrás de Servo, un motor de navegador escrito en Rust, se
disolvió por completo. El evento generó preocupaciones sobre el futuro
de Rust, ya que algunos miembros del equipo eran colaboradores
activos de Rust.

A la semana siguiente, el equipo central de Rust reconoció el grave

impacto de los despidos y anunció que los planes para una fundación de
Rust estaban en marcha. El primer objetivo de la fundación sería tomar
posesión de todas las marcas comerciales y nombres de dominio, y
asumir la responsabilidad financiera por sus costos. [35]

El 8 de febrero de 2021, sus cinco empresas fundadoras

(AWS, Huawei, Google, Microsoft y Mozilla) anunciaron la formación de la
Fundación Rust.[36][37]

El 6 de abril de 2021, Google anunció la compatibilidad con Rust dentro

del Proyecto de código abierto de Android como alternativa a C/C++.[38]

Ejemplos
[editar]
El siguiente código es válido para Rust 1.70.0. En versiones posteriores
puede cambiar la sintaxis o las funciones.

Programa que muestra la frase “¡Hola, mundo!”:

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

Dos versiones de la función factorial, en el estilo recursivo e iterativo:

/* Las ramas en esta función exhiben los valores de retorno implícito

opcional
de Rust, que pueden ser usados cuando se prefiera un estilo más
“funcional”.
A diferencia de C++ y otros lenguajes similares, la estructura de
control
`if` es una expresión en vez de una declaración, por tanto, tiene un
valor
de retorno propio. */

fn recursive_factorial(n: i32) -> i32 {

 if n == 0 {
1
} else {
n * recursive_factorial(n-1)
}
}

fn iterative_factorial(n: i32) -> i32 {

// Las variables son declaradas con `let`.
// La palabra `mut` permite que las variables puedan ser mutadas.
let mut i = 1;
let mut result = 1;
while i <= n {
result *= i;
i += 1;
}
return result; // Un retorno explícito, en contraste con la función
previa.
}

fn main() {
println!("Resultado recursivo: {}", recursive_factorial(10));
println!("Resultado iterativo: {}", iterative_factorial(10));
}

Una simple demostración de las capacidades de concurrencia ligera de

Rust:

/* Esta función crea diez “tareas” que se pueden ejecutar

concurrentemente.
Ejecútalo múltiples veces y observa la salida irregular que se obtiene
al
estar cada tarea llamando al stdout, ya que cada tarea puede
producirse entre
las sucesivas llamadas a `println` y dentro de la función `println` en
sí. */

use std::thread;

fn main() {
// Esta cadena es inmutable, para que pueda ser accedida de forma
segura
// por múltiples tareas.
 let message = "¡Miradme, soy un proceso ligero!";
// Los bucles `for` funcionan con cualquier tipo que implemente el
trait
// `Iterator`.

for num in 0..10 {

// Es muy probable que no muestre los 10 mensajes porque si la
“tarea”
// principal termina antes, las “tareas” producidas ya no se
ejecutan.
thread::spawn (move || {
println!("{}", message);
// `println!` es una macro que verifica estáticamente un string de
// formato. Las macros son estructurales (como en Scheme) en
lugar
// de ser textuales (como en C).
println!("Este mensaje ha sido ofrecido por la tarea {}.", num);
});
}
}

Evolución del lenguaje

[editar]
Además de los tipos estáticos convencionales, Rust también
incluyó typestates hasta su versión 0.4. El sistema typestate modela
afirmaciones antes y después de las declaraciones del programa,
mediante el uso de una declaración de verificación especial. Las
discrepancias pueden ser descubiertas durante la compilación, en lugar
de una vez que el programa se ejecuta, como podría ser el caso de
las aserciones en el código C o C++. El concepto typestate no es
exclusivo de Rust, ya que se introdujo por primera vez en el lenguaje de
programación NIL.[25] Fueron retirados los typestates porque en la
práctica se encontraron poco usados, sin embargo la misma
funcionalidad aún se puede lograr con los patrones del mismo lenguaje.
[39]

El estilo del sistema de objetos ha cambiado considerablemente en las

versiones 0.2, 0.3 y 0.4 de Rust. La versión 0.2 introdujo clases por
primera vez, con la versión 0.3 añadiendo un número de características
que incluyen destructores y polimorfismo mediante el uso de interfaces.
En Rust 0.4, se añadieron traits como un medio para proporcionar
herencia, las interfaces se unificaron con los traits y eliminándose como
una característica independiente. También se eliminaron las clases,
reemplazadas por una combinación de las implementaciones y tipos
estructurados.

Interfaces gráficas (GUI)

[editar]
Rust permite la creación de interfaces gráficas mediante las APIs nativas
de la plataforma anfitriona, esto gracias a que tiene características de
un lenguaje de bajo nivel. Sin embargo, esta ruta de desarrollo puede
llegar a generar dificultades en proyectos que planten la admision de
múltiples plataformas.[40]

Actualmente existen múltiples desarrollos para crear GUIs en Rust,

algunos permiten la creación de la interfaz junto a Electron o haciendo
uso de HTML, algunos otros, suministran bibliotecas nativas para el
lenguaje, pero todavía se encuentran en un estado inmaduro de
desarrollo. Finalmente están los proyectos que enlazan bibliotecas
bastante conocidas y con una mayor madurez en su desarrollo,
como GTK o Qt, lo cuales permiten desarrollos multiplataforma.[41]
Algunos proyectos populares son los siguientes:

gtk-rs
[editar]

Ejemplo de interfaz con GTK

Es una implementación de las bibliotecas de GTK para el uso junto al
lenguaje Rust. Para ello, crea funciones de Rust superpuestas a las
funciones de las bibliotecas de GTK en C, haciendo uso de Foreign
Function Interface que ofrece Rust.

conrod
[editar]
Biblioteca de bajo nivel que hace uso de OpenGL o Vulkan.

Proyectos
[editar]
Navegador web
[editar]
Se están escribiendo en Rust un navegador web y varios componentes
relacionados, que incluyen:

 Firefox
 Servo: motor de navegador web paralelo de Mozilla
desarrollado en colaboración con Samsung
 Quantum: un proyecto, compuesto por varios
subproyectos, para mejorar el motor del navegador
web Gecko de Firefox, desarrollado por Mozilla
 Oxidation: un proyecto para integrar código escrito en
el lenguaje de programación Rust en Gecko y Firefox,
impulsado por Mozilla
 Brave
Brave Shields (adblock-rust): Un bloqueador de

anuncios nativo del navegador web Brave, que integra
la sintaxis de uBlock Origin y que ofrece un gran
rendimiento en comparación con su anterior
implementación basada en JavaScript, según sus
desarrolladores
Sistemas operativos
[editar]
Muchos sistemas operativos (SO) y componentes relacionados se están
escribiendo en Rust. A partir de enero de 2019, los sistemas operativos
incluían: BlogOS, intermezzOS, QuiltOS, Redox, RustOS, Rux, Tefflin y
Tock.

 Redox: Un micronucleo
 Stratis: Un sistema de archivos para Fedora y RHEL 8.
Otro
[editar]

 exa - un reemplazo moderno para ls.

 Microsoft Azure IoT Edge: una plataforma utilizada para
ejecutar servicios de Azure e inteligencia artificial en
dispositivos de IoT tiene componentes implementados en Rust
 OpenDNS : utilizado en dos de sus componentes
 Tor : una red de anonimato , escrita originalmente en C, está
experimentando con la migración a Rust con Arti por sus
características de seguridad[42]
 TiKV: una base de datos distribuida de valor clave desarrollada
por primera vez por PingCAP , ahora un proyecto miembro de
Cloud Native Computing Foundation
 Xi: un editor de texto de Raph Levien, utilizado dentro del
sistema operativo Fuchsia.
  Deno : un tiempo de ejecución seguro para JavaScript y
TypeScript creado con V8 , Rust y Tokio
 Linkerd 2.x: una herramienta de "malla de servicios" para la
supervisión de microservicios está escrita en gran parte en
Rust.
 TerminusDB - diseño y disposición de la estructura de datos
 Discord : servicio de chat dirigido a jugadores que usa Rust
para partes de su backend, así como codificación de video del
lado del cliente.[43]
 rav1e: un codificador de formato de video AV1 experimental.
 Zed: un editor de código escrito desde cero en Rust por los
creadores de Atom.
 Thunderbird: El código responsable de ofrecer soporte para
Exchange está escrito en Rust.[44]
 Zola: Un motor para servir sitios web estáticos, como Hugo. A
diferencia de Hugo, Zola está escrito en Rust. [45]
Véase también
[editar]

 Servo
Referencias
[editar]

1. ↑ https://blog.rust-lang.org
2. ↑ «OpenBSD ports». Consultado el 3 de abril de 2018.
3. ↑ «Building and Deploying a Rust library on iOS». 6 de
septiembre de 2017. Consultado el 11 de enero de 2019.
4. ↑ «COPYRIGHT». Rust compiler source repository. Consultado
el 17 de diciembre de 2012.
5. ↑ «The Mozilla Manifesto». Consultado el 9 de abril de 2012.
6. ↑ Peter Bright (3 de abril de 2013). «Samsung teams up with
Mozilla to build browser engine for multicore machines».
Consultado el 4 de abril de 2013.
7. ↑ «Rust Contributors».
8. ↑ «Lenguajes de programacion para Bitcoins: Hablan los
desarrolladores.».
9. ↑ Medina, Eduardo (9 de diciembre de 2021). «Rust avanza
para convertirse en el segundo lenguaje del kernel Linux -
MuyLinux». www.muylinux.com. Consultado el 13 de febrero
de 2023.
10. ↑ Walton, Patrick (5 de diciembre de 2010). «C++
Design Goals in the Context of Rust». Consultado el 21 de
enero de 2011. «… It’s impossible to be “as fast as C” in all
cases while remaining safe… C++ allows all sorts of low-
 level tricks, mostly involving circumventing the type system,
that offer practically unlimited avenues for optimization. In
practice, though, C++ programmers restrict themselves to a
few tools for the vast majority of the code they write,
including stack-allocated variables owned by one function
and passed by alias, uniquely owned objects (often used
with auto_ptr or the C++0x unique_ptr ), and reference
counting via shared_ptr or COM. One of the goals of Rust’s
type system is to support these patterns exactly as C++
does, but to enforce their safe usage. In this way, the goal is
to be competitive with the vast majority of idiomatic C++ in
performance, while remaining memory-safe…».
11. ↑ Rosenblatt, Seth (3 de abril de 2013). «Samsung joins
Mozilla's quest for Rust». Archivado desde el original el 4 de
abril de 2013. Consultado el 5 de abril de 2013. «[Brendan
Eich] noted that every year browsers fall victim to hacking in
the annual Pwn2Own contest at the CanSecWest
conference. "There's no free memory reads" in Rust, he
said, but there are in C++. Those problems "lead to a lot of
browser vulnerabilities" and would be solved by Rust, which
is a self-compiling language.»
12. ↑ Brown, Neil (17 de abril de 2013). «A taste of Rust».
Consultado el 25 de abril de 2013. «… Other more complex
data structures could clearly be implemented to allow
greater levels of sharing, while making sure the interface is
composed only of owned and managed references, and thus
is safe from unplanned concurrent access and from dangling
pointer errors.»
13. ↑ «Doc language FAQ». 14 de septiembre de 2010.
Consultado el 11 de enero de 2012.
14. ↑ Walton, Patrick (1 de octubre de 2010). «Rust
Features I: Type Inference». Consultado el 21 de enero de
2011.
15. ↑ Saltar a:a b Rust Team (9 de junio de 2016). «The
Rust Project». rust-lang (en inglés). Archivado desde el
original el 9 de junio de 2016. Consultado el 27 de junio de
2019.
16. ↑ kibwen (7 de junio de 2014). «Internet archaeology:
the definitive, end-all source for why Rust is named
"Rust"». reddit (en inglés). Consultado el 17 de septiembre
de 2019.
17. ↑ Brendan Eich (29 de abril de 2011). «Future
Tense». slideshare (en inglés). Consultado el 18 de
septiembre de 2020.
18. ↑ Mozilla Team (29 de abril de 2011). «Project
Servo» (PDF). venge (en inglés). Consultado el 7 de julio de
2010.
19. ↑ Graydon (2 de octubre de 2010). «Rust
progress». Graydon's work on Mozilla (en inglés). Archivado
desde el original el 15 de agosto de 2014. Consultado el 30
de octubre de 2010.
20. ↑ Hoare, Graydon (20 de abril de 2011), «rust-dev
stage1 rustc builds» (en en), lista de correo rust-dev,
archivado del original el 20 de julio de 2011, consultado el
18 de septiembre de 2020.
21. ↑ catamorphism (20 de enero de 2012). «Mozilla and
the Rust community release Rust 0.1 (a strongly-typed
systems programming language with a focus on memory
safety and concurrency)». reddit (en inglés). Consultado el
18 de septiembre de 2020.
22. ↑ Rust Team (20 de enero de
2012). «rust/RELEASES.md». github (en inglés). Consultado
el 18 de septiembre de 2020.
23. ↑ Rust Team (15 de mayo de 2015). «Announcing Rust
1.0». Rust Blog (en inglés). Consultado el 18 de septiembre
de 2020.
24. ↑ Rust Team (12 de diciembre de 2014). «Rust 1.0:
Scheduling the trains». Rust Blog (en inglés). Consultado el
18 de septiembre de 2020.
25. ↑ Saltar a:a b Strom, Robert E.; Yemini, Shaula
(1986). Typestate: A Programming Language Concept for
Enhancing Software Reliability. IEEE Transactions on
Software Engineering. ISSN 0098-5589. Consultado el 14 de
noviembre de 2010.
26. ↑ pcwalton (26 de diciembre de 2012). «Typestate Is
Dead, Long Live Typestate!». pcwalton (en inglés).
Archivado desde el original el 23 de febrero de 2018.
Consultado el 18 de septiembre de 2020.
27. ↑ Binstock, Andrew (7 de enero de 2014). «The Rise
And Fall of Languages in 2013». Dr.Dobb's (en inglés).
Consultado el 18 de septiembre de 2020.
28. ↑ stackoverflow Team (2015). «2015 Developer
Survey». stackoverflow (en inglés). Consultado el 18 de
septiembre de 2020.
29. ↑ stackoverflow Team (2016). «Most Loved, Dreaded,
and Wanted». stackoverflow (en inglés). Consultado el 18 de
septiembre de 2020.
30. ↑ stackoverflow Team (2017). «Most Loved, Dreaded,
and Wanted». stackoverflow (en inglés). Consultado el 18 de
septiembre de 2020.
31. ↑ stackoverflow Team (2018). «Developer Survey
Results 2018». stackoverflow (en inglés). Consultado el 18
de septiembre de 2020.
32. ↑ stackoverflow Team (2019). «Most Loved, Dreaded,
and Wanted». stackoverflow (en inglés). Consultado el 18 de
septiembre de 2020.
33. ↑ stackoverflow Team (27 de mayo de 2020). «The
2020 Developer Survey results are here!». stackoverflow (en
inglés). Consultado el 18 de septiembre de 2020.
34. ↑ Mozilla Team (2020). «The Book of
Mozilla». mozilla (en inglés). Consultado el 18 de septiembre
de 2020. «The Beast adopted new raiment and studied the
ways of Time and Space and Light and the Flow of energy
through the Universe. From its studies, the Beast fashioned
new structures from oxidised metal and proclaimed their
glories. And the Beast’s followers rejoiced, finding renewed
purpose in these teachings.»
35. ↑ «Laying the foundation for Rust's future». Rust Blog.
18 de agosto de 2020. Archivado desde el original el 2 de
diciembre de 2020. Consultado el 2 de diciembre de 2020.
36. ↑ «Hello World!». Rust Foundation (en inglés). 8 de
febrero de 2020. Archivado desde el original el 19 de abril
de 2022. Consultado el 4 de junio de 2022.
37. ↑ «Mozilla Welcomes the Rust Foundation». Mozilla
Blog (en inglés estadounidense). 9 de febrero de 2021.
Archivado desde el original el 8 de febrero de 2021.
Consultado el 9 de febrero de 2021.
38. ↑ Amadeo, Ron (7 de abril de 2021). «Google is now
writing low-level Android code in Rust». Ars Technica (en
inglés estadounidense). Archivado desde el original el 8 de
abril de 2021. Consultado el 8 de abril de 2021.
39. ↑ «Typestate Is Dead, Long Live Typestate!». 26 de
diciembre de 2012. Archivado desde el original el 31 de
diciembre de 2012. Consultado el 28 de diciembre de 2012.
40. ↑ areweguiyet (2020). «Are we GUI
Yet?». areweguiyet (en inglés). Consultado el 19 de
septiembre de 2020.
41. ↑ Amann, Marco (7 de febrero de 2020). «GUI
programming with Rust». medium (en inglés). Consultado el
19 de septiembre de 2020.
 42. ↑ «Announcing Arti, a pure-Rust Tor implementation»
[Anunciando Arti, una implementación de Tor escrita en
Rust].
43. ↑ «Why Discord is switching from Go to Rust» [Por qué
Discord está cambiando de Go a Rust].
44. ↑ «Adventures In Rust: Bringing Exchange Support To
Thunderbird» [Aventuras en Rust: Aportando compatibilidad
con Exchange a Thunderbird].
45. ↑ «A fast static site generator in a single binary with
everything built-in.» [Un generador de sitios web estáticos
rápido en un solo binario con todo lo incorporado.].
Enlaces externos
[editar]

 Sitio web oficial

 Documentación oficial
 Repositorio en GitHub
 Rust en X (antes Twitter).
Control de  Proyectos Wikimedia
autoridades
 Datos: Q575650
 Multimedia: Rust (programming language) / Q575650

 Identificadores
 BNE: XX6456854
 BNF: 17808721b (data)
 GND: 1078438080
 LCCN: sh2018000672
 NLI: 987012402011505171
 Informática
 Arch Linux: rust
 AUR: rust-nightly
 Fedora: rust
 Free Software Directory: Rust
  Gentoo: dev-lang/rust
Categorías:
 Lenguajes de programación orientada a objetos
 Lenguajes de programación multiparadigma
 Lenguajes de programación imperativa
 Lenguajes funcionales
 Lenguajes de programación por procedimientos
 Mozilla
 Software que utiliza la licencia Apache
 Software de 2010
 Lenguajes de programación de sistemas
 Esta página se editó por última vez el 7 abr 2025 a las 14:27.