IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Rust Discussion :

Rust 1.54 est disponible et vient étendre la connexion du langage à WebAssembly


Sujet :

Rust

  1. #1
    Chroniqueur Actualités

    Homme Profil pro
    Administrateur de base de données
    Inscrit en
    mars 2013
    Messages
    6 311
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations professionnelles :
    Activité : Administrateur de base de données

    Informations forums :
    Inscription : mars 2013
    Messages : 6 311
    Points : 154 514
    Points
    154 514
    Par défaut Rust 1.54 est disponible et vient étendre la connexion du langage à WebAssembly
    Rust 1.54 est disponible. Cette version vient étendre la connexion du langage à WebAssembly,
    et permet l'utilisation de macros dans les attributs

    La dernière version du langage de programmation Rust est maintenant disponible. Rust 1.54 introduit quelques nouvelles fonctionnalités stables. La nouvelle version intègre deux innovations notables, qui concernent d'une part WebAssembly en tant que plateforme cible et d'autre part l'utilisation de macros dans les attributs. Elle s'accompagne également de la stabilisation de certaines API et implémentations des traits, en particulier dans les collections standard.

    Pour mémoire, un trait est un agrégat de méthodes définies pour un type inconnu : Self. Elles peuvent accéder aux autres méthodes déclarées dans le même trait. Les traits peuvent être implémentés pour n'importe quel type de donnée. Dans l'exemple ci-dessous, nous définissons Animal, un groupe de méthodes. Le trait Animal est alors implémenté pour le type Sheep, permettant l'utilisation des méthodes de Animal avec une instance du type Sheep.

    Code Rust : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    struct Sheep { naked: bool, name: &'static str } 
     
    trait Animal { 
        // Méthode statique; `Self` fait référence au type ayant implémenté  
        // le trait. 
        fn new(name: &'static str) -> Self; 
     
        // Méthode d'instance; Elles renverront une chaîne de caractères. 
        fn name(&self) -> &'static str; 
        fn noise(&self) -> &'static str; 
     
        // Les traits peuvent fournir une implémentation par défaut. 
        fn talk(&self) { 
            println!("{} says {}", self.name(), self.noise()); 
        } 
    } 
     
    impl Sheep { 
        fn is_naked(&self) -> bool { 
            self.naked 
        } 
     
        fn shear(&mut self) { 
            if self.is_naked() { 
                // Les méthodes de `Self` peuvent utiliser les méthodes déclarées  
                // par le trait. 
                println!("{} is already naked...", self.name()); 
            } else { 
                println!("{} gets a haircut!", self.name); 
     
                self.naked = true; 
            } 
        } 
    } 
     
    // Implémentation des services du trait `Animal`  
    // pour le type `Sheep`. 
    impl Animal for Sheep { 
        // En l'occurrence, `Self` fait référence à `Sheep`. 
        fn new(name: &'static str) -> Sheep { 
            Sheep { name: name, naked: false } 
        } 
     
        fn name(&self) -> &'static str { 
            self.name 
        } 
     
        fn noise(&self) -> &'static str { 
            if self.is_naked() { 
                "baaaaah?" 
            } else { 
                "baaaaah!" 
            } 
        } 
     
        // L'implémentation par défaut fournie par le trait  
        // peut être réécrite. 
        fn talk(&self) { 
            // Par exemple, nous pourrions fournir une description plus précise. 
            println!("{} pauses briefly... {}", self.name, self.noise()); 
        } 
    } 
     
    fn main() { 
        // Typer l'identificateur est nécessaire dans ce cas de figure. 
        let mut dolly: Sheep = Animal::new("Dolly"); 
        // TODO ^ Essayez de supprimer le type annoté. 
     
        dolly.talk(); 
        dolly.shear(); 
        dolly.talk(); 
    }

    Il n'est guère surprenant que les innovations soient plutôt gérables : l'équipe se concentre actuellement principalement sur la prochaine édition de Rust 2021, qui devrait paraître avec l'avant-dernière version le 21 octobre. La phase de test public pour la troisième édition après Rust 2015 et Rust 2018 a récemment commencé.

    Les attributs peuvent invoquer des macros de type fonction

    Rust 1.54 prend en charge l'invocation de macros de type fonction dans les attributs. Les macros de type fonction peuvent être soit des macros basées sur macro_rules !, soit des macros procédurales qui sont invoquées comme macro!(...). Un cas d'utilisation notable pour cela est l'inclusion de la documentation d'autres fichiers dans les commentaires de la documentation Rust. Par exemple, si le fichier README de votre projet représente un bon commentaire de documentation, vous pouvez utiliser include_str ! pour incorporer directement le contenu. Auparavant, diverses solutions de contournement autorisaient des fonctionnalités similaires, mais à partir de Rust 1.54, les choses sont beaucoup plus ergonomiques.

    Code Rust : Sélectionner tout - Visualiser dans une fenêtre à part
    #![doc = include_str!("README.md")]

    Des macros peuvent également être imbriquées dans l'attribut, par exemple pour inclure du contenu généré par un script de build :

    Code Rust : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    #[path = concat!(env!("OUT_DIR"), "/generated.rs")]
    mod generated;

    Syntaxe acceptée : L'analyseur accepte les expressions Rust arbitraires dans cette position, mais toute expression autre qu'une invocation de macro conduira finalement à une erreur car elle n'est pas attendue par les formes d'expression intégrées (par exemple, #[doc]). Notez que les décorateurs et autres peuvent être en mesure d'observer d'autres formes d'expression.

    Nom : rust.png
Affichages : 2971
Taille : 10,6 Ko

    La compilation incrémentielle est réactivée par défaut

    La compilation incrémentielle a été réactivée par défaut dans cette version, après avoir été désactivée par défaut dans la 1.52.1.

    Dans Rust 1.52, une validation supplémentaire a été ajoutée lors du chargement des données de compilation incrémentielle à partir du cache sur disque. Cela a entraîné la découverte d'un certain nombre de problèmes potentiels préexistants, car la validation a transformé ces bogues silencieux en erreurs de compilateur internes (ICE - Internal Compiler Errors). En réponse, l'équipe de compilation a décidé de désactiver la compilation incrémentielle dans le correctif 1.52.1, permettant aux utilisateurs d'éviter de rencontrer les ICE et les problèmes sous-jacents, au détriment de temps de compilation plus longs.

    Depuis lors, les responsables du développement de Rust ont mené une série de rétrospectives et les contributeurs ont travaillé dur pour résoudre les problèmes signalés, certains correctifs arrivant dans la 1.53 et la majorité dans cette version.

    Il existe actuellement encore deux problèmes connus qui peuvent entraîner un ICE. En raison de l'absence de rapports de plantage automatisés, les responsables indiquent ne pas être en mesure de déterminer l'ampleur de l'impact des problèmes en suspens. Cependant, sur la base des commentaires qu'ils ont reçus des utilisateurs concernés par la version 1.52, ils pensent que les problèmes restants sont rares dans la pratique.

    Par conséquent, la compilation incrémentielle a été réactivée dans cette version !

    Stabilisation des fonctions intégrées wasm32

    Une autre nouveauté est la migration de certaines fonctions intégrées sur la plateforme wasm32 vers des versions stables.

    La version actuelle stabilise certaines fonctions intrinsèques de la plateforme wasm32 avec lesquelles les instructions SIMD (Single Instruction, Multiple Data) peuvent être implémentées. Cela signifie que pour la plupart des fonctions intrinsèques, wasm32. Contrairement aux fonctions intégrées x86 et x86_64 déjà stabilisées, elles n'ont pas d'exigences de sécurité qui ne peuvent être appelées que si les fonctionnalités de ciblage appropriées sont activées. En effet, WebAssembly valide le code en toute sécurité avant l'exécution, garantissant que les instructions sont décodées correctement ou pas du tout.

    Certaines fonctions telles que v128_bitselect sont donc considérées comme des fonctions sûres. D'autres cependant, comme v128_load, sont déclarées comme n'étant pas sûres car elles utilisent des pointeurs bruts.

    API stabilisées

    Les méthodes et implémentations de traits suivantes ont été stabilisées :
    • BTreeMap::into_keys
    • BTreeMap::into_values
    • HashMap::into_keys
    • HashMap::into_values
    • arch::wasm32
    • VecDeque::binary_search
    • VecDeque::binary_search_by
    • VecDeque::binary_search_by_key
    • VecDeque::partition_point

    Source : blog Rust

    Voir aussi :

    Le projet Tor envisage de remplacer sa base de code C « complexe et fragile » par du Rust dans le cadre du projet Arti : le langage C est-il adapté à la création d'applications sécurisées ?
    Les derniers correctifs du projet Rust for Linux montrent que le langage Rust avance à grands pas vers le noyau, Torvalds estime que cela pourrait être prêt pour la version 5.14
    Projet Protissimo : l'Internet Security Research Group veut sécuriser la mémoire du noyau Linux avec Rust et fournit au dev Miguel Ojeda un contrat d'un an pour travailler dessus à plein temps
    Le créateur de Python, Guido van Rossum, dit ce qu'il pense de Rust, Go, Julia et TypeScript et relève des similitudes entre ces langages et Python
    Contribuez au club : Corrections, suggestions, critiques, ... : Contactez le service news et Rédigez des actualités

  2. #2
    Expert éminent sénior Avatar de Uther
    Homme Profil pro
    Inscrit en
    avril 2002
    Messages
    4 289
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Pyrénées Orientales (Languedoc Roussillon)

    Informations forums :
    Inscription : avril 2002
    Messages : 4 289
    Points : 12 876
    Points
    12 876
    Par défaut
    Il y a un point intéressant qui n'est pas précisé dans le blog : les optimisation basées sur les information d'alias des pointeurs ont été réactivées. Ils ne l'ont probablement pas précisé au cas où, car les fois précédentes, ils avaient du les retirer suite a des bugs de LLVM, mais ça pourrait permettre a Rust d'augmenter légèrement ses performances par rapport à un code C ou C++ équivalent.

  3. #3
    Modérateur
    Avatar de Gugelhupf
    Homme Profil pro
    Analyste Programmeur
    Inscrit en
    décembre 2011
    Messages
    1 308
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Analyste Programmeur

    Informations forums :
    Inscription : décembre 2011
    Messages : 1 308
    Points : 3 633
    Points
    3 633
    Billets dans le blog
    12
    Par défaut
    On peut créer un fn new() -> Self dans les traits maintenant ? C'est depuis quelle version ?
    N'hésitez pas à consulter la FAQ Java, lire les cours et tutoriels Java, et à poser vos questions sur les forums d'entraide Java

    Ma page Developpez | Mon profil Linkedin | Vous souhaitez me contacter ? Contacter Gokan EKINCI

  4. #4
    Nouveau membre du Club
    Profil pro
    Développeur
    Inscrit en
    octobre 2008
    Messages
    8
    Détails du profil
    Informations personnelles :
    Localisation : Canada

    Informations professionnelles :
    Activité : Développeur

    Informations forums :
    Inscription : octobre 2008
    Messages : 8
    Points : 36
    Points
    36
    Par défaut
    Citation Envoyé par Gugelhupf Voir le message
    On peut créer un fn new() -> Self dans les traits maintenant ? C'est depuis quelle version ?
    Pas certains depuis quand, mais je peux te dire que ca fait un moment quand meme (genre au moins un an/deux ans au moins)

  5. #5
    Expert éminent sénior Avatar de Uther
    Homme Profil pro
    Inscrit en
    avril 2002
    Messages
    4 289
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Pyrénées Orientales (Languedoc Roussillon)

    Informations forums :
    Inscription : avril 2002
    Messages : 4 289
    Points : 12 876
    Points
    12 876
    Par défaut
    Citation Envoyé par Gugelhupf Voir le message
    On peut créer un fn new() -> Self dans les traits maintenant ? C'est depuis quelle version ?
    Depuis toujours il me semble. Du moins, depuis la version 1.0, sortie il y a plus de 6 ans, au minimum.

  6. #6
    Expert confirmé

    Homme Profil pro
    Développeur .NET
    Inscrit en
    novembre 2010
    Messages
    2 040
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Rhône (Rhône Alpes)

    Informations professionnelles :
    Activité : Développeur .NET

    Informations forums :
    Inscription : novembre 2010
    Messages : 2 040
    Points : 4 147
    Points
    4 147
    Par défaut
    Un trait c'est similaire à une interface dans d'autre langage on dirait

  7. #7
    Expert éminent sénior Avatar de Uther
    Homme Profil pro
    Inscrit en
    avril 2002
    Messages
    4 289
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Pyrénées Orientales (Languedoc Roussillon)

    Informations forums :
    Inscription : avril 2002
    Messages : 4 289
    Points : 12 876
    Points
    12 876
    Par défaut
    En effet c'est assez similaire a ce qu'on appelle une interface en Java. Une différence principale par rapport a java est que l'implémentation du trait par un type peut avoir lieu aussi bien au niveau du trait lui même que dans le type implémenté.

    En Rust ou il n'y a pas une hiérarchie des classes comme en Java, la notion de trait est d'autant plus importante. C'est ce qui sert de base aux systèmes de polymorphisme et de type génériques.

Discussions similaires

  1. Réponses: 0
    Dernier message: 20/12/2019, 09h16
  2. La version stable de Rust 1.24 est disponible
    Par Olivier Famien dans le forum Rust
    Réponses: 0
    Dernier message: 16/02/2018, 13h01
  3. Réponses: 0
    Dernier message: 13/10/2017, 12h56
  4. Rust 1.19 est disponible en version stable
    Par Hinault Romaric dans le forum Rust
    Réponses: 45
    Dernier message: 21/07/2017, 08h25

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo