Jon Pretty

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.

Hoping that gets reverted

Really, why? Because it's performing a function too similar to `&` and `with`?

Well yeah, because there's already `with`. I think you can't use `&` in extends clause.

No, you can't use `&`. It needs to be something different because the order of inheritance is significant, whereas `&` doesn't imply any order (in other uses). I hope `with` gets phased out instead—I think that's the plan, anyway.