Foi publicado o lançamento da linguagem de programação de uso geral Rust 1.59, 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:
- É possível usar inserções em linguagem assembly, que são procuradas em aplicações que precisam controlar a execução em baixo nível ou ser capazes de usar instruções de máquina especializadas. As inserções de montagem são adicionadas usando macros "asm!" e "global_asm!" usando sintaxe de formatação de string para nomear registros semelhante àquela usada para substituições de string em Rust. O compilador suporta instruções de montagem para arquiteturas x86, x86-64, ARM, AArch64 e RISC-V. Exemplo de inserção: use std::arch::asm; // Multiplique x por 6 usando deslocamentos e adições let mut x: u64 = 4; inseguro {asm!( "mov {tmp}, {x}", "shl {tmp}, 1", "shl {x}, 2", "adicionar {x}, {tmp}", x = inout(reg ) x, tmp = saída(reg) _, ); } assert_eq!(x, 4 * 6);
- Adicionado suporte para atribuições desestruturadas (paralelas), nas quais diversas características, fatias ou estruturas são especificadas no lado esquerdo da expressão. Por exemplo: deixe (a, b, c, d, e); (uma, b) = (1, 2); [c, .., d, _] = [1, 2, 3, 4, 5]; Estrutura { e, .. } = Estrutura { e: 5, f: 3 }; assert_eq!([1, 2, 1, 4, 5], [a, b, c, d, e]);
- Foi fornecida a capacidade de especificar valores padrão para genéricos const: struct ArrayStorage {arr: [T; N], } impl ArrayStorage {fn novo(a:T, b:T) -> ArrayStorage {ArrayStorage { arr: [a, b], } } }
- O gerenciador de pacotes Cargo fornece avisos sobre o uso de estruturas inválidas em dependências que são processadas devido a erros no compilador (por exemplo, devido a um erro, foi permitido emprestar campos de estruturas compactadas em blocos seguros). Essas construções não serão mais suportadas em versões futuras do Rust.
- Cargo e Rustc possuem uma capacidade integrada de gerar arquivos executáveis sem dados de depuração (strip = "debuginfo") e símbolos (strip = "symbols"), sem a necessidade de chamar um utilitário separado. A configuração de limpeza é implementada através do parâmetro “strip” em Cargo.toml: [profile.release] strip = “debuginfo”, “symbols”
- A compilação incremental está desabilitada por padrão. Diz-se que o motivo é uma solução temporária para um bug no compilador que leva a travamentos e erros de desserialização. Uma correção de bug já foi preparada e será incluída na próxima versão. Para retornar a compilação incremental, você pode usar a variável de ambiente RUSTC_FORCE_INCREMENTAL=1.
- Uma nova parte da API foi movida para a categoria de estável, incluindo os métodos e implementações de características que foram estabilizadas:
- std::thread::available_parallelism
- Resultado::copiado
- Resultado::clonado
- arco::asm!
- arco::global_asm!
- operações::ControlFlow::is_break
- operações::ControlFlow::is_continue
- ExperimenteDe para u8
- char::TryFromCharError (Clone, Depuração, Display, PartialEq, Copiar, Eq, Erro)
- iter::zip
- Diferente de ZeroU8::is_power_of_two
- Diferente de ZeroU16::is_power_of_two
- Diferente de ZeroU32::is_power_of_two
- Diferente de ZeroU64::is_power_of_two
- Diferente de ZeroU128::is_power_of_two
- DoubleEndedIterator para estrutura ToLowercase
- DoubleEndedIterator para estrutura ToUppercase
- TryFrom<&mut [T]> para [T; N]
- UnwindSafe para a estrutura Once
- RefUnwindSafe pela primeira vez
- funções de suporte armv8 neon integradas ao compilador para aarch64
- O atributo "const", que determina a possibilidade de utilizá-lo em qualquer contexto ao invés de constantes, é utilizado em funções:
- mem::TalvezUninit::as_ptr
- mem::TalvezUninit::assume_init
- mem::TalvezUninit::assume_init_ref
- ffi::CStr::from_bytes_with_nul_unchecked
Fonte: opennet.ru