Traits de Igualdade

Parte da seção Programação Orientada a Objetos do Journey de Rust da Coddy. Lição 38 de 61.

Comparar duas instâncias de uma struct personalizada com == não funciona por padrão em Rust. O compilador não sabe como determinar se duas structs são iguais. Você precisa informá-lo implementando o trait PartialEq.

Assim como Debug e Copy, você pode derivar PartialEq automaticamente:

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

let a = Coordinate { x: 5, y: 10 };
let b = Coordinate { x: 5, y: 10 };
let c = Coordinate { x: 3, y: 7 };

println!("{}", a == b);  // true
println!("{}", a == c);  // false

Quando derivado, PartialEq compara cada campo da struct. Duas instâncias são iguais somente se todos os seus campos correspondentes forem iguais.

Você também encontrará Eq, que é uma trait marcadora que indica igualdade total, ou seja, todo valor é igual a si mesmo. A maioria dos tipos satisfaz essa condição, mas números de ponto flutuante não (porque NaN != NaN). Para structs com campos inteiros, você pode derivar ambos com segurança:

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

Eq não possui métodos próprios. Ele simplesmente sinaliza que o tipo tem igualdade reflexiva. Alguns recursos da biblioteca padrão exigem Eq além de PartialEq, portanto é comum derivar ambos juntos para tipos que se qualificam.

Desafio

Fácil

Vamos criar um sistema de correspondência de cores que demonstra como os traits PartialEq e Eq permitem a comparação entre instâncias de structs!

Você criará dois arquivos para organizar sua lógica de comparação de cores:

color.rs: Defina uma struct Color pública com três campos públicos: red, green e blue (todos u8). Derive tanto PartialEq quanto Eq para que duas cores possam ser comparadas usando ==. Quando derivados, Rust considerará duas cores iguais somente se todos os três componentes RGB corresponderem exatamente.
main.rs: Inclua seu módulo de cores e crie duas instâncias de Color usando as entradas fornecidas. Compare-as usando == e imprima se correspondem ou não.

Sua saída deve indicar se as duas cores são iguais:

Color 1: rgb({r1}, {g1}, {b1})
Color 2: rgb({r2}, {g2}, {b2})
Colors match: {true/false}

Por exemplo, com as entradas 255, 128, 0, 255, 128, 0:

Color 1: rgb(255, 128, 0)
Color 2: rgb(255, 128, 0)
Colors match: true

E com as entradas 100, 100, 100, 200, 200, 200:

Color 1: rgb(100, 100, 100)
Color 2: rgb(200, 200, 200)
Colors match: false

Você receberá seis entradas: os valores RGB da primeira cor (três valores), seguidos pelos valores RGB da segunda cor (três valores). Faça o parse de cada um como u8.

Experimente você mesmo

mod color;

use color::Color;

fn main() {
    // Leia os seis valores RGB
    let mut input = String::new();
    std::io::stdin().read_line(&mut input).expect("Failed to read line");
    let r1: u8 = input.trim().parse().expect("Invalid input");

    input.clear();
    std::io::stdin().read_line(&mut input).expect("Failed to read line");
    let g1: u8 = input.trim().parse().expect("Invalid input");

    input.clear();
    std::io::stdin().read_line(&mut input).expect("Failed to read line");
    let b1: u8 = input.trim().parse().expect("Invalid input");

    input.clear();
    std::io::stdin().read_line(&mut input).expect("Failed to read line");
    let r2: u8 = input.trim().parse().expect("Invalid input");

    input.clear();
    std::io::stdin().read_line(&mut input).expect("Failed to read line");
    let g2: u8 = input.trim().parse().expect("Invalid input");

    input.clear();
    std::io::stdin().read_line(&mut input).expect("Failed to read line");
    let b2: u8 = input.trim().parse().expect("Invalid input");

    // TODO: Crie duas instâncias de Color usando os valores analisados

    // TODO: Imprima Color 1 no formato: Color 1: rgb(r, g, b)

    // TODO: Imprima Color 2 no formato: Color 2: rgb(r, g, b)

    // TODO: Compare the two colors using == and print: Colors match: {true/false}
}