Yep, that's precisely it! When dealing with other languages I miss the "match" keyword and being able to open a block anywhere. Sure, sometimes Rust allows you to write terse abominations if you don't exercise a dose of caution and empathy for future maintainers (you included).

Other than the great developer experience in tooling and language ergonomics (as in coherent features not necessarily ease of use) the reason I continue to put up with the difficulties of Rust's borrow checker is because I feel I can work towards mastering one language and then write code across multiple domains AND at the end I'll have an easy way to share it, no Docker and friends needed.

But I don't shy away from the downsides. Rust loads the cognitive burden at the ends. Hard as hell in the beginning when learning it and most people (me included) bounce from it for the first few times unless they have C++ experience (from what I can tell). At the middle it's a joy even when writing "throwaway" code with .expect("Lol oops!") and friends. But when you get to the complex stuff it becomes incredibly hard again because Rust forces you to either rethink your design to fit the borrow checker rules or deal with unsafe code blocks which seem to have their own flavor of C++ like eldritch horrors.

Anyway, would *I* recommend Rust to everyone? Nah, Go is a better proposition for a most bang for your buck language, tooling and ecosystem UNLESS you're the kind that likes to deal with complexity for the fulfilled promise of one language for almost anything. In even simpler terms Go is good for most things, Rust can be used for everything.

Also stuff like Maud and Minijinja for Rust are delights on the backend when making old fashioned MPA.

Thanks for coming to my TED talk.

>Anyway, would I recommend Rust to everyone?

For me it's a question of whether I can get away with garbage collection. If I can then pretty much everything else is going to be twice as productive but if I can't then the options are quite limited and Rust is a good choice.

What language are you using that doesn’t have match? Even Java has the equivalent. The only ones I can think of that don’t are the scripting languages.. Python and JS.

Does Java have sum types now?

Yes via sealed classes. It also has pattern matching.

So they are there, but ugly to define:

    public abstract sealed class Vehicle permits Car, Truck {
      public Vehicle() {}
    }

    public final class Truck extends Vehicle implements Service {
      public final int loadCapacity;

      public Truck(int loadCapacity) {
        this.loadCapacity = loadCapacity;
      }
    }

    public non-sealed class Car extends Vehicle implements Service {
      public final int numberOfSeats;
      public final String brandName;

      public Car(int numberOfSeats, String brandName) {
        this.numberOfSeats = numberOfSeats;
        this.brandName = brandName;
      }
    }

In Kotlin it's a bit better, but nothing beats the ML-like langs (and Rust/ReScript/etc):

    type Truck = { loadCapacity: int }
    type Car = { numberOfSeats: int, brandName: string }
    type Vehicle = Truck | Car

You could use Java records to make things more concise:

  record Truck(int loadCapacity) implements Vehicle {}
  record Car(int numberOfSeats, String brandName) implements Vehicle {}
  sealed interface Vehicle permits Car, Truck {}

Scala 3 has:

  enum Vehicle:
    case Truck(loadCapacity: Int)
    case Car(numberOfSets: Int, brandName: String)

You implemented this much more verbosely than needed

    sealed interface Vehicle {
        record Truck(int loadCapacity) implements Vehicle {}
        record Car(int numberOfSeats, String brandName) implements Vehicle {}
    }

Ah! Thanks, I didn't know that. I should have RTFMD better - https://docs.oracle.com/en/java/javase/21/language/sealed-cl...

Turns out you can do this and not have the annoying inner class e.g. Vehicle.Car too:

  package com.example.vehicles;

  public sealed interface Vehicle
      // The permits clause has been omitted
      // as its permitted classes have been
      // defined in the same file.
  { }
  record Truck(int loadCapacity) implements Vehicle {}
  record Car(int numberOfSeats, String brandName) implements Vehicle {}

I think Java 21 does. Scala and Kotlin do as well.

Python has it as well.

Ah my mistake. It’s been at least 5 years since I’ve written it. I’m honestly surprised that JS has moved no where on it considering all of the fancy things they’ve been adding.

It has been proposed, but since there is all the process on how features get added into the standard, someone needs to champion it, and then there is the "at least two implementations" factor.

https://github.com/tc39/proposal-pattern-matching

Yeah, anything with nulls ends up with Option<this> and Option<that> which means unwraps or matches. There is a comment above about good bedrock and Rust works OK with nulls but it works really well with unsparse databases (avoiding joins).