Lambda the Ultimate

The contortions that one imagines are possible with MI don't seem to come up often in practice, so any reasonably sane scheme should be fine, including reasonable restrictions.

I implemented MI as a result of user demand, in the second major release of a commercial OO language extension product - the first version only had single inheritance. Support for MI-related issues hardly ever came up.

If inheritance order doesn't matter maybe inheritance isn't what we are looking for - it seems that when order do matters, inheritance is used for composing implementation(not is-a), and not for abstraction.

While you are experimenting: what if you have single inheritance with another construct for grouping(union) classes into a class Set. For example:

Class Size {}
Class Big extends Size {}
Class Small extends Size {}

Class Karma {}
Class Bad extends Karma {}
Class Good extends Karma {}

Class Race {}
Class Wolf extends Race {}
Class Bear extends Race {}

Class PCDetails {}

types of Classes are also class sets:
Class Size {} :: {Size}
Class Karma {} :: {Karma}
Class Race {} :: {Race}


new constract for grouping class sets into bigger class sets:
type NPC = {Size Karma Race}
type PC = {NPC, PCDetails} :: {Size Karma Race, PCDetails}


now we can write a function:
doSomething(obj:{Size Karma Race}) { ... }

we can construct new objects:
var bbw:NPC = new {Big Bad Wolf}
var hero:PC = new {Big Good Bear Details}

and call a function with:
doSomething(bbw)
doSomething(hero)
calling a function check that: type <: (type ∩ typeof(obj))

This is inspired by Haskell's type-classes.
Still unbaked, but what say you ?

If you provide some kind of CLOS :before and :after methods then your inheritance scheme may more conveniently express mix-in modifier classes for which the difference between AB and BA matters (BTW, if you want to support that kind of thing, you might also want repeated inheritance.) Inheritance schemes are typically presented as a big list of rules that might do what you want rather than as part of a principled modeling discipline, so it's hard to give an answer about what's needed in theory.