Opérateurs & Itérateurs Rust

Voici quelques points d'attention autour de Rust, surtout qu'on vient avec des habitudes d'un autre language de programmation.

Opérateurs de Comparaison

Rust est en mode keep it simple pour les opérateurs :

x == y    // Égal
x != y    // Différent
x < y     // Inférieur
x > y     // Supérieur

Pas de <>, ===, ou !== comme dans d'autres langages. Juste == et !=.

Itérateur vs Collection

Au final qu'est-ce qui est itérable :

3..10                    // ✅ Itérateur
["a", "b"]              // ❌ Array (utiliser .iter())
vec!["x", "y"]          // ❌ Vec (utiliser .iter() ou .into_iter())

iter() vs into_iter()

let arr = ["a", "b", "c"];

arr.iter()        // Renvoit des &&str (référence vers référence)
arr.into_iter()   // Renvoit des &str (plus propre, préféré)

Utilise into_iter() pour les arrays - un niveau de référence en moins.

Unicode depuis un Char

let c = '🦀';
let code = c as u32;           // 129408
println!("U+{:04X}", code);   // U+1F980

Qu'est-ce qui a .sort() ?

Seulement les slices mutables :

let mut vec = vec![3, 1, 4];
vec.sort();  // ✅

let mut arr = [3, 1, 4];
arr.sort();  // ✅

// Les itérateurs nécessitent .collect() d'abord
let sorted: Vec<_> = iter.collect().sort();  // ❌
let mut sorted: Vec<_> = iter.collect();     // ✅
sorted.sort();

La raison tient à la forme des données, pas à la syntaxe. Un itérateur est une recette paresseuse, sans longueur ni indices ; trier suppose d'échanger des éléments sur place, donc il faut d'abord une slice possédée, contiguë et mutable :

into() vs into_iter()

Objectifs différents :

"hello".into()           // Conversion de type (&str -> String)
vec![1,2,3].into_iter()  // Crée un itérateur

Rappel : into() convertit les types, into_iter() crée des itérateurs. Donc rien à voir les deux !!