Operatori di Comparazione in Rust

Gli operatori di comparazione in Rust permettono di confrontare valori e restituiscono un bool. Sono implementati tramite i trait PartialEq, Eq, PartialOrd e Ord.

Operatori Disponibili

Operatore	Descrizione	Trait
==	Uguale a	PartialEq
!=	Diverso da	PartialEq
<	Minore di	PartialOrd
>	Maggiore di	PartialOrd
<=	Minore o uguale	PartialOrd
>=	Maggiore o uguale	PartialOrd

Confronto tra Tipi Primitivi

fn main() {
    let a = 10;
    let b = 20;

    println!("{}", a == b);  // false
    println!("{}", a != b);  // true
    println!("{}", a < b);   // true
    println!("{}", a > b);   // false
    println!("{}", a <= 10); // true
    println!("{}", a >= 20); // false
}

Confronto tra Stringhe

fn main() {
    let s1 = "abc";
    let s2 = "abd";

    println!("{}", s1 == s2);   // false
    println!("{}", s1 < s2);    // true (confronto lessicografico)
    println!("{}", "A" < "a");  // true (A=65, a=97)

    let owned: String = String::from("ciao");
    println!("{}", owned == "ciao"); // true - String si confronta con &str
}

PartialEq e Eq

PartialEq permette confronti di uguaglianza parziali (non tutti i valori sono confrontabili, come f64::NAN). Eq garantisce uguaglianza totale.

// f64 implementa PartialEq ma NON Eq
let nan = f64::NAN;
println!("{}", nan == nan); // false! NaN non è uguale a se stesso

// i32 implementa sia PartialEq che Eq
let x: i32 = 5;
println!("{}", x == x); // true, sempre

Derivare PartialEq per Struct

#[derive(PartialEq, Debug)]
struct Punto {
    x: f64,
    y: f64,
}

fn main() {
    let p1 = Punto { x: 1.0, y: 2.0 };
    let p2 = Punto { x: 1.0, y: 2.0 };
    let p3 = Punto { x: 3.0, y: 4.0 };

    println!("{}", p1 == p2); // true
    println!("{}", p1 != p3); // true
}

PartialOrd e Ord

#[derive(PartialEq, PartialOrd)]
struct Voto {
    punteggio: f64,
}

fn main() {
    let v1 = Voto { punteggio: 8.5 };
    let v2 = Voto { punteggio: 9.0 };

    println!("{}", v1 < v2);  // true
    println!("{}", v1 > v2);  // false
}

Implementazione Manuale

use std::cmp::Ordering;

struct Studente {
    nome: String,
    media: f64,
}

impl PartialEq for Studente {
    fn eq(&self, other: &Self) -> bool {
        self.media == other.media
    }
}

impl PartialOrd for Studente {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        self.media.partial_cmp(&other.media)
    }
}

Conclusione

Gli operatori di comparazione in Rust sono basati su trait, rendendo il sistema estensibile e type-safe. La distinzione tra Partial e totale (Eq/Ord) gestisce correttamente casi come i numeri floating-point con NaN. Usa #[derive] per generare automaticamente le implementazioni sui tuoi tipi personalizzati.