Mixins are traits which are used to compose a class.
abstract class A {
val message: String
}
class B extends A {
val message = "I'm an instance of class B"
}
trait C extends A {
def loudMessage = message.toUpperCase()
}
class D extends B with C
val d = new D
println(d.message) // I'm an instance of class B
println(d.loudMessage) // I'M AN INSTANCE OF CLASS B
Class D has a superclass B and a mixin C. Classes can only have one superclass but many mixins (using the keywords extends and with respectively). The mixins and the superclass may have the same supertype.
abstract class A:
val message: String
class B extends A:
val message = "I'm an instance of class B"
trait C extends A:
def loudMessage = message.toUpperCase()
class D extends B, C
val d = D()
println(d.message) // I'm an instance of class B
println(d.loudMessage) // I'M AN INSTANCE OF CLASS B
Class D has a superclass B and a mixin C. Classes can only have one superclass but many mixins (using the keyword extends and the separator , respectively). The mixins and the superclass may have the same supertype.
Now let’s look at a more interesting example starting with an abstract class:
abstract class AbsIterator {
type T
def hasNext: Boolean
def next(): T
}
abstract class AbsIterator:
type T
def hasNext: Boolean
def next(): T
The class has an abstract type T and the standard iterator methods.
Next, we’ll implement a concrete class (all abstract members T, hasNext, and next have implementations):
class StringIterator(s: String) extends AbsIterator {
type T = Char
private var i = 0
def hasNext = i < s.length
def next() = {
val ch = s charAt i
i += 1
ch
}
}
class StringIterator(s: String) extends AbsIterator:
type T = Char
private var i = 0
def hasNext = i < s.length
def next() =
val ch = s charAt i
i += 1
ch
StringIterator takes a String and can be used to iterate over the String (e.g. to see if a String contains a certain character).
Now let’s create a trait which also extends AbsIterator.
trait RichIterator extends AbsIterator {
def foreach(f: T => Unit): Unit = while (hasNext) f(next())
}
This trait implements foreach by continually calling the provided function f: T => Unit on the next element (next()) as long as there are further elements (while (hasNext)). Because RichIterator is a trait, it doesn’t need to implement the abstract members of AbsIterator.
trait RichIterator extends AbsIterator:
def foreach(f: T => Unit): Unit = while hasNext do f(next())
This trait implements foreach by continually calling the provided function f: T => Unit on the next element (next()) as long as there are further elements (while hasNext). Because RichIterator is a trait, it doesn’t need to implement the abstract members of AbsIterator.
We would like to combine the functionality of StringIterator and RichIterator into a single class.
class RichStringIter extends StringIterator("Scala") with RichIterator
val richStringIter = new RichStringIter
richStringIter.foreach(println)
class RichStringIter extends StringIterator("Scala"), RichIterator
val richStringIter = RichStringIter()
richStringIter.foreach(println)
The new class RichStringIter has StringIterator as a superclass and RichIterator as a mixin.
With single inheritance we would not be able to achieve this level of flexibility.