Jon Pretty

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.

I don't think `with` can be phased out because of ambiguity with tuples. e.g. trait X; object X def x = (new X, X) Is it `x: X` or `x: (X, X.type)` ? So I hope `,` gets reconsidered as an ill-thought-out experiment :P