Thanks god.
Yeah. Pretty much. And we know that OOP doesn't work and we even know why OOP doesn't work.
The core unfixable vulnerability of OOP is LSP. It's often mentioned in the OOP tutorials, but never explored in depth — because if you think about it for 5 minutes you would realize that the whole OOP methodology is fundamentally flawed and couldn't be fixed.
LSP, of course, looks like this: 𝑆⊑𝑇→(∀𝑥:𝑇)ϕ(𝑥)→(∀𝑦:𝑆)ϕ(𝑦)
Or, in text form: Let ϕ(x) be a property provable about objects x of type T. Then ϕ(y) should be true for objects y of type S where S is a subtype of T.
Looks innocuous enough, right? Just look on the set of ϕ and then… but stop! Where and how can we obtain that list of ϕ? These are, obviously, not all properties imaginable (then types would be identical) and also that set is not empty (because then there would be no need for subtyping). OOP says: who cares, let's make it as flexible as possible and then we would, later, do something about that mess. Math answers: is you made you list ϕ non-trivial, expandable, and you have made your list of types expandable, too then have just made it fundamentally impossible to write provably correct programs. Not hard. Impossible.
That's not a theoretical concern, the whole Old New Thing blog is filled with examples of how people produce bugs because of that, some are hilarious, some are hard to imagine and fix.
And here the theory hits the practical side: how do you provide these ϕ, these properties provable, for your subclasses? Rust essentially gives two options that make the list trivial (math term, not random word): either limit number of classes (this would give you ADT, structs and enums), then for each ϕ (no matter how many of them) you can verify everything — or limit number of ϕ by providing trait with default implementations. List of default implementations is fixed, non-expandable, thus giving limit to list ϕ in another way.
So please answer the core question: do you want to limit number of subclasses or number of implementations of ϕ? This would give you an answer to where to proceed.
P.S. It's possible that the only way to create a useful UI is to demand that there are both unlimited number of classes and unlimited number of properties. That would just mean that it's impossible to develop UI in a way that makes to correct, bug-free. That would be sad outcome, to be honest, but I'm not asserting that it's not the only one: making good UI is hard and it wouldn't surprise me that a bug-free way to make it just simply doesn't exist.