A equipe de desenvolvimento do Rust tem o prazer de anunciar o lançamento de uma nova versão do Rust, 1.32.0. Rust é uma linguagem de programação que permite a todos criar software confiável e eficiente.
Se você possui uma versão anterior do Rust instalada usando rustup , para fazer o upgrade do Rust para a versão 1.32.0, basta fazer o seguinte:
$ rustup update stable
Se você ainda não instalou o rustup , poderá instalá-lo na página correspondente do nosso site. Notas de versão detalhadas do Rust 1.32.0 estão disponíveis no GitHub.
Uma observação rustup : vários novos lançamentos de rustup foram rustup ! Para atualizar o rustup si, faça rustup self update do rustup self update .
O que está incluído na versão estável 1.32.0
O Rust 1.32.0 adquiriu várias melhorias para melhorar a vida, alterou o alocador de memória padrão e tornou mais funções constantes. Leia sobre essas alterações abaixo ou veja mais nas notas de versão .
Macro dbg
Vamos começar com uma melhoria na melhoria da vida. Você usa a depuração de impressão? Nesse caso, e você deseja imprimir algum valor enquanto trabalha no código, você é forçado a fazer isso:
let x = 5; println!("{:?}", x);
Esse não é o maior obstáculo que atrasa o desenvolvimento, mas é preciso muito esforço para simplesmente depurar a saída do valor x . Além disso, o contexto não é levado em consideração aqui. Se você tiver vários desses println! s, fica difícil determinar a que a saída se refere, até você adicionar informações de contexto a cada chamada, o que exige ainda mais trabalho.
Para esses propósitos, no Rust 1.32.0 , adicionamos uma nova macro dbg! :
fn main() { let x = 5; dbg!(x); }
Depois de iniciar este programa, você verá:
[src/main.rs:4] x = 5
Juntamente com o nome da variável e seu valor, o nome do arquivo e o número da linha onde a chamada dbg! foi feita serão exibidos dbg! .
Além disso, println! imprime na saída padrão, por isso é melhor usar o eprintln! para imprimir no fluxo de erro padrão. Macro dbg! saídas para stderr , e com razão.
Isso funciona mesmo em casos difíceis. Considere um exemplo de implementação fatorial:
fn factorial(n: u32) -> u32 { if n <= 1 { n } else { n * factorial(n - 1) } }
Para eprintln! lo, podemos usar o 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 produzir n em cada iteração e ver o contexto de cada uma das ramificações. Para factorial(4) produzirá:
n: 4 n: 3 n: 2 n: 1 n <= 1 n: 2 n: 6 n: 24
Isso é aceitável, mas não particularmente bom. Talvez possamos trabalhar para melhorar a saída de informações de contexto para tornar a conclusão mais clara. Mas então, em vez de depurar nosso código, melhoraremos o código de depuração.
Considere o mesmo exemplo usando dbg! :
fn factorial(n: u32) -> u32 { if dbg!(n <= 1) { dbg!(1) } else { dbg!(n * factorial(n - 1)) } }
Simplesmente envolvemos uma macro com cada uma das expressões que queremos gerar. Como resultado, obtemos:
[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
Uma vez que a macro é dbg! retorna o próprio valor de depuração, diferente do eprintln! que retorna () , não precisamos fazer alterações na estrutura do nosso código. Além disso, temos uma conclusão muito mais útil.
Demos muita atenção a uma macro tão pequena, pois esperamos que isso simplifique seu processo de depuração. Obviamente, também continuamos a trabalhar no apoio ao gdb e à Co.
jemalloc removido por jemalloc
Era uma vez, Rust, um grande tempo de execução semelhante ao Erlang. Para ele, o jemalloc foi escolhido em vez do alocador do sistema, porque costumava ser mais produtivo. Gradualmente, nos livramos do tempo de execução cada vez mais e, no final, quase tudo foi excluído, mas o jemalloc permaneceu. Não tínhamos como escolher um alocador personalizado e, portanto, não conseguimos remover completamente o jemalloc, para não prejudicar aqueles que precisavam.
Além disso, a afirmação de que jemalloc sempre foi o jemalloc padrão estava principalmente relacionada ao mundo UNIX, uma vez que, por padrão, era apenas em algumas plataformas. Em particular, o objetivo do MSVC no Windows há muito tempo usa um alocador de sistema.
Finalmente, embora o jemalloc geralmente tenha um bom desempenho, esse nem sempre é o caso. Além disso, ele adiciona cerca de 300 kilobytes a cada executável. Além disso, acumulamos muitos outros problemas com o jemalloc. Em geral, é estranho que o idioma do sistema não use o alocador de sistema por padrão.
Por esses motivos, assim que o Rust 1.28 forneceu uma maneira de escolher um alocador global , começamos a planejar mudar para o alocador de sistema padrão e fornecer o jemalloc como uma biblioteca externa. No Rust 1.32, finalmente concluímos este trabalho e agora, por padrão, seu programa usará o alocador de sistema.
Se você quiser continuar usando o jemalloc, use a biblioteca jemallocator . Para fazer isso, especifique em Cargo.toml :
jemallocator = "0.1.8"
E no arquivo raiz do seu projeto:
#[global_allocator] static ALLOC: jemallocator::Jemalloc = jemallocator::Jemalloc;
Isso é tudo! Se você não precisar do jemalloc, não será mais obrigado a usá-lo, mas se precisar, o problema será resolvido com algumas linhas de código.
Melhorias finais no sistema do módulo
Nos últimos dois lançamentos, falamos sobre várias melhorias no sistema de módulos. No 1.32.0 e na edição de 2018, adicionamos a alteração mais recente. Ele é chamado de "caminhos uniformes" e permite trabalhar com os caminhos de importação da mesma maneira que com outros caminhos, que anteriormente funcionavam incorretamente. Por exemplo:
enum Color { Red, Green, Blue } use Color::*;
Este código não foi compilado antes , pois os caminhos em use deveriam ter começado com super , self ou crate . Agora, graças ao compilador que oferece suporte a caminhos consistentes, esse código funcionará e fará o que você espera: importando variantes da enumeração Color definida acima.
Essa alteração conclui nossa revisão do sistema de módulos. Esperamos que você goste de usar o sistema simplificado!
Aprimoramentos de macro
O Rust 1.32.0 lançou vários aprimoramentos de macro. Primeiro, um novo especificador de fragmento literal foi adicionado:
macro_rules! m { ($lt:literal) => {}; } fn main() { m!("some string literal"); }
O fragmento literal é mapeado para literais de qualquer tipo: string, numérico e caractere.
Na macro_rules 2018 macro_rules você também pode usar macro_rules ? :
macro_rules! bar { ($(a)?) => {} }
Fragmento com ? uma ocorrência zero ou uma será correspondida, assim como um fragmento com * já corresponde a "zero ou mais" ocorrências e com + , uma ou mais ocorrências.
Estabilização da biblioteca padrão
Macro dbg! , que já descrevemos acima, tornou-se uma adição importante à biblioteca padrão. Além disso, 19 funções foram mantidas constantes e todos os tipos numéricos primitivos receberam funções de conversão em uma matriz de bytes e vice-versa com a ordem de bytes especificada. Existem seis funções com os nomes to_<endian>_bytes e from_<endian>_bytes , onde <endian> é:
ne - ordem nativa (endianness nativo)le - ordem do junior ao senior (little endian)be - ordem do mais antigo para o mais novo (big endian)
Veja as notas de versão para mais detalhes.
Aprimoramentos de carga
Cargo recebeu o alias cargo c para o comando de verificação de carga e agora permite que nomes de usuários sejam usados nos URLs do repositório .
Veja as notas de versão para mais detalhes.
Desenvolvedores 1.32.0
Muitas pessoas juntas criaram o Rust 1.32.0. Não poderíamos ter concluído o trabalho sem cada um de vocês. Obrigada
De um tradutor: expresso um agradecimento especial aos membros da comunidade Rustycrate e pessoalmente @dashadee e ozkriff por sua ajuda na tradução e revisão.