Versão Rust 1.39.0: assíncrona / aguardada, atributos para parâmetros de função, novas funções constantes

A equipe Rust tem o prazer de anunciar o lançamento de uma nova versão, 1.39.0. Rust é uma linguagem de programação que permite a todos criar software confiável e eficiente.


Se você instalou a versão anterior do Rust usando rustup , para atualizar para a versão 1.39.0, basta executar o seguinte comando:


 $ rustup update stable 

Se você ainda não instalou o rustup , pode instalá-lo na página correspondente do nosso site, bem como ver notas de versão detalhadas no GitHub.


O que está incluído na versão estável 1.39.0


As inovações mais significativas incluem a .await async / .await , referências compartilhadas a valores móveis em match-guards e os atributos dos parâmetros de função. Consulte as notas de versão detalhadas para obter mais informações.


Com o .await terminado, conheça async fn


No início do Rust 1.36.0, anunciamos a disponibilidade da característica Future . Então observamos que:


Esperamos que essa inovação permita que caixas populares, bibliotecas e todo o ecossistema se preparem para a .await async / .await , que está planejada para ser estabilizada em um futuro próximo.

A promessa é dada - a promessa é cumprida. Temos o prazer de anunciar que a tão esperada .await async / .await , que nos permite definir funções e blocos async ( async ) e aguardar sua execução ( .await ), finalmente está estável!


Uma função assíncrona definida usando a sintaxe async fn (em vez da fn usual) não faz nada, exceto que, quando chamada, retorna um objeto que implementa a característica Future . Este objeto é um cálculo suspenso, que pode ser concluído com a sintaxe .await . Além disso, async fn , async { ... } e async move { ... } atuam como fechamentos e podem ser usados ​​para definir literais assíncronos.


Você pode ler mais sobre o lançamento do async / .await na postagem do blog Niko Matsakis .


Links compartilhados para valores de roaming em match-guards


Ao corresponder uma imagem, uma variável conhecida como ligação pode ser vinculada de uma das seguintes maneiras:


  • Por referência, imutável ou mutável. Isso pode ser feito explicitamente, por exemplo, com a sintaxe ref my_var ou ref mut my_var respectivamente. Quase sempre, o modo snap é exibido automaticamente.


  • Por valor - copiando (se o tipo da variável vinculada implementa a característica Copy ) ou transferindo-a para propriedade .



Agora, é permitido usar variáveis ​​de modelo nas restrições if do modelo, se a propriedade for transferida para essa variável (ou seja, a variável no modelo de vinculação por movimentação). Anteriormente, o seguinte código seria descartado:


 fn main() { let array: Box<[u8; 4]> = Box::new([1, 2, 3, 4]); match array { nums // ---- `nums`    (by move). if nums.iter().sum::<u8>() == 10 // ^------ `.iter()`     `nums` => { drop(nums); // ----------- `nums`      } _ => unreachable!(), } } 

Começando com Rust 1.39.0 , o compilador aceitará o fragmento acima sem avisos e erros. Esperamos que essa inovação aumente a usabilidade da expressão de match .


Atributos para parâmetros de função


A partir do Rust 1.39.0, os atributos podem ser aplicados aos parâmetros, fechamentos e ponteiros de função. Anteriormente, a função len() podia ser representada da seguinte maneira:


 #[cfg(windows)] fn len(slice: &[u16]) -> usize { slice.len() } #[cfg(not(windows))] fn len(slice: &[u8]) -> usize { slice.len() } 

Mas o Rust 1.39.0 simplifica muito a escrita do código acima:


 fn len( #[cfg(windows)] slice: &[u16], //        Windows. #[cfg(not(windows))] slice: &[u8], //       . ) -> usize { slice.len() } 

Atributos utilizáveis ​​incluem:


  1. Compilação condicional: cfg e cfg_attr ;


  2. Verificar gerenciamento: allow , warn , deny e forbid ;


  3. Atributos auxiliares usados ​​por macros de atributo procedural para elementos de sintaxe.


    Esperamos que essa inovação ajude o ecossistema a escrever DSLs baseadas em macro mais expressivas.



Os avisos de migração de cheques emprestados se tornam bugs graves no Rust 2018


No release 1.35.0, anunciamos que o novo analisador de empréstimos (NLL) chegou aos editores do Rust 2015 depois de lançado aos editores do Rust 2018 na versão 1.31 .


Conforme declarado na liberação 1.35.0, o analisador de empréstimos anterior foi projetado com bugs que permitiam o uso inseguro de memória. Esses erros foram corrigidos usando um novo analisador que implementa a NLL. Como essas correções podem quebrar o código de trabalho, a equipe do Rust decidiu introduzi-las gradualmente, verificando se o analisador anterior deveria aceitar o código, que o novo analisador rejeitaria. Nesse caso, os erros se tornarão avisos.


A partir do Rust 1.39.0, esses avisos agora são bugs na edição do Rust 2018 .
Na próxima versão do Rust 1.40.0, essa regra também será aplicada ao código de revisão do Rust 2015 , que eliminará completamente o antigo analisador de empréstimos do compilador.


Se você é afetado por essas alterações ou deseja saber mais, consulte a postagem do blog Niko Matsakis .


Funções mais constantes na biblioteca padrão


Começando com Rust 1.39.0, as seguintes funções são marcadas como const fn ( const fn ):



Funções estáveis ​​na biblioteca padrão


As seguintes funções foram estabilizadas no Rust 1.39.0:



Outras mudanças


A sintaxe , o gerenciador de pacotes de carga e o analisador Clippy também sofreram algumas alterações.


Leia as notas de compatibilidade para ver se essas alterações afetam você.


Membros 1.39.0


Muitas pessoas se uniram para criar o Rust 1.39.0. Não poderíamos ter feito isso sem todos vocês, obrigado !


De tradutores


Em caso de dúvidas sobre o idioma Rust, eles poderão ajudá-lo no bate-papo do telegrama no idioma russo ou em um bate-papo semelhante para os novatos .


Este artigo foi traduzido em conjunto por andreevlex , blandger , funkill e Hippolot .

Source: https://habr.com/ru/post/pt474808/


All Articles