A equipe de desenvolvimento do Rust tem o prazer de anunciar o lançamento de uma nova versão do Rust, 1.31.0, além do "Rust 2018". 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.31.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.31.0 estão disponíveis no GitHub.
O que está incluído na versão estável 1.31.0
Rust 1.31 é sem dúvida o lançamento mais significativo desde o Rust 1.0! A primeira iteração do "Rust 2018" está incluída nesta versão, mas essa não é a única inovação! A revisão das melhorias será longa, então aqui está o índice:
- Rust 2018
- Tempos de vida não lexicais
- Alterações no sistema de módulos
- Regras adicionais para exibir vidas úteis
const fn- Novas ferramentas
- Verificações instrumentais de qualidade do código
- A documentação
- Grupos de Trabalho
- Novo site
- Estabilização da biblioteca padrão
- Aprimoramentos de carga
- Release Developers
Rust 2018
Escrevemos sobre o Rust 2018 pela primeira vez em março e depois em julho . Para detalhes sobre por que você precisa do Rust 2018, consulte estas publicações. Nesta revisão, há muito a nos dizer, portanto, focaremos apenas no que é o Rust 2018. Você também pode ler sobre isso em um post no Mozilla Hacks ( tradução ).
Em suma, o Rust 2018 é uma oportunidade para integrar todo o trabalho que fizemos nos últimos três anos em um todo coerente. O Rust 2018 é mais do que apenas um monte de melhorias de idioma. Além deles, inclui:
- Kit de ferramentas (suporte no IDE,
rustfmt , Clippy) - A documentação
- Grupos de trabalho sujeitos
- Novo site
Além disso, falaremos sobre tudo isso em mais detalhes e sobre outras inovações.
Vamos criar um novo projeto usando Cargo:
$ cargo new foo
Aqui está o conteúdo do Cargo.toml :
[package] name = "foo" version = "0.1.0" authors = ["Your Name <you@example.com>"] edition = "2018" [dependencies]
Uma nova chave foi adicionada à seção [package] : edition . Observe que ele está instalado em 2018 . Você também pode instalá-lo em 2015 - esse valor será definido por padrão se a chave estiver ausente.
O uso do Rust 2018 desbloqueia alguns novos recursos que não são permitidos no Rust 2015.
É importante observar que cada pacote pode estar no modo 2015 ou 2018 e eles trabalharão juntos. Seu projeto da edição 2018 pode usar as dependências da edição 2015 e o projeto da edição 2015 pode usar as dependências da edição 2018. Isso garante a integridade do ecossistema e que todos os novos recursos serão opcionais, mantendo a compatibilidade com o código existente. Além disso, quando você decide portar o código do Rust 2015 para o Rust 2018, as alterações podem ser feitas automaticamente através da cargo fix .
Você pode perguntar: e os novos recursos? Em primeiro lugar, eles também são adicionados no Rust 2015, se forem compatíveis com os recursos desta edição. Assim, a maior parte do idioma permanece a mesma em todos os lugares. Você pode consultar o manual editorial para descobrir a versão mínima do rustc para cada novo recurso e seus outros requisitos. No entanto, existem várias grandes inovações que precisam ser mencionadas separadamente: vida útil não-lexical e algumas mudanças no sistema do módulo.
Tempos de vida não lexicais
Se você tem seguido o Rust nos últimos anos, pode ocasionalmente encontrar o termo "NLL" ou "vidas não-lexicais". Esse é um jargão, que, em termos simples, significa: o mutuário se tornou mais inteligente e agora aceita algum código correto, que ele rejeitou anteriormente. Considere um exemplo:
fn main() { let mut x = 5; let y = &x; let z = &mut x; }
Ferrugem usada para gerar um erro de compilação:
error[E0502]: cannot borrow `x` as mutable because it is also borrowed as immutable --> src/main.rs:5:18 | 4 | let y = &x; | - immutable borrow occurs here 5 | 6 | let z = &mut x; | ^ mutable borrow occurs here 7 | } | - immutable borrow ends here
Isso ocorre porque a área de vida dos links foi definida "lexicamente"; isto é, pedir emprestado y foi considerado ativo até que y saiu do escopo no final do main , mesmo que nunca o y dentro do escopo novamente. Está tudo bem com o código acima, mas o analisador de dependências não conseguiu entender isso.
Agora esse código compila bem.
Mas e se usamos y ? Por exemplo, assim:
fn main() { let mut x = 5; let y = &x; let z = &mut x; println!("y: {}", y); }
Ferrugem usada para fornecer esse erro:
error[E0502]: cannot borrow `x` as mutable because it is also borrowed as immutable --> src/main.rs:5:18 | 4 | let y = &x; | - immutable borrow occurs here 5 | let z = &mut x; | ^ mutable borrow occurs here ... 8 | } | - immutable borrow ends here
No Rust 2018, esta mensagem de erro foi aprimorada:
error[E0502]: cannot borrow `x` as mutable because it is also borrowed as immutable --> src/main.rs:5:13 | 4 | let y = &x; | -- immutable borrow occurs here 5 | let z = &mut x; | ^^^^^^ mutable borrow occurs here 6 | 7 | println!("y: {}", y); | - borrow later used here
Em vez de indicar onde y sai do escopo, mostra onde ocorrem empréstimos conflitantes. Isso simplifica bastante os erros de depuração desse tipo.
No Rust 1.31, essa é uma melhoria exclusiva para o Rust 2018. Planejamos adicioná-lo ao Rust 2015 mais tarde.
Alterações no sistema de módulos
O sistema de módulos pode ser difícil para as pessoas que estão aprendendo Rust pela primeira vez. Claro, sempre há algo que leva tempo para dominar. Mas a principal razão pela qual os módulos são tão embaraçosos para muitos é que, apesar das regras simples e consistentes que definem o sistema de módulos, as conseqüências de seu uso podem parecer contraditórias, misteriosas e não naturais.
Portanto, a edição 2018 faz algumas alterações na maneira como os caminhos funcionam, simplificando o sistema de módulos e tornando-o mais compreensível.
Aqui está um breve resumo:
extern crate não extern crate mais necessária em quase nenhum outro lugar.- Você pode importar macros usando
use , em vez de usar o atributo #[macro_use] . - Os caminhos absolutos começam com o nome do contêiner, onde a palavra-chave
crate refere-se ao contêiner atual. foo.rs e o foo/ subdiretório podem coexistir; mod.rs não mod.rs mais necessário ao colocar submódulos em um subdiretório.
Parece um conjunto arbitrário de regras, mas, em geral, o modelo mental agora foi bastante simplificado.
Ainda há muitos detalhes, consulte o manual editorial para todos os detalhes.
Regras adicionais para exibir vidas úteis
Vamos falar sobre a melhoria disponível em ambas as edições: adicionamos algumas regras de inferência adicionais para blocos de impl e definições de funções. Código como este:
impl<'a> Reader for BufReader<'a> {
agora pode ser escrito assim:
impl Reader for BufReader<'_> {
Lifetime '_ ainda mostra que o BufReader usa como parâmetro, mas não precisamos mais dar um nome a ele.
As vidas ainda precisam ser definidas em estruturas. No entanto, não precisamos mais escrever o código padrão como antes:
Dependência : 'a será impressa. Você ainda pode especificá-lo explicitamente, se desejar. Estamos considerando outras oportunidades de retirada nesses locais para o futuro, mas até agora não temos planos concretos.
const fn
O Rust possui várias maneiras de declarar uma função: fn para funções comuns, unsafe fn para funções inseguras e extern fn para funções externas. Esta versão adiciona uma nova maneira de declarar uma função: const fn . É usado assim:
const fn foo(x: i32) -> i32 { x + 1 }
Uma função constante pode ser chamada como uma função normal, mas, além disso, pode ser usada em qualquer contexto constante. No entanto, ele será executado em tempo de compilação e não durante a execução do programa. Por exemplo:
const SIX: i32 = foo(5);
A função foo será executada em tempo de compilação e SIX será definido como 6 .
As funções constantes não podem fazer tudo o que as funções normais podem fazer: elas devem ter um resultado determinístico. Isso é importante por razões de confiabilidade. Na forma atual, funções constantes podem executar um subconjunto mínimo de operações. Aqui estão alguns exemplos do que você pode fazer neles:
- Use aritmética inteira e operações de comparação
- Use qualquer operação lógica, exceto
&& e || - Design de matrizes, estruturas, enumerações e tuplas
- Chamar outras funções constantes
- Acesso por índice em matrizes e fatias
- Acessando os Campos de Estruturas e Tuplas
- Use constantes (mas não valores estáticos e nem mesmo referências a eles)
- Use os links
& e * - Tipos de conversão, exceto converter o ponteiro bruto para o valor inteiro
Expandiremos os recursos de funções constantes, mas o conjunto acima já é suficiente para usar const fn na prática.
Veja o manual para detalhes.
Novas ferramentas
A edição de 2018 marca o início de um novo nível de maturidade para o ecossistema de ferramentas Rust. Cargo, Rustdoc e Rustup são as principais ferramentas desde a versão 1.0; Com a edição de 2018, está chegando uma nova geração de ferramentas que todos podem usar: Suporte para Clippy, Rustfmt e IDE.
O analisador de código estático está agora disponível no Rust estável. Você pode instalá-lo através do rustup component add clippy e executá-lo com o cargo clippy . O Clippy agora recebeu a versão 1.0 e possui as mesmas garantias de estabilidade para verificações estáticas que o rustc. Novas verificações podem ser adicionadas ou a funcionalidade das antigas pode ser expandida, mas as antigas não podem ser excluídas (elas só podem ser marcadas como desatualizadas). Isso significa que o código que compila com o clippy continuará sendo compilado com o clippy (supondo que nenhuma verificação esteja configurada para gerar
erro via deny ), mas pode gerar novos avisos.
Rustfmt é uma ferramenta para formatar código no Rust. A formatação automática de código economizará tempo, além disso, aproximará seu código do estilo oficial Rust . Você pode instalá-lo através do rustup component add rustfmt e use o comando cargo fmt .
A versão atual inclui o Rustfmt 1.0. A partir de agora, garantimos a compatibilidade com versões anteriores do Rustfmt: se você formatar seu código hoje, a formatação não será alterada no futuro (apenas nas configurações padrão). Compatibilidade com versões anteriores significa que agora é prático executar o Rustfmt no seu IC (use cargo fmt --check ). Tente isso junto com “formatação ao salvar” no editor, e seu fluxo de trabalho será revolucionado.
O suporte ao IDE é um dos recursos mais solicitados para o Rust. Agora, existem várias soluções de alta qualidade:
O trabalho de suporte no IDE não está concluído. Em particular, o preenchimento de código em editores baseados em RLS não está ao mesmo nível. No entanto, se você deseja principalmente suporte para tipos, documentação e a "transição para a definição", ficará satisfeito.
No Rust 1.30, estabilizamos "atributos instrumentais" como #[rustfmt::skip] . No Rust 1.31, estabilizamos algo como isto: "tool lints" como #[allow(clippy::bool_comparison)] . Isso permite que você especifique os espaços de nomes para as verificações, para deixar mais claro de que ferramentas elas vêm.
Se você já usou as verificações do Clippy, pode migrar da seguinte maneira:
Você não precisa mais de cfg_attr ! Você também receberá avisos que ajudarão você a usar o novo estilo.
A documentação
Houve várias melhorias no Rustdoc este ano e o livro completamente reescrito, The Rust Programming Language, foi lançado. Você pode comprar uma cópia em papel da No Starch Press !
Antigamente era chamada de "segunda edição" do livro, mas desde que se tornou a primeira edição impressa, isso causou confusão. Afinal, a edição impressa está planejada para ser atualizada periodicamente. No final, depois de muitas discussões com o No Starch, foi decidido atualizar o livro no site a cada lançamento, e o No Starch periodicamente pegava as alterações e as imprimia. O livro vende muito bem e arrecada dinheiro para o Black Girls Code .
Você pode encontrar a nova versão do livro aqui .
Grupos de Trabalho
Este ano, anunciamos a criação de quatro grupos de trabalho:
- Serviços de rede
- Aplicativos de linha de comando
- Webassembly
- Dispositivos incorporados
Os grupos trabalharam muito para melhorar o Rust em cada uma dessas áreas. Aqui estão algumas conquistas:
- Os serviços de rede redesenharam a interface para futuros e, além disso, assíncrona / aguardada. Essas melhorias ainda não foram lançadas, mas já estamos perto disso!
- A equipe da CLI trabalhou em bibliotecas e documentação para melhorar os aplicativos de linha de comando.
- O WebAssembly lançou muitas ferramentas de classe mundial para o uso do Rust com wasm.
- Para dispositivos embarcados, tornou-se possível desenvolver o ARM em um Rust estável!
Você pode aprender mais sobre tudo isso em nosso novo site!
Novo site
Na semana passada , anunciamos uma nova versão do nosso site. Agora tornou-se a versão oficial do rust-lang.org!
Para criar, foi preciso um ano de trabalho de muitas pessoas. Embora ainda haja muito a ser feito antes de sua conclusão, estamos orgulhosos do trabalho realizado.
Estabilização da biblioteca padrão
Novas implementações From foram adicionadas:
u8 agora implementa o From<NonZeroU8> , da mesma forma para outros tipos numéricos e seus equivalentes diferentes de NonZeroOption<&T> implementa From<&Option<T>> , da mesma forma que &mut
As seguintes funções também foram estabilizadas:
Veja as notas de versão para mais detalhes.
Aprimoramentos de carga
Agora o Cargo carregará pacotes em paralelo usando HTTP / 2.
Além disso, como a extern crate agora extern crate opcional, seria frustrante escrever extern crate foo as bar; renomear a dependência. Portanto, você pode fazê-lo no Cargo.toml desta maneira:
[dependencies] baz = { version = "0.1", package = "foo" }
ou, equivalente:
[dependencies.baz] version = "0.1" package = "foo"
O pacote foo agora está disponível como baz para uso em seu código.
Veja as notas de versão para mais detalhes.
Desenvolvedores 1.31.0
Normalmente, no final da revisão, agradecemos às pessoas que contribuíram para o lançamento . Mas desta vez, ao contrário do passado, essa lista não cobre totalmente todas as pessoas que ajudaram e toda a quantidade de trabalho que foi realizado. Cada versão regular é o resultado de seis semanas de trabalho, mas essa versão é o culminar de três anos de esforço, refletidos na miríade de repositórios feitos por um grande número de pessoas. Ficamos satisfeitos em trabalhar com todos vocês e esperamos ansiosamente pelo desenvolvimento contínuo do Rust nos próximos três anos.
De um tradutor: expresso meus agradecimentos especiais aos membros da comunidade Rustycrate e pessoalmente @dashadee , ozkriff , humbug e mvlabat por sua ajuda na tradução e revisão.