Derive attribute for specific fields only, like serde does

Question

Using derive syntax, can I implement traits like Hash or PartialEq using specific fields, not all of them?

It could look like:

#[derive(Debug, Hash, Eq, PartialEq)]
struct MyStruct {
    id: i32,
    name: String,

    #[derive(hash_skip, eq_skip)] 
    aux_data1: f64,
    #[derive(hash_skip, eq_skip)]
    aux_data2: f64,
    #[derive(hash_skip, eq_skip)]
    aux_data3: String,
}

I want the hash method to only use id, and name and no others.

The serde library allows something like this for serialization.

Answer 1

No, there is no such feature in Rust at this moment. What I would suggest is to use the implementation for tuples available for these traits, like this:

use std::hash::{Hash, Hasher};

#[derive(Debug)]
struct MyStruct {
    id: i32,
    name: String,
    aux_data1: f64,
    aux_data2: f64,
    aux_data3: String,
}

impl Hash for MyStruct {
    fn hash<H>(&self, state: &mut H) where H: Hasher {
        (&self.id, &self.name).hash(state);
    }
}

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

Edit: or as @Shepmaster suggested in a comment below, you can create a key function which returns a tuple of all useful fields and use it.

impl MyStruct {
    fn key(&self) -> (&i32, &String) {
        (&self.id, &self.name)
    }
}

impl Hash for MyStruct {
    fn hash<H>(&self, state: &mut H) where H: Hasher {
        self.key().hash(state);
    }
}

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

Answer 2

This is possible by using derivative.

Example:

use derivative::Derivative;

#[derive(Derivative)]
#[derivative(Hash, PartialEq)]
struct Foo {
    foo: u8,
    #[derivative(Hash="ignore")]
    #[derivative(PartialEq="ignore")]
    bar: u8,
}