Foi lançado o Rust 1.78, uma linguagem de programação de propósito geral desenvolvida pela Mozilla, agora gerida pela organização sem fins lucrativos Rust Foundation. A linguagem foca na segurança do gerenciamento de memória e fornece ferramentas para alcançar alta paralelização na execução de tarefas, tudo isso sem a utilização de um coletor de lixo e com um runtime reduzido à inicialização básica e manutenção da biblioteca padrão.
Os métodos de manipulação de memória em Rust protegem o desenvolvedor de erros ao trabalhar com ponteiros e evitam problemas decorrentes de manipulação de memória de baixo nível, como acesso a áreas de memória após sua liberação, desreferenciação de ponteiros nulos, e estouro de buffer, entre outros. Para distribuição de bibliotecas, construção e gerenciamento de dependências, o projeto conta com o gerenciador de pacotes Cargo. O repositório crates.io é suportado para hospedagem de bibliotecas.
A manipulação segura da memória em Rust é garantida em tempo de compilação através da verificação de referências, rastreamento de propriedade de objetos, controle do tempo de vida dos objetos (escopos) e avaliação da correção do acesso à memória durante a execução do código. Rust também oferece mecanismos para proteção contra estouros inteiros, exige a inicialização obrigatória de valores de variáveis antes do uso, trata erros de forma superior na biblioteca padrão, aplica o conceito de referências e variáveis imutáveis (immutable) por padrão e oferece uma forte tipagem estática para minimizar erros lógicos.
Principais novidades:
- Foi proposto um novo espaço de nomes para atributos "#[diagnostic]", que oferece ferramentas para influenciar as mensagens de erro emitidas pelo compilador. O primeiro atributo implementado nesse novo espaço é "#[diagnostic::on_unimplemented]", que pode ser usado para personalizar as mensagens de erro emitidas quando um trait que não é implementado para um tipo é requerido. #[diagnostic::on_unimplemented( message = "My Message for `ImportantTrait` is not implemented for `{Self}`", label = "My Label", note = "Note 1", note = "Note 2" )] trait ImportantTrait {} fn use_my_trait(_: impl ImportantTrait) {} fn main() { use_my_trait(String::new()); } error[E0277]: My Message for `ImportantTrait` is not implemented for `String` —> src/main.rs:12:18 | 12 | use_my_trait(String::new()); | ———— ^^^^^^^^^^^^^ My Label | | | required by a bound introduced by this call | = help: the trait `ImportantTrait` is not implemented for `String` = note: Note 1 = note: Note 2
- As assertions preliminares aplicadas a funções unsafe agora podem ser adiadas até a fase de geração de código, permitindo que essas verificações sejam realizadas sem a necessidade de compilar a biblioteca padrão em modo "#[cfg(debug_assertions)]". Para que as verificações sejam acionadas, agora é suficiente habilitar assertions de depuração para compilações de teste ou de depuração do seu código.
- O comportamento das funções na biblioteca padrão que afetam o alinhamento de ponteiros e slices agora é previsível durante a execução e depende dos dados de entrada. A função pointer::align_offset, que calcula o deslocamento para o alinhamento de um ponteiro, agora retorna usize::MAX apenas quando a operação não pode ser realizada. As funções slice::align_to e slice::align_to_mut, que transformam slices em uma representação de slice alinhado, agora sempre retornam a maior parte central.
- As seguintes funcionalidades foram transferidas para a versão estável:
- impl Read for &Stdin
- É permitido o uso de tempos de vida não estáticos (não ‘static) para algumas implementações relacionadas ao std::error::Error.
- Na implementação impl é permitido o uso de valores ?Sized.
- impl From para io::Error
- A função Barrier::new() foi estabilizada para uso com o modificador ‘const’ em qualquer contexto, ao invés de constantes.
- Para as plataformas alvo x86_64-pc-windows-msvc, i686-pc-windows-msvc, x86_64-pc-windows-gnu, i686-pc-windows-gnu, x86_64-pc-windows-gnullvm e i686-pc-windows-gnullvm, agora é requerida pelo menos a versão do Windows 10.
- Foi implementado o terceiro nível de suporte para as plataformas wasm32-wasip2, arm64ec-pc-windows-msvc, armv8r-none-eabihf e loongarch64-unknown-linux-musl. O terceiro nível indica suporte básico, mas sem testes automatizados, publicação de builds oficiais e verificação da capacidade de compilar código.
- Foi implementado o segundo nível de suporte para a plataforma alvo Add wasm32-wasip1. O segundo nível de suporte garante a possibilidade de compilação.
- A plataforma wasm32-wasi-preview1-threads foi renomeada para wasm32-wasip1-threads.
- O compilador foi migrado para usar LLVM 18. Ao usar LLVM 18 para as arquiteturas x86-32 e x86-64, o ABI relacionado aos tipos u128 e i128 foi alterado.
- Na ferramenta de gerenciamento de pacotes Cargo, a versão 4 dos arquivos de bloqueio (lockfile v4) foi estabilizada.
- No Cargo, foi estabilizado um cache global com informações sobre o último uso de dados. O cache é armazenado no arquivo $CARGO_HOME/.global-cache usando SQLite, é atualizado automaticamente e reflete as últimas mudanças relacionadas ao índice, ao arquivo crate, ao diretório de código, ao git clone e ao git checkout.
Além disso, pode-se destacar a linguagem de programação Borgo, que tenta ser mais expressiva que a linguagem Go, mas menos complexa que a linguagem Rust. Borgo combina as melhores características de Go e Rust, preenchendo as lacunas de cada uma dessas linguagens. Por exemplo, a linguagem Go é simples e clara, mas não fornece ferramentas avançadas para garantir segurança ao trabalhar com tipos. A linguagem Rust oferece ferramentas para programação segura, mas é excessivamente complexa. O projeto é desenvolvido por Marco Sampellegrini, autor do livro 'The Simple Haskell Handbook' e desenvolvedor do sistema de integração contínua Quad CI.
O Borgo utiliza tipagem estática, tipos semelhantes aos da linguagem Go e uma sintaxe parecida com a do Rust. O uso de ponto e vírgula ao final das linhas no código Borgo não é obrigatório. O código na linguagem Borgo é compilado para um formato em Go, que é totalmente compatível com os pacotes existentes da linguagem Go. O código do compilador é escrito em Rust e distribuído sob a licença ISC. use fmt enum NetworkState { Loading, Failed(int), Success(T), } struct Response { title: string, duration: int, } fn main() { let res = Response { title: "Hello world", duration: 0, } let state = NetworkState.Success(res) let msg = match state { NetworkState.Loading => "ainda carregando", NetworkState.Failed(code) => fmt.Sprintf("Código de erro obtido: %d", code), NetworkState.Success(res) => res.title, } fmt.Println(msg) }
Fonte: opennet.ru
