Scala - Layered Traits

---

---

Scala layered traits allow you to create a stack of behaviors that can be mixed into classes in a specific order, enabling a powerful form of code reuse and composition.

Defining a Layered Trait

A trait definition looks just like a class definition except that it uses the keyword trait. The following is the basic example syntax of a trait −

trait A {
   def message: String
}

trait B extends A {
   def loudMessage: String = message.toUpperCase()
}

class C extends A {
   val message = "Hello from C"
}

class D extends C with B

Example

In this example, we have three traits A, B, and C, where B extends A. The class D extends C and mixes in B, thus layering the behaviors defined in A and B.

trait A {
   def message: String
}

trait B extends A {
   def loudMessage: String = message.toUpperCase()
}

class C extends A {
   val message = "Hello from C"
}

class D extends C with B

object Demo {
   def main(args: Array[String]): Unit = {
      val d = new D
      println(d.message)      
      println(d.loudMessage)  
   }
}

Save the above program in Demo.scala. The following commands are used to compile and execute this program.

Command

\>scalac Demo.scala
\>scala Demo

The output will be −

Hello from C
HELLO FROM C

Usage of Layered Traits

Layered traits can be particularly useful when you need to add behaviors incrementally. Each trait can represent a different layer of functionality, and by mixing them into a class, you can compose a final class with a rich set of behaviors.

Example

trait Equal {
   def isEqual(x: Any): Boolean
   def isNotEqual(x: Any): Boolean = !isEqual(x)
}

trait Printable extends Any {
   def print(): Unit = println(this)
}

trait Movable {
   def move(dx: Int, dy: Int): Unit
}

class Point(xc: Int, yc: Int) extends Equal with Printable with Movable {
   var x: Int = xc
   var y: Int = yc

   def isEqual(obj: Any): Boolean = obj.isInstanceOf[Point] && 
   obj.asInstanceOf[Point].x == x && obj.asInstanceOf[Point].y == y

   def move(dx: Int, dy: Int): Unit = {
      x += dx
      y += dy
   }

   override def print(): Unit = println(s"Point($x, $y)")
}

object Demo {
   def main(args: Array[String]): Unit = {
      val p1 = new Point(2, 3)
      val p2 = new Point(2, 4)
      val p3 = new Point(2, 3)

      println(p1.isNotEqual(p2))
      println(p1.isNotEqual(p3))
      println(p1.isNotEqual(2))

      p1.print()
      p1.move(1, 1)
      p1.print()
   }
}

In this example, the Point class uses both Printable and Movable traits to layer the behaviors. The order in which traits are mixed in matters, as it defines the order in which methods are overridden.

Save the above program in Demo.scala. The following commands are used to compile and execute this program.

Command

\>scalac Demo.scala
\>scala Demo

The output will be −

true
false
true
Point(2, 3)
Point(3, 4)

Example with Layered Traits

To further illustrate the power of layered traits, let's consider a more complex example where traits modify state and behavior.

trait Base {
   var count = 0
   def increment(): Unit = {
      count += 1
   }
}

trait Doubling extends Base {
   abstract override def increment(): Unit = {
      super.increment()
      count *= 2
   }
}

trait Logging extends Base {
   abstract override def increment(): Unit = {
      println(s"Before increment: $count")
      super.increment()
      println(s"After increment: $count")
   }
}

class Counter extends Base

class AdvancedCounter extends Counter with Doubling with Logging

object Demo {
   def main(args: Array[String]): Unit = {
      val counter = new AdvancedCounter
      counter.increment()
      counter.increment()
   }
}

Save the above program in Demo.scala. The following commands are used to compile and execute this program.

Command

\>scalac Demo.scala
\>scala Demo

The output will be −

Before increment: 0
After increment: 2
Before increment: 2
After increment: 6 

Layered Traits Summary

• Traits are used to compose behavior in Scala. You can layered multiple traits for their functionalities.
• You can use layered traits to define reusable behaviors that can be mixed into multiple and unrelated classes. So, it promotes code reuse and modularity.
• You can have partially implemented methods in traits. So, you can provide default behavior that can be overridden by classes mixing in the trait.
• You can also define fields, which can be used for adding state to classes that mix in the trait.
• You can use universal traits for value classes to extend traits.