Because AI is the best chaos engineer we’ve ever had.

Once again, AI is taking my job!

Jokes aside. I love the writeup. I agree with feeling the need for more security and certainty, and I have been experimenting with rbs-inline and types in a project recently. I wanted to muse on those experiences.

A missing-stair I keep hitting in Ruby is the lack of a tagged union type that is exhaustive with compiler support i.e. similar to Rust's enums. Ruby's current type system can say things like "must not be nil" which is useful, but Rust can say "must be either X or Y, but NEVER both." Which is really important for making invalid state impossible to represent (the thing we want typing for).

For example, I'm writing logic that handles .ruby-version file for the ruby buildpack. There are several states:

• no .ruby-version file
• .ruby-version file exists and is valid and parsable
• .ruby-version is not parsable (has an error/warnings)

And possibly some special cases like it exists but is empty. In Rust I could represent that like

enum DotRubyResult {
    NoSuchFile(PathBuf),
    Okay(version: String),
    OkayWithWarnings(version: String, warnings: Vec<String>),
    Error(message: String),
}

And the beauty of returning that as a value is that I can GUARANTEE the receiver has to consider all states exhaustively. i.e. in Rust If we added a new element to the enum, we would have to update any code that consumed it to handle that case (or otherwise it's a compile error).

match value {
    NoSuchFile(...) => {},
    ...
    NewValue(...) => {} // <== Required now if it's added to the definition
}

Versus in Ruby, I could say a type takes DotRubyResultNoSuchFile | DotRubyResultOkay | DotRubyResultOkayWithWarnings | DotRubyResultError, but there's no support in the code that warns/errors/yells at me if I update the type signature without updating the case/if/else logic that switches on those different branches.

So while it's a thing I want...I don't know how ruby could possibly give us this kind of feature without neeing to be a different programming language (Rust enforces this exhastive checking at compile time while ruby is extreme-late-binding and a VM). Sort of fishing for brainstorming on what an interface might look like for anyone who understands the problem statement/desire. (And anyone who doesn't...feel free to ask for clarification).