Rust 1.35

L'équipe de développeurs Rust est heureuse de présenter la nouvelle version de son langage : 1.35. Rust est un langage de programmation qui permet d'écrire des programmes fiables et efficaces.

Si vous avez déjà installé Rust via rustup, vous pouvez le mettre à jour avec la commande :
$ rustup update stable

L'aspect principal de la mise à jour est la réalisation des traits de fermeture Fn, FnOnce, FnMut pour Box, Box, Box, respectivement. L'ajout de la possibilité de convertir les fermetures en pointeurs vers des fonctions non sécurisées, l'appel du macro dbg!() est maintenant possible sans arguments, et la stabilisation de la bibliothèque standard a eu lieu.

En détail :

• La nouvelle version a ajouté les implémentations des traits Fn, FnOnce, FnMut pour Box, Box, Box, respectivement.
  Maintenant, ce code fonctionnera :
  fn foo(x: Box u8>) -> Vec {
  vec![1, 2, 3, 4].into_iter().map(x).collect()
  }

  De plus, il est possible d'appeler une fermeture directement depuis Box :
  fn foo(x: Box) {
  x()
  }

• Maintenant, les fermetures peuvent être converties en pointeurs vers des fonctions non sécurisées.
  À présent, ce code est valide :
  /// 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!();
  });
  }
  }

• La possibilité d'appeler le macro dbg!() sans arguments a été ajoutée.
  Si vous passez une expression à ce macro, il affichera son résultat. Exemple :
  fn main() {
  let mut x = 0;

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

  dbg!(x);
  }

  Lorsque vous exécutez ce code, vous verrez :
  [src/main.rs:4] x == 1 = false
  [src/main.rs:8] x = 0

  Maintenant, vous pouvez écrire comme ceci :
  fn main() {
  let condition = true;

  if condition {
  dbg!();
  }
  }

  Lorsque vous exécutez ce code, vous verrez :
  [src/main.rs:5]
  

• Certaines parties de la bibliothèque standard ont été stabilisées.
  • Nouvelles méthodes pour f32 et f64 :
    • f32::copysign
    • f64::copysign

    Les fonctions copient le signe d'un autre nombre. Exemple :
    fn main() {
    assert_eq!(3.5_f32.copysign(-0.42), -3.5);
    }

  • De nouvelles méthodes ont été ajoutées pour les types Range
    • Range::contains
    • RangeFrom::contains
    • RangeTo::contains
    • RangeInclusive::contains
    • RangeToInclusive::contains

    Avec ces méthodes, vous pouvez facilement vérifier si une certaine valeur est présente dans la séquence :
    fn main() {
    if (0..=10).contains(&5) {
    println!("Cinq est inclus dans zéro à dix.");
    }
    }

  • Vous pouvez trouver la liste complète des API stabilisées ici
• Dans cette mise à jour, Clippy (c'est un programme qui vérifie votre code pour de nombreuses erreurs) a ajouté une nouvelle vérification pour drop_bounds. Cette vérification se déclenche lorsque vous imposez la contrainte : T: Drop — pour les fonctions génériques :
  fn foo(x: T) {}

  Avoir une contrainte T: Drop est souvent une erreur, car cela exclut immédiatement certains types tels que u8. (Vous pouvez en lire plus là-dessus) ici)

• De nombreuses améliorations et corrections ont été apportées à Cargo (le gestionnaire de paquets du langage). liste complète des modifications

Source : linux.org.ru