Jon Pretty

Scala 3's multiple inheritance is a bit different from Scala 2's. It feels quirky in the context of Scala 2, but the rules are easier to understand. Traits can now take parameters, but you're only allowed to apply them in the extends clause of a class (not another trait).

An inheritance hierarchy between traits will be "parameterless" inheritance, so the linearization order is not so significant, and the type system now provides a sound way to combine multiple transitive inheritances of the same trait (which may have different type parameters).

Class-to-class inheritance is always single-inheritance, so there's never any ambiguity when applying the value parameters, though there may still be a need to resolve conflicts in concrete implementations.

A new error will occur with code like this: trait Foo(x: Int) trait Bar extends Foo // not allowed to extend Foo(0)! class Baz() extends Bar We are told that we need to explicitly specify the inheritance of Foo with its parameter, like so: class Baz() extends Bar, Foo(0)

You also get to use commas to separate the list of inherited traits.

And something changed around self types. If X refers to Y members you can say: trait X { this: Y => … } but if X implements any of Y you must say: trait X extends Y { … }.

That's very interesting, and I never saw the relation ro self-types before, but it seems like "parameterless trait inheritance" is very much like a self-type, except that if the trait is parameterless anyway, it's inherited... Thanks for the hint!

Actually I am wrong. Something has changed in self types but that is not quite it. I will get back to you on that!