Rust 1.35

A equipe de desenvolvedores do Rust tem o prazer de apresentar a nova versão de sua linguagem: 1.35. Rust é uma linguagem de programação que permite escrever programas confiáveis e eficientes.

Se você já tem o Rust instalado através do rustup, você pode atualizar com o comando:
$ rustup update stable

O principal desta atualização é a implementação dos traits de fechamento Fn, FnOnce, FnMut para Box<dyn Fn>, Box<dyn FnOnce>, Box<dyn FnMut>, respectivamente. A adição da capacidade de converter fechamentos em ponteiros para funções inseguras, a chamada do macro dbg!() agora é possível sem argumentos, e a estabilização da biblioteca padrão foi concluída.

Detalhes:

• Na nova versão, foram adicionadas implementações dos traits Fn, FnOnce, FnMut para Box<dyn Fn>, Box<dyn FnOnce>, Box<dyn FnMut>, respectivamente.
  Agora, esse código funcionará:
  fn foo(x: Box<dyn Fn(u8) -> u8>) -> Vec<u8> {
  vec![1, 2, 3, 4].into_iter().map(x).collect()
  }

  Além disso, você pode chamar fechamentos diretamente de Box<dyn FnOnce>:
  fn foo(x: Box<dyn FnOnce()>) {
  x()
  }

• Agora, fechamentos podem ser convertidos em ponteiros para unsafe fn.
  Atualmente, esse código é válido:
  /// The safety invariants are those of the `unsafe fn` pointer passed.
  unsafe fn call_unsafe_fn_ptr(f: unsafe fn()) {
  f()
  }

  fn main() {
  // SAFETY: There are no invariants.
  // The closure is statically prevented from doing unsafe things.
  unsafe {
  call_unsafe_fn_ptr(|| {
  dbg!();
  });
  }
  }

• Foi adicionada a capacidade de chamar o macro dbg!() sem argumentos.
  Se você passar uma expressão para esse macro, ele exibirá seu resultado. Exemplo:
  fn main() {
  let mut x = 0;

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

  dbg!(x);
  }

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

  Agora você pode escrever assim:
  fn main() {
  let condition = true;

  if condition {
  dbg!();
  }
  }

  Ao executar esse 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

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

  • Novos métodos foram adicionados para tipos Range.
    • Range::contains
    • RangeFrom::contains
    • RangeTo::contains
    • RangeInclusive::contains
    • RangeToInclusive::contains

    Com esses métodos, é fácil verificar se um determinado valor está na sequência:
    fn main() {
    if (0..=10).contains(&5) {
    println!("Cinco está incluído de zero a dez.");
    }
    }

  • Você pode encontrar a lista completa de APIs estabilizadas. aqui
• Nesta atualização, no Clippy (um programa que verifica seu código em busca de erros), foi adicionada uma nova verificação para drop_bounds. Essa verificação é acionada quando você impõe a restrição: T: Drop — para funções genéricas:
  fn foo<T: Drop>(x: T) {}

  Ter a restrição T: Drop é muitas vezes um erro, pois exclui imediatamente certos tipos como u8. (Você pode ler mais sobre isso.) aqui)

• Muitos aperfeiçoamentos e correções foram realizados no Cargo (gerenciador de pacotes da linguagem), lista completa de alterações

Fonte: linux.org.ru