El equipo de desarrollo de Rust se complace en anunciar el lanzamiento de una nueva versión de Rust, 1.32.0. Rust es un lenguaje de programación que permite a todos crear software confiable y eficiente.
Si tiene una versión anterior de Rust instalada con rustup , entonces para actualizar Rust a la versión 1.32.0 solo necesita hacer:
$ rustup update stable
Si aún no ha instalado rustup , puede instalarlo desde la página correspondiente de nuestro sitio web. Las notas de lanzamiento detalladas para Rust 1.32.0 están disponibles en GitHub.
Una nota rustup : ¡ rustup se han rustup varios nuevos lanzamientos de rustup ! Para actualizar rustup , realice rustup self update .
Lo que se incluye en la versión estable 1.32.0
Rust 1.32.0 adquirió varias mejoras para mejorar la vida, cambió el asignador de memoria predeterminado e hizo más constantes las funciones. Lea sobre estos cambios a continuación o vea más en las notas de la versión .
Dbg macro
Comencemos con una mejora que mejore la vida. ¿Utiliza la depuración de impresión? Si es así, y desea imprimir algún valor mientras trabaja en el código, se ve obligado a hacer esto:
let x = 5; println!("{:?}", x);
Este no es el mayor obstáculo que ralentiza el desarrollo, pero requiere demasiado esfuerzo simplemente depurar la salida del valor x . Además, el contexto no se tiene en cuenta aquí. Si tienes varios de esos println! s, se hace difícil determinar a qué se refiere la salida, hasta que usted mismo agrega información de contexto a cada llamada, lo que requiere aún más trabajo.
Para estos propósitos, en Rust 1.32.0 agregamos una nueva macro dbg! :
fn main() { let x = 5; dbg!(x); }
Después de comenzar este programa, verá:
[src/main.rs:4] x = 5
¡Junto con el nombre de la variable y su valor, se mostrarán el nombre del archivo y el número de línea donde se realizó la llamada dbg! .
Además, println! imprime en salida estándar, por lo que es mejor usar eprintln! para imprimir en flujo de error estándar. Macro dbg! salidas a stderr , y con razón.
Esto funciona incluso en casos difíciles. Considere un ejemplo de implementación factorial:
fn factorial(n: u32) -> u32 { if n <= 1 { n } else { n * factorial(n - 1) } }
Para depurarlo, podemos usar eprintln! :
fn factorial(n: u32) -> u32 { eprintln!("n: {}", n); if n <= 1 { eprintln!("n <= 1"); n } else { let n = n * factorial(n - 1); eprintln!("n: {}", n); n } }
Queremos generar n en cada iteración y ver el contexto de cada una de las ramas. Para factorial(4) generará:
n: 4 n: 3 n: 2 n: 1 n <= 1 n: 2 n: 6 n: 24
Esto es aceptable, pero no particularmente bueno. Quizás podríamos trabajar para mejorar el resultado de la información de contexto para aclarar la conclusión. Pero luego, en lugar de depurar nuestro código, mejoraremos el código de depuración.
¡Considere el mismo ejemplo usando dbg! :
fn factorial(n: u32) -> u32 { if dbg!(n <= 1) { dbg!(1) } else { dbg!(n * factorial(n - 1)) } }
Simplemente envolvimos una macro con cada una de las expresiones que queremos generar. Como resultado, obtenemos:
[src/main.rs:3] n <= 1 = false [src/main.rs:3] n <= 1 = false [src/main.rs:3] n <= 1 = false [src/main.rs:3] n <= 1 = true [src/main.rs:4] 1 = 1 [src/main.rs:5] n * factorial(n - 1) = 2 [src/main.rs:5] n * factorial(n - 1) = 6 [src/main.rs:5] n * factorial(n - 1) = 24 [src/main.rs:11] factorial(4) = 24
¡Ya que la macro es dbg! devuelve el valor de depuración en sí, a diferencia de eprintln! , que devuelve () , entonces no necesitamos realizar ningún cambio en la estructura de nuestro código. Además, obtenemos una conclusión mucho más útil.
Prestamos mucha atención a una macro tan pequeña, ya que esperamos que simplifique su proceso de depuración. Por supuesto, también continuamos trabajando para apoyar a gdb and Co.
jemalloc eliminado por jemalloc
Érase una vez, Rust tuvo un gran tiempo de ejecución similar a Erlang. Para él, se eligió jemalloc en lugar del asignador del sistema, porque a menudo era más productivo. Poco a poco, nos deshicimos del tiempo de ejecución cada vez más y al final, casi todo se eliminó, pero quedó jemalloc. No teníamos forma de elegir un asignador personalizado y, por lo tanto, no podíamos eliminar completamente jemalloc para no dañar a quienes lo necesitaban.
Además, la afirmación de que jemalloc siempre fue el jemalloc predeterminado se relacionó principalmente con el mundo UNIX, ya que por defecto solo estaba en algunas plataformas. En particular, el objetivo de MSVC en Windows ha sido durante mucho tiempo utilizar un asignador del sistema.
Finalmente, aunque jemalloc generalmente tiene un buen rendimiento, este no es siempre el caso. Además, agrega aproximadamente 300 kilobytes a cada ejecutable. Además, hemos acumulado muchos otros problemas con jemalloc. En general, es extraño que el idioma del sistema no utilice el asignador del sistema de forma predeterminada.
Por estas razones, tan pronto como Rust 1.28 proporcionó una forma de elegir un asignador global , comenzamos a planear cambiar al asignador predeterminado del sistema y proporcionar jemalloc como una biblioteca externa. En Rust 1.32, finalmente completamos este trabajo, y ahora, por defecto, su programa utilizará el asignador del sistema.
Si desea continuar usando jemalloc, use la biblioteca jemallocator . Para hacer esto, especifique en Cargo.toml :
jemallocator = "0.1.8"
Y en el archivo raíz de su proyecto:
#[global_allocator] static ALLOC: jemallocator::Jemalloc = jemallocator::Jemalloc;
Eso es todo! Si no necesita jemalloc, ya no está obligado a usarlo, pero si lo necesita, el problema se resuelve con unas pocas líneas de código.
Mejoras finales del sistema del módulo
En las últimas dos versiones, hablamos sobre varias mejoras al sistema de módulos. En 1.32.0 y la edición 2018, agregamos el último cambio. Se llama "rutas uniformes" y le permite trabajar con rutas de importación de la misma manera que con otras rutas, que anteriormente funcionaban incorrectamente. Por ejemplo:
enum Color { Red, Green, Blue } use Color::*;
Este código no se ha compilado antes , ya que las rutas en use deberían haber comenzado con super , self o crate . Ahora, gracias al compilador que admite rutas consistentes, este código funcionará y hará lo que espera: importar variantes de la enumeración de Color definida anteriormente.
Este cambio completa nuestra revisión del sistema de módulos. ¡Esperamos que disfrute usando el sistema simplificado!
Mejoras de macro
Rust 1.32.0 ha lanzado varias mejoras macro. Primero, se agregó un nuevo especificador de fragmento literal :
macro_rules! m { ($lt:literal) => {}; } fn main() { m!("some string literal"); }
El fragmento literal se asigna a literales de cualquier tipo: cadena, numérico y carácter.
En la macro_rules 2018 macro_rules ¿puedes usar macro_rules también ? :
macro_rules! bar { ($(a)?) => {} }
Fragmento con ? se hará coincidir una ocurrencia cero o una, de la misma manera que un fragmento con * ya coincide con las ocurrencias "cero o más", y con + , una o más ocurrencias.
Estabilización de la biblioteca estándar.
Macro dbg! , que ya describimos anteriormente, se ha convertido en una adición importante a la biblioteca estándar. Además, 19 funciones se hicieron constantes y todos los tipos primitivos numéricos recibieron funciones de conversión a una matriz de bytes y viceversa con el orden de bytes especificado. Hay seis funciones con los nombres to_<endian>_bytes y to_<endian>_bytes from_<endian>_bytes , donde <endian> es:
ne - orden nativa (endianness nativa)le - orden de junior a senior (little endian)be - orden de mayor a menor (big endian)
Vea las notas de la versión para más detalles.
Mejoras de carga
Cargo recibió el alias cargo c para el comando de verificación de carga , y ahora permite que los nombres de usuario se usen en las URL del repositorio .
Vea las notas de la versión para más detalles.
Desarrolladores 1.32.0
Muchas personas juntas crearon Rust 1.32.0. No podríamos haber completado el trabajo sin cada uno de ustedes. Gracias
De un traductor: Expreso mi agradecimiento especial a los miembros de la comunidad Rustycrate y personalmente a @dashadee y ozkriff por su ayuda con la traducción y la corrección de pruebas.