Derive macros are a godsend. There’s macros to automatically implement serialization as well. Basically a Trait that can automatically be implemented when derived
i’ve only read about rust, but is there a way to influence those automatic implementations?
equality for example could be that somethings literally point to the same thing in memory, or it could be that two structs have only values that are equal to each other
Equality in rust is value equality per default, that’s what these traits are for. If you want to check pointer equality you’d use the std::ptr::eq function to check if two pointers are equal, which is rather rare in practice. You can also implement the PartialEq trait yourself if you need custom equality checks.
I worked on software at one point that had at it’s core a number of “modes” that it switched between. It was, at the time, in the process of migrating from enums and switch/case trees to an inheritance based system.
In practice this meant there was a single instance of “Mode” for each mode which used pointer equality to switch/case on modes like an enum.
To add a new mode (that did nothing) I think I had to change about 6 different places.
It’s because people put in the hard work of writing amazing macros instead of baking code reuse into the type system itself 😁 I’m a rust noob and I love the derive macro.
Yes, it is that simple. In Rust if you have a structure Person and you want to allow testing equality between instances, you just add that bit of code before the struct definition as follows:
In Rust, PartialEq and Eq are traits, which are similar to interfaces in Java. Manually implementing the PartialEq trait in this example would be writing code that returns something like a.name == b.name && a.age == b.age. This is pretty simple but with large data structures it can be a lot of boilerplate.
There also exist other traits such as Clone to allow creating a copy of an instance, Debug for getting a string representation of an object, and PartialOrd and Ord for providing an ordering. Each of these traits can be automatically implemented for a struct by adding #[derive(PartialEq, Eq, Clone, Debug, PartialOrd, Ord)] before it.
Is that because it’s that simple, or just that the boilerplate is pre-written in the standard library (or whatever it’s called in rust)?
Derive macros are a godsend. There’s macros to automatically implement serialization as well. Basically a Trait that can automatically be implemented when derived
i’ve only read about rust, but is there a way to influence those automatic implementations?
equality for example could be that somethings literally point to the same thing in memory, or it could be that two structs have only values that are equal to each other
Not for the built-in Eq derive macro. But you can write your own derive macros that do allow you to take options, yeah.
Equality in rust is value equality per default, that’s what these traits are for. If you want to check pointer equality you’d use the
std::ptr::eqfunction to check if two pointers are equal, which is rather rare in practice. You can also implement thePartialEqtrait yourself if you need custom equality checks.I worked on software at one point that had at it’s core a number of “modes” that it switched between. It was, at the time, in the process of migrating from enums and switch/case trees to an inheritance based system.
In practice this meant there was a single instance of “Mode” for each mode which used pointer equality to switch/case on modes like an enum.
To add a new mode (that did nothing) I think I had to change about 6 different places.
Not really related to the pointer thing, but Rust also has pattern matching based on Enums, as they’re actually sum-types and not just numbers
It’s because people put in the hard work of writing amazing macros instead of baking code reuse into the type system itself 😁 I’m a rust noob and I love the derive macro.
So it’s actually a secret third option! That’s pretty rad.
Yes, it is that simple. In Rust if you have a structure
Personand you want to allow testing equality between instances, you just add that bit of code before the struct definition as follows:#[derive(PartialEq, Eq)] struct Person { name: String, age: u32, }In Rust,
PartialEqandEqare traits, which are similar to interfaces in Java. Manually implementing thePartialEqtrait in this example would be writing code that returns something likea.name == b.name && a.age == b.age. This is pretty simple but with large data structures it can be a lot of boilerplate.There also exist other traits such as
Cloneto allow creating a copy of an instance,Debugfor getting a string representation of an object, andPartialOrdandOrdfor providing an ordering. Each of these traits can be automatically implemented for a struct by adding#[derive(PartialEq, Eq, Clone, Debug, PartialOrd, Ord)]before it.