Rust-style enums containing both classes and values would be my ideal scenario. I'm very happy to share actual examples from work where I've wished I had robust ADTs if that would help.
I am sympathetic to Rust-style enums (subclasses listed inside the body of the base class). The problem is getting this to work with inheritance in Python. Rust doesn't have inheritance, so it doesn't care. Scala and Swift have a compiler that handles it. The obvious design (the rejected one in the PEP) would use the `class` keyword within the base class body. The problem is that the base class does not exist at this point (at least not under its name), so something like this will not work: ``` from enum import Enum class Result(Enum): class Success(Result): ... class Failure(Result): .... ``` We could have `Enum` do some magic (on top of what it does right now) that it injects itself into the `__bases__` of any class object found among its attributes. Or `Enum` could rebuild each class object found with itself added to the list of bases. This may be worth exploring more, because there are a number of edge cases that I don't know how to deal with from an implementation perspective.