• dukk@programming.dev
    link
    fedilink
    arrow-up
    6
    ·
    edit-2
    11 months ago

    I’ll point to how many functional languages handle it. You create a type Maybe a, where a can be whatever type you wish. The maybe type can either be Just x or Nothing, where x is a value of type a (usually the result). You can’t access the x value through Maybe: if you want to get the value inside the Maybe, you’ll have to handle both a case where we have a value(Just x) and don’t(Nothing). Alternatively, you could just pass this value through, “assuming” you have a value throughout, and return the result in another Maybe, where you’ll either return the result through a Just or a Nothing. These are just some ways we can use Maybe types to completely replace nulls. The biggest benefit is that it forces you to handle the case where Maybe is Nothing: with null, it’s easy to forget. Even in languages like Zig, the Maybe type is present, just hiding under a different guise.

    If this explanation didn’t really make sense, that’s fine, perhaps the Rust Book can explain it better. If you’re willing to get your hands dirty with a little bit of Rust, I find this guide to also be quite nice.

    TLDR: The Maybe monad is a much better alternative to nulls.

    • Feathercrown@lemmy.world
      link
      fedilink
      English
      arrow-up
      4
      ·
      11 months ago

      Isn’t a Maybe enum equivalent to just using a return value of, for example, int | null with type warnings?

      • itslilith@lemmy.blahaj.zone
        link
        fedilink
        arrow-up
        2
        ·
        11 months ago

        Not quite, because the Maybe enum is neither int nor null, but it’s own, third thing. So before you can do any operations with the return value, you need to handle both cases that could occur

        • Feathercrown@lemmy.world
          link
          fedilink
          English
          arrow-up
          5
          ·
          11 months ago

          Isn’t that also true with compile-time type checking though? Eg. 0 + x where x is int|null would be detected? I don’t have much experience here so I could be wrong but I can’t think of a case where they’re not equivalent