Oh boy, multiple inheritance! Already "achievable...

# language-proposals

[Hullaballoonatic]

Oh boy, multiple inheritance!

Already "achievable" like so:

interface Bar {
    val bar: Int
    companion object {
        operator fun invoke(bar: Int) = object : Bar {
            override val bar = bar
        }
    }
}

interface Baz { 
    ...same as how Bar is implemented 
}

class Foo(bar: Int, baz: Int): Bar by Bar(bar), Baz by Baz(baz)

but wouldn't it be nice to just:

class Foo(bar: Int, baz: Int): Bar(bar), Baz(baz)

[Ruckus]

Is this a proposal or a question?

All discussion in this channel should begin with a use-case or proposal instead of a question.

If you're proposing multiple inheritance, please word it as such. If you're simply asking why it's not allowed, you should probably try a different channel.

[Hullaballoonatic]

Yeah, I already posted it to general with the advice to move it here, so I'll just reword it as a proposal...

[gildor]

I didn’t get it. It’s not a real inheritance, because you cannot extend 2 classes, only interfaces

[gildor]

the biggest problem that in case of classes you actually can have state, but not in interface

[gildor]

In you example above it’s just a creation of default instance

[janvladimirmostert]

In Dart multiple inheritence is possible via mixins

A extends B with C, D, E

[janvladimirmostert]

Although interfaces since JDK8 already makes multiple inheritance almost as nice.

[Hullaballoonatic]

Yeah, I'm not sure the classic wisdom of "never allow for multiple inheritance" holds today. I don't see what's wrong with it.

[gildor]

Multiple inheritance is like all problems of inheritance but multiplied

[Ruckus]

Hmm, aptly named indeed

[janvladimirmostert]

Composition in most cases is a better choice than Inheritance, but there are cases where inheritance makes more sense.
Mixins can technically already be achieved via class A : B(), C, D, E where B is a class / abstract class and C-E are interfaces

[janvladimirmostert]

https://medium.com/@debuggingisfun/darts-mixin-in-kotlin-b77409178047

[gildor]

Interface is not really inheritance, you do not inherit any behavior or state, you just declare that your class is implementation of some contract

[gildor]

And it's the biggest difference comparing to what you have in Dart, where you actually can inherit some state

[gildor]

Also funny that mixin example used for this article is really bad, you would never want such code in a real project

[gildor]

1. It's against inversion of control
2. This particular code can be easily replaced with Singleton, also against IoC but at least explicit and doesn't require any inheritance