Rust 1.37.0 est disponible en version stable et apporte des éléments const non nommés,
ainsi qu'une clé d'exécution par défaut dans Cargo

L'équipe responsable du développement de Rust a annoncé la disponibilité de la version stable Rust 1.37.0. Les points saillants de Rust 1.37.0 incluent les références aux variantes enum via les alias type, le cargo vendor intégré, les éléments const non nommés, l’optimisation guidée par le profil, une clé d’exécution par défaut default - run dans Cargo et #[repr(align(N))] sur des enum.

Faire référence à des variantes enum via des alias type

Avec Rust 1.37.0, vous pouvez maintenant faire référence à des variantes d’énumération via des alias de type. Par exemple:

Code Rust : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
type ByteOption = Option<u8>;
 
fn increment_or_zero(x: ByteOption) -> u8 {
    match x {
        ByteOption::Some(y) => y + 1,
        ByteOption::None => 0,
    }
}

Dans les implémentations, Self agit comme un alias de type. Donc, dans Rust 1.37.0, vous pouvez également faire référence à des variantes enum avec Self :: Variant:

Code Rust : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
impl Coin {
    fn value_in_cents(&self) -> u8 {
        match self {
            Self::Penny => 1,
            Self::Nickel => 5,
            Self::Dime => 10,
            Self::Quarter => 25,
        }
    }
}

Pour être plus précis, Rust vous permet désormais de faire référence à des variantes d’énumération via "résolution relative au type", <MyType <.. >> :: Variant.

Nom : mozillarust.jpg
Affichages : 2176
Taille : 14,9 Ko

Prise en charge intégrée de Cargo pour les dépendances

Après avoir été disponible pendant plusieurs années sous forme de crate distincte, la commande cargo vendor est maintenant intégrée directement à Cargo. La commande extrait toutes les dépendances de votre projet en les décompressant dans le répertoire vendor / et affiche l'extrait de configuration requis pour utiliser le code lors des builds.

Il existe de nombreux cas où cargo vendor est déjà utilisé en production: le compilateur Rust rustc l'utilise pour expédier toutes ses dépendances dans des archives de version, et les projets avec monorepos l'utilisent pour valider le code de ces dépendances dans le contrôle de code source.

Utilisation d'éléments const non nommés pour les macros

Vous pouvez maintenant créer des éléments const non nommés. Au lieu de donner un nom explicite à votre constante, nommez-la simplement _. Par exemple, dans le compilateur rustc, nous trouvons:

Code Rust : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
/// Type size assertion where the first parameter
/// is a type and the second is the expected size.
#[macro_export]
macro_rules! static_assert_size {
    ($ty:ty, $size:expr) => {
        const _: [(); $size] = [(); ::std::mem::size_of::<$ty>()];
        //    ^ Note the underscore here.
    }
}
 
static_assert_size!(Option<Box<String>>, 8); // 1.
static_assert_size!(usize, 8); // 2.

Remarquez le second static_assert_size! (..): grâce à l'utilisation de constantes non nommées, vous pouvez définir de nouveaux éléments sans conflit de nom. Auparavant, vous auriez eu besoin d'écrire static_assert_size! (MON_IDENTIFIANT, usize, 8) ;. Avec Rust 1.37.0, il est maintenant plus facile de créer des macros déclaratives et procédurales ergonomiques et réutilisables à des fins d'analyse statique.

Optimisation guidée par profil

Le compilateur rustc prend désormais en charge l’optimisation guidée par le profil (PGO) par le biais des indicateurs [C]-C profile-generate[/B] et -C profile-use.

L’optimisation guidée par le profil permet au compilateur d’optimiser le code en fonction des commentaires provenant de charges de travail réelles. Cela fonctionne en compilant le programme pour l'optimiser en deux étapes:
  1. Premièrement, le programme est généré avec une instrumentation insérée par le compilateur. Ceci est fait en passant le drapeau -Cprod-generate dans rustc. Le programme instrumenté doit ensuite être exécuté sur des exemples de données et écrit les données de profilage dans un fichier.
  2. Ensuite, le programme est généré à nouveau, cette fois, en ajoutant les données de profilage collectées dans rustc à l'aide de l'indicateur -C profile-use. Cette compilation utilisera les données collectées pour permettre au compilateur de prendre de meilleures décisions concernant le placement du code, l’inclusion et d’autres optimisations.


Choisir un binaire par défaut dans les projets Cargo

Le cycle de chargement est idéal pour tester rapidement les applications CLI. Lorsque plusieurs fichiers binaires sont présents dans le même package, vous devez déclarer explicitement le nom du fichier binaire que vous souhaitez exécuter avec l'indicateur --bin. Cela rend le chargement moins ergonomique que ne le souhaite l'équipe, en particulier lorsqu'un binaire est appelé plus souvent que les autres.

Rust 1.37.0 résout le problème en ajoutant default-run, une nouvelle clé dans Cargo.toml. Lorsque la clé est déclarée dans la section [package], cargo run va se tourner par défaut sur le binaire choisi si l'indicateur --bin n'est pas transmis.

#[repr(align(N))] sur enum

L'attribut #[repr(align(N))] peut être utilisé pour augmenter l'alignement d'une définition de type. Auparavant, l'attribut n'était autorisé que sur les structures et les unions. Avec Rust 1.37.0, l’attribut peut également être utilisé dans les définitions d’énumération. Par exemple, le type suivant Align16 indiquerait, comme prévu, 16 comme étant l'alignement, tandis que l'alignement naturel sans # [repr (align (16))] serait 4 :

Code Rust : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
#[repr(align(16))]
enum Align16 {
    Foo { foo: u32 },
    Bar { bar: u32 },
}

La sémantique de l'utilisation de # [repr (align (N)) sur une énumération est identique à la définition d'une structure d'encapsulation AlignN <T> avec cet alignement, puis à l'utilisation de AlignN <MyEnum>:

Code Rust : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
#[repr(align(N))]
struct AlignN<T>(T);

Source : blog Rust