Foi publicado o lançamento da linguagem de programação de uso geral Rust 1.78, fundada pelo projeto Mozilla, mas agora desenvolvida sob os auspícios da organização independente sem fins lucrativos Rust Foundation. A linguagem se concentra na segurança da memória e fornece os meios para obter alto paralelismo de trabalho, evitando o uso de um coletor de lixo e tempo de execução (o tempo de execução é reduzido à inicialização básica e manutenção da biblioteca padrão).
Os métodos de manipulação de memória do Rust salvam o desenvolvedor de erros ao manipular ponteiros e protegem contra problemas que surgem devido ao manuseio de memória de baixo nível, como acessar uma área de memória após ter sido liberada, desreferenciar ponteiros nulos, saturação de buffer, etc. Para distribuir bibliotecas, prover builds e gerenciar dependências, o projeto desenvolve o gerenciador de pacotes Cargo. O repositório crates.io é compatível com hospedagem de bibliotecas.
A segurança da memória é fornecida no Rust em tempo de compilação por meio de verificação de referência, acompanhando a propriedade do objeto, acompanhando o tempo de vida do objeto (escopos) e avaliando a exatidão do acesso à memória durante a execução do código. Rust também fornece proteção contra estouros de número inteiro, requer inicialização obrigatória de valores de variáveis antes do uso, lida melhor com erros na biblioteca padrão, aplica o conceito de referências e variáveis imutáveis por padrão, oferece tipagem estática forte para minimizar erros lógicos.
Principais inovações:
- Um novo namespace de atributo "#[diagnostic]" foi proposto, fornecendo um meio de influenciar as mensagens de erro produzidas pelo compilador. O primeiro no novo espaço é o atributo "#[diagnostic::on_unimplemented]", que pode ser usado para customizar as mensagens de erro lançadas em uma situação em que você precisa usar uma característica que não está implementada para o tipo. #[diagnostic::on_unimplemented( message = "Minha mensagem para `ImportantTrait<{A}>` não está implementada para `{Self}`", label = "My Label", note = "Nota 1", note = "Nota 2" )] traço ImportanteTrait {} fn use_my_trait(_: impl ImportanteTrait ) {} fn main() { use_my_trait(String::new()); } erro [E32]: Minha mensagem para `ImportantTrait ` não está implementado para `String` —> src/main.rs:0277:32 | 12 | use_my_trait(String::new()); | ———— ^^^^^^^^^^^^^ Minha Etiqueta | | | exigido por um limite introduzido por esta chamada | = ajuda: o traço `ImportantTrait `não está implementado para `String` = nota: Nota 18 = nota: Nota 12
- As verificações de pré-afirmação aplicadas a funções inseguras agora podem ser adiadas até a geração do código, permitindo que essas verificações sejam realizadas sem a necessidade de construir a biblioteca padrão no modo "#[cfg(debug_assertions)]". Para acionar verificações, agora é suficiente habilitar declarações de depuração para testes ou compilações de depuração do seu código.
- O comportamento das funções da biblioteca padrão que afetam o alinhamento de ponteiros e fatias agora é previsível em tempo de execução e depende dos dados de entrada. A função pointer::align_offset, que calcula o deslocamento para alinhar o ponteiro, agora retorna usize::MAX somente se a operação falhar. As funções slice::align_to e slice::align_to_mut, que transformam fatias em uma representação com uma fatia central alinhada e as fatias iniciais e finais originais, agora sempre retornam a maior parte central.
- Foram transferidos para a categoria estável:
- impl Ler para &Stdin
- Permitir o uso de um tempo de vida não estático (não estático) para algumas implementações relacionadas a std::error::Error.
- Implementação de implementação permitido usar o valor ?Sized.
- impl De para io::Erro
- A função Barrier::new() foi estabilizada para ser usada com o atributo "const" em qualquer contexto em vez de constantes.
- Para plataformas de destino 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 requer pelo menos a versão do Windows 10.
- O terceiro nível de suporte foi implementado para as plataformas wasm32-wasip2, arm64ec-pc-windows-msvc, armv8r-none-eabihf e loongarch64-unknown-linux-musl. O terceiro nível envolve suporte básico, mas sem testes automatizados, publicação de compilações oficiais ou verificação se o código pode ser compilado.
- O segundo nível de suporte para a plataforma de destino Add wasm32-wasip1 foi implementado. O segundo nível de apoio envolve uma garantia de montagem.
- A plataforma wasm32-wasi-preview1-threads foi renomeada para wasm32-wasip1-threads.
- O compilador foi alterado para usar o LLVM 18. Ao usar o LLVM 18 para arquiteturas x86-32 e x86-64, a ABI associada aos tipos u128 e i128 foi alterada.
- No Cargo Pact Manager, a versão 4 dos arquivos de bloqueio (lockfile v4) foi estabilizada.
- Cargo possui um cache global estabilizado com informações sobre o uso de dados mais recente. O cache é hospedado em $CARGO_HOME/.global-cache usando SQLite e é atualizado automaticamente para refletir as alterações mais recentes no índice, arquivo crate, diretório de código, clone git e checkout git.
Além disso, a linguagem de programação Borgo tenta ser mais expressiva que a linguagem Go, mas menos complexa que a linguagem Rust. Borgo combina os melhores recursos do Go e Rust, compensando as deficiências de cada linguagem. Por exemplo, Go é simples e direto, mas não oferece recursos avançados de segurança. A linguagem Rust fornece ferramentas para programação segura, mas é muito complicada. O projeto está sendo desenvolvido por Marco Sampellegrini, autor do The Simple Haskell Handbook e desenvolvedor do sistema de integração contínua Quad CI.
Borgo usa digitação estática, tipos semelhantes a Go e sintaxe semelhante a Rust. Ponto e vírgula são opcionais no final das linhas no código Borgo. O código Borgo é compilado em uma representação Go que é totalmente compatível com os pacotes Go existentes. O código do compilador é escrito em Rust e distribuído sob a licença ISC. use fmt enum NetworkState { Carregando, Falha (int), Sucesso (T), } struct Response { título: string, duração: int, } fn main() { let res = Response { título: “Olá mundo”, duração: 0, } let state = NetworkState.Success (res) let msg = match state { NetworkState.Loading => “ainda carregando”, NetworkState.Failed (código) => fmt.Sprintf (“Obteve código de erro:% d”, código), NetworkState.Success (res) => res.title, } fmt.Println(msg) }
Fonte: opennet.ru
