Operatori Logici in Rust

Gli operatori logici in Rust operano su valori booleani (bool) e restituiscono un valore booleano. Sono fondamentali per costruire condizioni complesse.

Operatori Disponibili

Operatore	Nome	Descrizione
&&	AND logico	Vero se entrambi sono veri
||	OR logico	Vero se almeno uno è vero
!	NOT logico	Inverte il valore booleano

AND Logico (&&)

fn main() {
    let eta = 25;
    let ha_patente = true;

    if eta >= 18 && ha_patente {
        println!("Puoi guidare");
    }

    println!("{}", true && true);   // true
    println!("{}", true && false);  // false
    println!("{}", false && true);  // false
    println!("{}", false && false); // false
}

OR Logico (||)

fn main() {
    let giorno = "sabato";

    if giorno == "sabato" || giorno == "domenica" {
        println!("È weekend!");
    }

    println!("{}", true || false);  // true
    println!("{}", false || true);  // true
    println!("{}", false || false); // false
}

NOT Logico (!)

fn main() {
    let attivo = false;

    if !attivo {
        println!("L'utente non è attivo");
    }

    println!("{}", !true);  // false
    println!("{}", !false); // true
}

Valutazione Short-Circuit

Rust utilizza la valutazione a corto circuito: il secondo operando non viene valutato se il risultato è determinabile dal primo.

fn controllo_lento() -> bool {
    println!("Funzione chiamata!");
    true
}

fn main() {
    // controllo_lento() NON viene chiamata
    if false && controllo_lento() {
        println!("Non raggiungibile");
    }

    // controllo_lento() NON viene chiamata
    if true || controllo_lento() {
        println!("Sempre raggiungibile");
    }
}

Combinare Condizioni

fn puo_iscriversi(eta: u32, ha_documenti: bool, ha_acconto: bool) -> bool {
    eta >= 18 && (ha_documenti || ha_acconto)
}

Precedenza: ! > && > ||. Usa le parentesi per rendere esplicito l’ordine.

Operatori Logici con Pattern Matching

fn classifica_numero(n: i32) -> &'static str {
    if n > 0 && n % 2 == 0 {
        "positivo e pari"
    } else if n > 0 && n % 2 != 0 {
        "positivo e dispari"
    } else if n == 0 {
        "zero"
    } else {
        "negativo"
    }
}

Conclusione

Gli operatori logici in Rust funzionano esclusivamente con il tipo bool — non esiste conversione implicita da altri tipi. La valutazione short-circuit è garantita dal linguaggio, rendendo sicuro l’uso di espressioni come vec.len() > 0 && vec[0] == 1.