`Ord::max` în Rust

Returnează cea mai mare (max) sau cea mai mică (min) dintre două valori ale unui tip Ord.

Sintaxă

fn max(self, other: Self) -> Self
fn min(self, other: Self) -> Self

Ce face `Ord::max`

a.max(b) și a.min(b) funcționează pe orice tip Ord: numere întregi, texte, char, tupluri, tipuri proprii. Ambele valori sunt primite prin valoare (sunt mutate), iar cea aleasă este returnată. Există și formele de funcție std::cmp::max(a, b) și std::cmp::min(a, b).

La egalitate, max returnează al doilea argument, iar min pe primul. Contează doar când valorile egale diferă prin ceva ce nu intră în comparație. Pentru f64, care nu este Ord, se folosesc metodele proprii f64::max și f64::min.

Parametri

Parametru	Descriere
`other`	A doua valoare, de același tip.

Ce returnează

Una dintre cele două valori.

Exemple

Exemplul 1: Numere, texte și tupluri

use std::cmp;

fn main() {
    println!("{}", 7.max(12));
    println!("{}", 7.min(12));
    println!("{}", "Iași".max("Cluj"));
    println!("{:?}", (2, "b").max((2, "a")));
    println!("{}", cmp::max(-3, -8));
    println!("{}", 2.5_f64.max(1.5));   // metoda proprie lui f64
}

Rezultat

12
7
Iași
(2, "b")
-3
2.5

Exemplul 2: Care valoare se întoarce la egalitate

Comparația folosește doar nota, deci Ana și Radu sunt „egali”. max îl alege pe al doilea, min pe primul.

use std::cmp::Ordering;

#[derive(Debug)]
struct Elev {
    nume: &'static str,
    nota: u8,
}

impl PartialEq for Elev {
    fn eq(&self, o: &Self) -> bool { self.nota == o.nota }
}
impl Eq for Elev {}
impl PartialOrd for Elev {
    fn partial_cmp(&self, o: &Self) -> Option<Ordering> { Some(self.cmp(o)) }
}
impl Ord for Elev {
    fn cmp(&self, o: &Self) -> Ordering { self.nota.cmp(&o.nota) }
}

fn main() {
    let a = || Elev { nume: "Ana", nota: 9 };
    let r = || Elev { nume: "Radu", nota: 9 };
    println!("max: {}", a().max(r()).nume);
    println!("min: {}", a().min(r()).nume);
    println!("{:?}", Elev { nume: "Ioana", nota: 10 }.max(a()));
}