Rustで学ぶ！トレイトを活用した型の比較処理実装例

trait ExampleTrait {
    fn example_method(&self);
}

fn cmp(&self, other: &Self) -> std::cmp::Ordering;

fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering>;
fn lt(&self, other: &Self) -> bool;
fn le(&self, other: &Self) -> bool;
fn gt(&self, other: &Self) -> bool;
fn ge(&self, other: &Self) -> bool;

use std::cmp::Ordering;

#[derive(Eq, PartialEq)]
struct Point {
    x: i32,
    y: i32,
}

impl Ord for Point {
    fn cmp(&self, other: &Self) -> Ordering {
        // x座標を優先し、同じ場合はy座標を比較
        self.x.cmp(&other.x).then_with(|| self.y.cmp(&other.y))
    }
}

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

fn cmp(&self, other: &Self) -> Ordering {
    self.x.cmp(&other.x).then_with(|| self.y.cmp(&other.y))
}

fn main() {
    let mut points = vec![
        Point { x: 2, y: 3 },
        Point { x: 1, y: 4 },
        Point { x: 2, y: 1 },
    ];

    points.sort(); // xで昇順、次にyで昇順にソート
    for point in points {
        println!("Point({}, {})", point.x, point.y);
    }
}

Point(1, 4)  
Point(2, 1)  
Point(2, 3)

use std::cmp::Ordering;

#[derive(Debug, PartialEq)]
struct Temperature {
    value: f32, // 温度値（摂氏）
}

impl PartialOrd for Temperature {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        if self.value.is_nan() || other.value.is_nan() {
            None // NaNの場合は比較不可能
        } else {
            self.value.partial_cmp(&other.value)
        }
    }
}

fn main() {
    let temp1 = Temperature { value: 36.5 };
    let temp2 = Temperature { value: 37.0 };
    let temp3 = Temperature { value: f32::NAN };

    println!("{:?}", temp1 < temp2); // true
    println!("{:?}", temp1 > temp3); // false (比較不可能)
}

true  
false  

use std::cmp::Ordering;

#[derive(Debug, Eq, PartialEq)]
struct Student {
    name: String,
    score: i32,
}

impl Ord for Student {
    fn cmp(&self, other: &Self) -> Ordering {
        // 成績（score）で比較、同点の場合は名前で比較
        self.score.cmp(&other.score).reverse() // 高得点が先
            .then_with(|| self.name.cmp(&other.name))
    }
}

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

fn main() {
    let mut students = vec![
        Student { name: "Alice".to_string(), score: 90 },
        Student { name: "Bob".to_string(), score: 95 },
        Student { name: "Charlie".to_string(), score: 90 },
    ];

    students.sort(); // `Ord` に基づいてソート
    for student in students {
        println!("{:?}", student);
    }
}

Student { name: "Bob", score: 95 }  
Student { name: "Alice", score: 90 }  
Student { name: "Charlie", score: 90 }

use std::collections::BTreeSet;

fn main() {
    let mut set = BTreeSet::new();
    set.insert(Student { name: "Alice".to_string(), score: 85 });
    set.insert(Student { name: "Bob".to_string(), score: 90 });

    for student in set {
        println!("{:?}", student);
    }
}

impl PartialEq for MyType {
    fn eq(&self, other: &Self) -> bool {
        self.value % 2 == other.value % 2 // 偶奇のみを考慮
    }
}

impl Ord for MyType {
    fn cmp(&self, other: &Self) -> Ordering {
        self.value.cmp(&other.value) // 値そのものを比較
    }
}

fn main() {
    let x = f64::NAN;
    let y = 1.0;
    println!("{:?}", x > y); // 予期しない動作
}

impl PartialOrd for MyType {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        if self.value.is_nan() || other.value.is_nan() {
            None
        } else {
            self.value.partial_cmp(&other.value)
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_sorting() {
        let mut items = vec![
            MyType { value: 3 },
            MyType { value: 1 },
            MyType { value: 2 },
        ];
        items.sort(); // ソートロジックを検証
        assert_eq!(items, vec![
            MyType { value: 1 },
            MyType { value: 2 },
            MyType { value: 3 },
        ]);
    }
}

impl Ord for MyType {
    fn cmp(&self, other: &Self) -> Ordering {
        self.primary_key.cmp(&other.primary_key)
            .then_with(|| self.secondary_key.cmp(&other.secondary_key))
    }
}

struct MyType {
    value: i32,
    cached_result: Option<Ordering>,
}

impl MyType {
    fn expensive_computation(&self) -> Ordering {
        // 高コストな計算
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_ordering() {
        let student1 = Student { name: "Alice".to_string(), score: 90 };
        let student2 = Student { name: "Bob".to_string(), score: 95 };
        let student3 = Student { name: "Charlie".to_string(), score: 90 };

        // 比較結果を直接テスト
        assert!(student2 > student1);
        assert!(student1 == student3);
        assert!(student1 < student2);
    }

    #[test]
    fn test_sorting() {
        let mut students = vec![
            Student { name: "Alice".to_string(), score: 90 },
            Student { name: "Bob".to_string(), score: 95 },
            Student { name: "Charlie".to_string(), score: 90 },
        ];

        students.sort(); // `Ord` に基づくソート
        let sorted_names: Vec<_> = students.iter().map(|s| &s.name).collect();
        assert_eq!(sorted_names, vec!["Bob", "Alice", "Charlie"]);
    }
}

#[test]
fn test_partial_cmp() {
    let temp1 = Temperature { value: 36.5 };
    let temp2 = Temperature { value: f32::NAN };

    assert!(temp1.partial_cmp(&temp2).is_none()); // NaNの場合
    assert!(temp2.partial_cmp(&temp1).is_none());
}

#[test]
fn test_negative_values() {
    let val1 = MyType { value: -10 };
    let val2 = MyType { value: -20 };

    assert!(val1 > val2);
    assert!(val1 != val2);
}

use criterion::{criterion_group, criterion_main, Criterion};

fn sort_benchmark(c: &mut Criterion) {
    c.bench_function("sort_students", |b| {
        let mut students = vec![
            Student { name: "Alice".to_string(), score: 90 },
            Student { name: "Bob".to_string(), score: 95 },
            // 大量のデータを追加
        ];
        b.iter(|| students.sort());
    });
}

criterion_group!(benches, sort_benchmark);
criterion_main!(benches);

use std::cmp::Ordering;

#[derive(Debug, Eq, PartialEq)]
struct Employee {
    name: String,
    salary: u32,
}

impl Ord for Employee {
    fn cmp(&self, other: &Self) -> Ordering {
        other.salary.cmp(&self.salary) // 給与で降順
            .then_with(|| self.name.cmp(&other.name)) // 同額の場合は名前で昇順
    }
}

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

fn main() {
    let mut employees = vec![
        Employee { name: "Alice".to_string(), salary: 50000 },
        Employee { name: "Bob".to_string(), salary: 60000 },
        Employee { name: "Charlie".to_string(), salary: 50000 },
    ];

    employees.sort(); // `Ord` トレイトによるソート
    for employee in employees {
        println!("{:?}", employee);
    }
}

Employee { name: "Bob", salary: 60000 }
Employee { name: "Alice", salary: 50000 }
Employee { name: "Charlie", salary: 50000 }

fn main() {
    let employees = vec![
        Employee { name: "Alice".to_string(), salary: 50000 },
        Employee { name: "Bob".to_string(), salary: 60000 },
        Employee { name: "Charlie".to_string(), salary: 40000 },
    ];

    let high_earners: Vec<_> = employees
        .into_iter()
        .filter(|e| e.salary >= 50000) // 給与が50000以上の従業員を選別
        .collect();

    for employee in high_earners {
        println!("{:?}", employee);
    }
}

Employee { name: "Alice", salary: 50000 }
Employee { name: "Bob", salary: 60000 }

#[derive(Debug, Eq, PartialEq)]
struct Player {
    name: String,
    score: u32,
}

impl Ord for Player {
    fn cmp(&self, other: &Self) -> Ordering {
        other.score.cmp(&self.score) // スコアで降順
    }
}

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

fn main() {
    let mut players = vec![
        Player { name: "Alice".to_string(), score: 100 },
        Player { name: "Bob".to_string(), score: 150 },
        Player { name: "Charlie".to_string(), score: 120 },
    ];

    players.sort();
    for (rank, player) in players.iter().enumerate() {
        println!("Rank {}: {:?}", rank + 1, player);
    }
}

Rank 1: Player { name: "Bob", score: 150 }
Rank 2: Player { name: "Charlie", score: 120 }
Rank 3: Player { name: "Alice", score: 100 }