Question

I want to have classes that can mix only specified traits:

class Peter extends Human with Lawful with Evil
class Mag extends Elf with Chaotic with Neutral

Is in Scala a way to do this?

UPD:

trait Law
trait Lawful extends Law
trait LNeutral extends Law
trait Chaotic extends Law

trait Moral
trait Good extends Moral
trait Neutral extends Moral
trait Evil extends Moral

class Hero .........
class Homer extends Hero with Chaotic with Good

I want to define a Hero class in a way that constrains the client programmer to mix specific traits (Lawful/LNeutral/Chaotic and Good/Neutral/Evil) if he extends the Hero class. And I want to find some other possibilities to restrict/constrain client code like this.

Answer 1

Tough. Try this:

scala> trait Law[T]
defined trait Law

scala> trait Lawful extends Law[Lawful]
defined trait Lawful

scala> trait Chaotic extends Law[Chaotic]
defined trait Chaotic

scala> class Peter extends Lawful with Chaotic
<console>:8: error: illegal inheritance;
 class Peter inherits different type instances of trait Law:
Law[Chaotic] and Law[Lawful]
       class Peter extends Lawful with Chaotic
             ^

If you want to make it a requirement that a Law type must be extended, then you need to to use self types in some base class or trait:

scala> class Human {
     |   self: Law[_] =>
     | }
defined class Human

scala> class Peter extends Human
<console>:7: error: illegal inheritance;
 self-type Peter does not conform to Human's selftype Human with Law[_]
       class Peter extends Human
                           ^

And there are a few further tweaks to ensure further type safety. The final result might look like this:

sealed trait Law[T <: Law[T]]
trait Lawful extends Law[Lawful]
trait LNeutral extends Law[LNeutral]
trait Chaotic extends Law[Chaotic]

sealed trait Moral[T <: Moral[T]]
trait Good extends Moral[Good]
trait Neutral extends Moral[Neutral]
trait Evil extends Moral[Evil]

class Human {
  self: Law[_] with Moral[_] =>
}