Leandro Lucarella wrote:
Andrei Alexandrescu, el 3 de octubre a las 11:23 me escribiste:
Leandro Lucarella wrote:
Andrei Alexandrescu, el 2 de octubre a las 19:10 me escribiste:
Leandro Lucarella wrote:
We might have very different taste, but I find that a little... horrible.
What do you have against mixins? I think you're trying to use D as C++ :)
If mixins work better, all the better. How would you use them to
achieve multiple inheritance?
Don't design with multiple inheritance in mind, use interfaces + mixins
for common functionality instead.
But you're just saying it. I think you'd agree I wouldn't just
follow that dogma noncritically just because you told me what to do.
No, because the language is designed to do that AFAIK, so it will be much
easier and clear (for who writes the code and who reads it). I think you
hack with alias this is more obscure (we might be hitting personal taste
here, I grant you that).
Alias this was introduced purposedly to allow multiple subtyping. Until
yesterday, however, I hadn't realized how much nested classes help with
that. Even before that I wasn't worried, since MI designs are not as
frequent as SI designs.
I don't think many people design with multiple inheritance in mind.
They design aiming at a good design.
But you always have to take into account the tools you have when
designing. What's the point of designing a perfect bridge assuming you
have a material that doesn't exist?
Of course you can do that, but when you hit reality, you'll have to "hack"
your design to fit your real tools. So you can design something that
"looks like" multiple-inheritance, because it's easier (or nicer) to do
so. But when you want to put that in reality, you have to choose what tool
to use. In C++ you probably want to use MI (because the language has
a good support for it), but in D you probably want to use interfaces
+ mixins (because the language has good support for it).
Of course you can even implement it in C, or even assembly; you can
implement it as in C in C++ or D too, but it would be harder and more
obscure.
In my experience, some designs can make gainful use of multiple
inheritance of classes, and some of my best designs do use multiple
inheritance simply because it was the best tool for the job.
Sure, the problem comes when the language don't support MI ;)
So, there we are, you have D, which doesn't support MI per se, you have to
hack it. You can do it with the nested-inherited-classes+alias-this hack,
or by using interfaces+mixins. We agree at least that you have the same
result with both right? Then, I guess is just a matter of taste. I simply
find much more obscure and complex the nested-inherited-classes+alias-this
hack than interfaces+mixins :)
I don't see using a nested class (or any class) with alias this as a
hack. It's the way the whole thing is supposed to work in the first place.
Scala supports that with mixins, D supports that with multiple
subtyping.
I don't know what you mean about multiple subtyping.
You subtype once by using inheritance, and then some more by using alias
this.
Andrei
