Foi publicado o lançamento da linguagem de programação de uso geral Rust 1.61, 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 definir seus próprios códigos de retorno na função principal. Originalmente, a função principal do Rust só poderia retornar o tipo "()" (unidade), que sempre indicava um status de saída bem-sucedido, a menos que o desenvolvedor chamasse explicitamente a função "process::exit(code)". No Rust 1.26, utilizando o traço de Terminação instável na função principal, foi possível retornar os valores “Ok” e “Err”, correspondentes aos códigos EXIT_SUCCESS e EXIT_FAILURE nos programas C. No Rust 1.61, o traço Termination tornou-se estável e um tipo ExitCode separado foi proposto para representar um código de retorno específico, que abstrai tipos de retorno específicos da plataforma, fornecendo constantes predefinidas SUCCESS e FAILURE, e o método From para retornar um código de retorno personalizado. usar std::process::ExitCode; fn main() -> ExitCode { if !check_foo() { return ExitCode::from(8); } ExitCode::SUCESSO }
- Foram estabilizados recursos adicionais de funções definidas usando a expressão “const fn”, que podem ser chamadas não apenas como funções regulares, mas também usadas em qualquer contexto em vez de constantes. Essas funções são calculadas em tempo de compilação, não em tempo de execução, portanto estão sujeitas a certas restrições, como a capacidade de ler somente constantes. Na nova versão, são permitidas operações básicas com ponteiros de função dentro de funções const (é permitido criar, passar e converter ponteiros, mas não chamar uma função por ponteiro); limites de características para parâmetros genéricos de funções const como T: Copy; características despacháveis dinamicamente (dyn Trait); impl Tipos de características para argumentos de função e valores de retorno.
- O fluxo manipula Stdin, Stdout e Stderr em std::io agora tem um tempo de vida estático ("'static") quando bloqueado, permitindo construções como "let out = std::io::stdout().lock();" com a obtenção de um identificador e a definição de um bloqueio em uma expressão.
- 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:
- Pin::static_mut
- Pin::static_ref
- Vec::retain_mut
- VecDeque::retain_mut
- Escreva para Cursor<[u8; N]>
- std::os::unix::net::SocketAddr::from_pathname
- std::process::ExitCode
- std::process::Terminação
- std::thread::JoinHandle::is_finished
- O atributo "const", que determina a possibilidade de utilizá-lo em qualquer contexto ao invés de constantes, é utilizado em funções:
- <*const T>::offset e <*mut T>::offset
- <*const T>::wrapping_offset e <*mut T>::wrapping_offset
- <*const T>::add e <*mut T>::add
- <*const T>::sub e <*mut T>::sub
- <*const T>::wrapping_add e <*mut T>::wrapping_add
- <*const T>::wrapping_sub e <*mut T>::wrapping_sub
- <[T]>::as_mut_ptr
- <[T]>::as_ptr_range
- <[T]>::as_mut_ptr_range
Além disso, você pode observar o artigo “Rust: A Critical Retrospective” com um resumo das impressões da linguagem Rust após escrever 100 mil linhas de código nela durante o desenvolvimento do sistema operacional microkernel Xous usado no firmware. As desvantagens incluem sintaxe difícil de entender, incompletude e desenvolvimento contínuo da linguagem, falta de compilações repetíveis, problemas típicos de confiança de dependência no Crates.io e a necessidade de manter uma certa disciplina para escrever código seguro. Os recursos que superaram as expectativas incluem ferramentas para refatorar código e retrabalhar “hacks” adicionados durante a prototipagem rápida.
Fonte: opennet.ru