Rust est un langage de programmation système moderne conçu pour la performance, la sécurité et la concurrence. Il offre aux utilisateurs des fonctionnalités puissantes tout en s'efforçant d'éliminer les erreurs de programmation courantes, telles que les déréférencements de pointeurs nuls et les courses de données. Rust met l'accent sur des abstractions sans coût, permettant aux développeurs d'écrire du code de haut niveau sans sacrifier la performance. Il est particulièrement bien adapté aux tâches nécessitant un contrôle de bas niveau sur le matériel et la gestion de la mémoire, telles que la programmation système, le WebAssembly et la création d'applications haute performance.
Rust a été conçu en 2006 par Graydon Hoare chez Mozilla Research. L'objectif initial du langage était de relever les défis du développement de logiciels concurrents sûrs et de créer une alternative plus fiable aux langages de programmation système existants. En 2010, la première version publique de Rust a été publiée et a rapidement attiré l'attention pour son approche innovante de la sécurité mémoire et de la concurrence.
Rust s'inspire de plusieurs langages de programmation, tels que C++ pour son design orienté performance et les langages de programmation fonctionnelle pour son accent sur l'immuabilité et les abstractions puissantes. Son design reflète également des principes de langages comme Haskell, notamment dans son système de types robuste et ses capacités de correspondance de motifs.
Depuis sa création, Rust a mûri pour devenir un langage largement reconnu, avec une forte communauté de développeurs et un écosystème de bibliothèques en croissance. Le langage est officiellement soutenu par Mozilla et a gagné en popularité dans divers domaines, y compris le développement web, les systèmes embarqués et le développement de jeux. La sortie de Rust 1.0 en 2015 a marqué une étape importante, consolidant sa stabilité et sa préparation pour une utilisation en production. La Rust Foundation, établie en 2021, soutient son développement continu et sa gouvernance.
Le modèle de propriété unique de Rust permet aux développeurs de gérer la mémoire sans un ramasse-miettes. Chaque variable en Rust a un seul propriétaire, et la propriété peut être transférée ou "empruntée" par le biais de références. Cette fonctionnalité aide à garantir la sécurité mémoire en imposant des règles d'emprunt strictes.
fn main() {
let s1 = String::from("Bonjour");
let s2 = &s1; // Emprunt de s1
println!("{}", s2);
}
La correspondance de motifs en Rust permet aux développeurs de déstructurer des types de données et de gérer le flux de contrôle complexe de manière fluide. L'instruction match fournit un moyen puissant de ramifier la logique en fonction des motifs de valeur.
fn main() {
let number = 4;
match number {
1 => println!("Un"),
2 => println!("Deux"),
_ => println!("Autre"),
}
}
Rust utilise l'inférence de types, permettant au compilateur de déduire automatiquement les types de variables, ce qui simplifie le code et améliore la lisibilité.
fn main() {
let x = 5; // Le compilateur infère que x est de type i32
}
Les traits sont similaires aux interfaces dans d'autres langages et permettent le polymorphisme. Ils définissent un comportement partagé que les types peuvent implémenter.
trait Speak {
fn speak(&self);
}
struct Dog;
impl Speak for Dog {
fn speak(&self) {
println!("Ouaf !");
}
}
Les types Option et Result de Rust fournissent une gestion des erreurs robuste et des paradigmes de programmation sûrs pour les valeurs nulles, permettant aux développeurs d'exprimer explicitement la possibilité d'absence ou d'erreur.
fn divide(x: f64, y: f64) -> Option<f64> {
if y == 0.0 {
None
} else {
Some(x / y)
}
}
Rust prend en charge la concurrence sans crainte grâce à son système de propriété, permettant à plusieurs threads d'opérer sur des données avec un risque minimal de courses de données.
use std::thread;
fn main() {
let handle = thread::spawn(|| {
println!("Bonjour depuis un thread !");
});
handle.join().unwrap();
}
Le système de macros de Rust permet la génération de code, rendant possible l'écriture de constructions syntaxiques personnalisées pouvant être réutilisées dans l'ensemble du code.
macro_rules! say_hello {
() => {
println!("Bonjour !");
};
}
fn main() {
say_hello!();
}
Les closures en Rust sont des fonctions anonymes qui peuvent capturer des variables de leur environnement, les rendant flexibles pour les paradigmes de programmation fonctionnelle.
fn main() {
let add = |a, b| a + b;
println!("{}", add(5, 7));
}
Rust utilise un système de modules pour organiser le code et contrôler la visibilité. Les crates sont des paquets de code Rust qui peuvent être partagés et réutilisés.
mod my_module {
pub fn hello() {
println!("Bonjour depuis my_module !");
}
}
fn main() {
my_module::hello();
}
Rust dispose de fonctionnalités de documentation intégrées, et l'outil Rustdoc génère automatiquement la documentation à partir des commentaires dans le code source.
/// Cette fonction additionne deux nombres.
///
/// # Exemples
///
/// ```
/// let result = add(2, 3);
/// assert_eq!(result, 5);
/// ```
fn add(a: i32, b: i32) -> i32 {
a + b
}
Rust dispose d'un ensemble riche d'outils pour les développeurs, y compris son gestionnaire de paquets, Cargo, qui facilite la gestion des dépendances, la construction et la publication de bibliothèques et d'applications. La bibliothèque standard de Rust fournit un support d'exécution abondant pour diverses tâches.
Plusieurs IDE et éditeurs prennent en charge le développement Rust, notamment :
Pour créer un nouveau projet Rust, les développeurs peuvent utiliser Cargo avec la commande suivante :
cargo new my_project
Cette commande génère un nouveau répertoire contenant une structure de projet Rust de base. Pour construire le projet, il suffit de naviguer vers le répertoire du projet et d'exécuter :
cargo build
Rust est utilisé dans divers domaines en raison de ses caractéristiques de performance et de sécurité. Les applications clés incluent :
Rust est souvent comparé à d'autres langages de programmation système en raison de son accent sur la performance et la sécurité. Voici quelques comparaisons :
La traduction de code Rust vers d'autres langages peut être difficile en raison de son modèle de propriété unique et de ses fonctionnalités avancées. Cependant, certains outils facilitent les traductions source-à-source, tels que :