• Ashelyn@lemmy.blahaj.zone
    link
    fedilink
    arrow-up
    33
    ·
    1 month ago

    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)?

    • mvirts@lemmy.world
      link
      fedilink
      arrow-up
      48
      ·
      1 month ago

      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.

    • Rusty 🦀 Femboy 🏳️‍🌈@lemmy.blahaj.zoneOP
      link
      fedilink
      English
      arrow-up
      29
      ·
      1 month ago

      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:

      #[derive(PartialEq, Eq)]
      struct Person {
          name: String,
          age: u32,
      }
      

      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.

    • Dhs92
      link
      fedilink
      arrow-up
      24
      ·
      1 month ago

      Derive macros are a godsend. There’s macros to automatically implement serialization as well. Basically a Trait that can automatically be implemented when derived

      • Dunstabzugshaubitze@feddit.org
        link
        fedilink
        arrow-up
        11
        ·
        1 month ago

        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

        • Wappen@lemmy.world
          link
          fedilink
          arrow-up
          20
          ·
          1 month ago

          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.

          • brisk@aussie.zone
            link
            fedilink
            arrow-up
            1
            ·
            1 month ago

            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.

            • Dhs92
              link
              fedilink
              arrow-up
              2
              ·
              1 month ago

              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

        • 2xsaiko@discuss.tchncs.de
          link
          fedilink
          arrow-up
          6
          ·
          1 month ago

          Not for the built-in Eq derive macro. But you can write your own derive macros that do allow you to take options, yeah.