Ferrugem 1.35

A equipe de desenvolvimento do Rust tem o prazer de anunciar a versão mais recente da linguagem: 1.35. Rust é uma linguagem de programação que permite escrever programas robustos e eficientes.

Se você já tem o Rust instalado via rustup, pode atualizá-lo com o comando:
$ rustup atualização estável

A principal atualização é a implementação das traits de fechamento Fn, FnOnce e FnMut para Box. , Caixa , Caixa respectivamente. Foi adicionada a capacidade de converter closures em ponteiros para funções não seguras, a macro dbg!() agora pode ser chamada sem argumentos e a biblioteca padrão foi estabilizada.

Para os detalhes:

• A nova versão adiciona implementações das traits Fn, FnOnce e FnMut para Box. , Caixa , Caixa , respectivamente.
  Agora este código funcionará:
  fn foo(x: Caixa u8>) -> Vec {
  vec![1, 2, 3, 4].into_iter().map(x).collect()
  }

  Você também pode solicitar um fechamento diretamente do Box. :
  fn foo(x: Caixa ) {
  x()
  }

• Closures agora podem ser convertidas em ponteiros para funções inseguras (unsafe fn).
  Atualmente, este código é válido:
  /// Os invariantes de segurança são aqueles do ponteiro `unsafe fn` passado.
  função insegura call_unsafe_fn_ptr(f: função insegura()) {
  f ()
  }

  fn principal() {
  // SEGURANÇA: Não existem invariantes.
  // O bloco de código é impedido estaticamente de realizar ações inseguras.
  inseguro {
  call_unsafe_fn_ptr(|| {
  dbg!();
  });
  }
  }

• Adicionada a capacidade de chamar a macro dbg!() sem argumentos.
  Se você passar uma expressão para esta macro, ela imprimirá o resultado. Exemplo:
  fn principal() {
  seja mut x = 0;

  se dbg!(x == 1) {
  x + = 1;
  }

  dbg!(x);
  }

  Ao executar este código, você verá:
  [src/main.rs:4] x == 1 = falso
  [src/main.rs:8] x = 0

  Agora você pode escrever assim:
  fn principal() {
  seja condição = verdadeira;

  se condição {
  dbg!();
  }
  }

  Ao executar este código, você verá:
  [src/main.rs:5]
  

• Algumas partes da biblioteca padrão foram estabilizadas.
  • Novos métodos para f32 e f64:
    • f32::copysign
    • f64::copysign

    As funções essencialmente copiam o sinal de outro número. Exemplo:
    fn principal() {
    assert_eq!(3.5_f32.copysign(-0.42), -3.5);
    }

  • Adicionados novos métodos para tipos Range.
    • Intervalo::contém
    • RangeFrom::contém
    • IntervaloPara::contém
    • RangeInclusive::contém
    • RangeToInclusive::contém

    Com esses métodos, você pode verificar facilmente se um determinado valor está em uma sequência:
    fn principal() {
    se (0..=10).contém(&5) {
    println!("Cinco está incluído no intervalo de zero a dez.");
    }
    }

  • Você pode encontrar a lista completa de APIs estabilizadas. aqui
• Nesta atualização, o Clippy (um programa que verifica seu código em busca de vários erros) adicionou uma nova verificação para `drop_bounds`. Essa verificação é acionada quando você define a restrição: `T: Drop — for generic functions:`
  fn foo (x: T) {}

  Ter uma restrição de "T: Drop" costuma ser um erro, pois exclui imediatamente certos tipos, como u8. (Você pode ler mais sobre isso aqui.) aqui)

• Muitas melhorias e correções no Cargo (o gerenciador de pacotes de linguagem). lista completa de mudanças

Fonte: linux.org.ru