the typeclass model offers superior extensibility

Problem

Subclassing inheritance is an anti-pattern (see also this and this and this). For those who aren't familiar with nominal typeclasses in for example Rust and Haskell, they conceptually (without getting into details and caveats yet) are a way of adding implementation to existing nominal types without modifying the source for those existing nominal types. For example, if you have an instance of existing nominal type `A` and your want to invoke a function that expects a nominal type `B` input, typeclasses conceptually enable you to declare the implementation of type `B` for type `A` and invoke the said function with the said instance of type `A` as input. The compiler is smart enough to automatically provide (the properties dictionary data structure or in ECMAScript the prototype chain) to the function the type `B` properties on the type `A` instance. The has efficiency, SPOT, and DNRY advantages over the alternative of manually wrapping the instance of `A` in a new instance which has `B` type and delegate to the properties of `A`. Scala has `implicit` conversion to automate, but this doesn't eliminate all the boilerplate and solve the efficiency (^{_{and tangentially note Scala also can implement a typeclass design pattern employing implicits}}). This disadvantage of wrapping with new instances compared to typeclasses is especially significant when the instance is a collection (or even collection of collections) of instances (potentially heterogeneous with a un