Sortie de Rust 1.78. Le langage Borgo, alliant les forces de Go et Rust

La version 1.78 du langage de programmation général Rust a été publiée, développée à l'origine par le projet Mozilla, mais maintenant sous l'égide de l'organisation à but non lucratif Rust Foundation. Ce langage se concentre sur la gestion sécurisée de la mémoire et fournit des outils pour atteindre un haut degré de parallélisme dans l'exécution des tâches, tout en évitant l'utilisation d'un ramasse-miettes et d'un runtime (le runtime se limite à l'initialisation de base et à l'accompagnement de la bibliothèque standard).

Les méthodes de gestion de la mémoire en Rust éliminent les erreurs lors de la manipulation des pointeurs et protègent contre les problèmes liés à la gestion bas niveau de la mémoire, tels que l'accès à une zone mémoire après sa libération, la déréférence de pointeurs nuls, le dépassement de tampon, etc. Pour faciliter la diffusion des bibliothèques, assurer la compilation et gérer les dépendances, un gestionnaire de paquets nommé Cargo est en développement. Un dépôt pour le déploiement des bibliothèques, crates.io, est également supporté.

La sécurité de la mémoire dans Rust est assurée au moment de la compilation grâce à la vérification des références, au suivi de la propriété des objets, à la prise en compte de la durée de vie des objets (portée) et à l'évaluation de l'accès mémoire pendant l'exécution du code. Rust offre également des outils pour se protéger contre les débordements d'entiers, exige l'initialisation obligatoire des valeurs des variables avant leur utilisation, gère mieux les erreurs dans la bibliothèque standard, applique le concept d'immuabilité (immutable) pour les références et les variables par défaut, et propose une forte typage statique pour minimiser les erreurs logiques.

Les principales nouveautés :

• Un nouvel espace de noms d'attributs «#[diagnostic]» a été proposé, fournissant des moyens d'influencer les messages d'erreur émis par le compilateur. Le premier attribut mis en œuvre dans ce nouvel espace est «#[diagnostic::on_unimplemented]», qui peut être utilisé pour personnaliser les messages d'erreur dans les situations où un trait requis n'est pas implémenté pour un type. #[diagnostic::on_unimplemented( message = «Mon message pour `ImportantTrait<{A}>` n'est pas implémenté pour `{Self}`», label = «Mon label», note = «Note 1», note = «Note 2» )] trait ImportantTrait<A> {} fn use_my_trait(_: impl ImportantTrait<i32>) {} fn main() { use_my_trait(String::new()); } error[E0277]: Mon message pour `ImportantTrait<i32>` n'est pas implémenté pour `String` —> src/main.rs:12:18 | 12 | use_my_trait(String::new()); | ———— ^^^^^^^^^^^^^ Mon label | | | requis par une contrainte introduite par cet appel | = aide : le trait `ImportantTrait<i32>` n'est pas implémenté pour `String` = note : Note 1 = note : Note 2
• Les assertions préliminaires appliquées aux fonctions unsafe peuvent maintenant être retardées jusqu'à la phase de génération de code, ce qui permet d'effectuer ces vérifications sans nécessiter la compilation de la bibliothèque standard en mode «#[cfg(debug_assertions)]». Pour que les vérifications soient déclenchées, il suffit d'activer les assertions de débogage pour les constructions de test ou de débogage de votre code.
• Le comportement des fonctions de la bibliothèque standard affectant l'alignement des pointeurs et des tranches est maintenant prévisible à l'exécution et dépend des données d'entrée. La fonction pointer::align_offset, qui calcule le décalage pour l'alignement d'un pointeur, renvoie maintenant usize::MAX uniquement lorsque l'opération ne peut pas être effectuée. Les fonctions slice::align_to et slice::align_to_mut, qui convertissent des tranches en une représentation avec un moyen aligné et des tranches de début et de fin originales, renvoient désormais toujours la plus grande partie moyenne.
• Ont été promus au statut stable :
  • impl Read for &Stdin
  • L'utilisation d'une durée de vie non statique (non ‘static) est autorisée pour certaines implémentations liées à std::error::Error.
  • Dans l'implémentation impl<Fd: AsFd>, l'utilisation de la valeur ?Sized est autorisée.
  • impl From<TryReserveError> pour io::Error
• La fonction Barrier::new() a été stabilisée pour être utilisée avec le préfixe «const» dans n'importe quel contexte au lieu d'une constante.
• Pour les plateformes cibles x86_64-pc-windows-msvc, i686-pc-windows-msvc, x86_64-pc-windows-gnu, i686-pc-windows-gnu, x86_64-pc-windows-gnullvm et i686-pc-windows-gnullvm, la version minimale de Windows 10 est désormais requise.
• Le troisième niveau de support a été mis en œuvre pour les plateformes wasm32-wasip2, arm64ec-pc-windows-msvc, armv8r-none-eabihf et loongarch64-unknown-linux-musl. Le troisième niveau implique un support de base, mais sans tests automatisés, publication de versions officielles et vérification de la possibilité de compiler le code.
• Le deuxième niveau de support pour la plateforme cible Add wasm32-wasip1 a été mis en œuvre. Le deuxième niveau de support implique une garantie de compilation.
• La plateforme wasm32-wasi-preview1-threads a été renommée en wasm32-wasip1-threads.
• Le compilateur a été mis à jour pour utiliser LLVM 18. Avec LLVM 18, l'ABI liée aux types u128 et i128 a été modifiée pour les architectures x86-32 et x86-64.
• Dans le gestionnaire de paquets Cargo, la version 4 des fichiers de verrouillage (lockfile v4) a été stabilisée.
• Dans Cargo, le cache global contenant des informations sur la dernière utilisation des données a été stabilisé. Le cache est placé dans le fichier $CARGO_HOME/.global-cache à l'aide de SQLite, il se met à jour automatiquement et reflète les dernières modifications liées à l'index, au fichier crate, au répertoire de code, au git clone et au git checkout.

On peut également mentionner le langage de programmation Borgo, qui essaie d'être plus expressif que le langage Go, mais moins complexe que le langage Rust. Borgo combine les meilleures caractéristiques de Go et Rust, comblant les lacunes de chacun des langages. Par exemple, le langage Go est simple et compréhensible, mais ne fournit pas d'outils avancés pour garantir la sécurité lors de la manipulation des types. Le langage Rust offre des moyens pour une programmation sécurisée, mais est trop complexe. Le projet est développé par Marco Sampellegrini, auteur du livre « The Simple Haskell Handbook » et développeur du système d'intégration continue Quad CI.

Borgo utilise une typage statique, des types similaires à ceux du langage Go et une syntaxe semblable à Rust. La spécification des points-virgules à la fin des lignes de code en Borgo n'est pas obligatoire. Le code en Borgo est compilé en une représentation en Go, totalement compatible avec les paquets existants pour Go. Le code du compilateur est écrit en Rust et est distribué sous la licence ISC. use fmt enum NetworkState { Loading, Failed(int), Success(T), } struct Response { title: string, duration: int, } fn main() { let res = Response { title: «Hello world», duration: 0, } let state = NetworkState.Success(res) let msg = match state { NetworkState.Loading => «chargement en cours», NetworkState.Failed(code) => fmt.Sprintf(«Erreur de code : %d», code), NetworkState.Success(res) => res.title, } fmt.Println(msg) }

Source : opennet.ru