Scala | Traits

Traits in Scala are a core concept that serves multiple purposes. They can be thought of as a mix between interfaces in languages like Java and mixins in other languages. Traits allow for a flexible form of inheritance and are used to share methods between multiple classes.

Here's a more detailed overview of traits in Scala:

Basic Trait Definition and Usage: Traits can be defined using the trait keyword:

trait Greeter {
  def greet(name: String): Unit = {
    println(s"Hello, $name!")
  }
}

You can mix this trait into a class using the extends or with keywords:

class Person(name: String) extends Greeter {
  def sayHello(): Unit = greet(name)
}

Abstract and Concrete Methods: Traits can have both abstract (without implementation) and concrete (with implementation) methods:

trait Shape {
  def area: Double      // abstract method
  def perimeter: Double // abstract method

  def description: String = "This is a shape" // concrete method
}

Fields in Traits: Traits can also contain fields, both abstract and concrete:

trait Colored {
  val color: String
  val description: String = s"A colored object with color $color"
}

Extending Multiple Traits: A class can extend multiple traits. The first trait is mixed in using extends, and subsequent traits are mixed in using with:
```
class Circle(r: Double) extends Shape with Colored {
  val color = "red"
  def area: Double = 3.14 * r * r
  def perimeter: Double = 2 * 3.14 * r
}
```

Stackable Modifications: Traits can be used to modify the methods of classes in a stackable fashion, allowing you to mix in behavior in a modular way:

abstract class Writer {
  def write(data: String)
}

trait UppercaseWriter extends Writer {
  abstract override def write(data: String) = super.write(data.toUpperCase())
}

class StringWriter extends Writer {
  private var storage = ""
  def write(data: String) = storage += data
  override def toString: String = storage
}

val writer = new StringWriter with UppercaseWriter
writer.write("hello")
println(writer)  // prints HELLO

Linearization: When a class extends multiple traits, there's a specific order in which the traits' methods are called, known as linearization. In simple terms, the last trait mixed in gets the highest precedence.
Self Types: Traits can declare a self type, specifying the type of other traits/classes that must be mixed into any class mixing in the trait:
```
trait User {
  def username: String
}

trait Tweeter {
  this: User =>
  def tweet(message: String) = println(s"$username: $message")
}
```

Traits offer a powerful mechanism in Scala for modular design, code reuse, and multiple inheritance. They play a pivotal role in achieving polymorphism and designing clean, maintainable, and extensible systems.

Mixin Composition with Scala Traits:

Traits in Scala facilitate mixin composition, allowing you to combine multiple traits to create classes with modular and reusable functionality.

trait Logger {
  def log(message: String): Unit = println(s"Log: $message")
}

trait Validator {
  def validate(data: String): Boolean
}

class DataProcessor extends Logger with Validator {
  def process(data: String): Unit = {
    if (validate(data)) log("Processing data...")
  }
}

Abstract Methods in Scala Traits:

Traits can declare abstract methods, which must be implemented by the classes that mix in the trait.

trait Logger {
  def log(message: String): Unit
}

class ConsoleLogger extends Logger {
  def log(message: String): Unit = println(s"Log: $message")
}

Trait vs Abstract Class in Scala:
Traits and abstract classes serve different purposes. Traits promote mixin composition and multiple inheritance, while abstract classes provide a base for concrete classes.
```
trait Logger { def log(message: String): Unit }
abstract class AbstractLogger extends Logger

class ConsoleLogger extends AbstractLogger {
  def log(message: String): Unit = println(s"Log: $message")
}
```

Multiple Inheritance in Scala with Traits:

Traits enable multiple inheritance in Scala, allowing a class to inherit from multiple traits.

trait A { def methodA(): Unit }
trait B { def methodB(): Unit }

class MyClass extends A with B {
  def methodA(): Unit = println("Method A")
  def methodB(): Unit = println("Method B")
}

Stackable Traits in Scala:

Stackable traits allow you to compose classes in a flexible and modular way, providing a stack of behaviors that can be easily combined.

trait Stackable1 { def stackableMethod(): Unit }
trait Stackable2 { def stackableMethod(): Unit }

class StackableClass extends Stackable1 with Stackable2 {
  override def stackableMethod(): Unit = {
    super[Stackable1].stackableMethod()
    super[Stackable2].stackableMethod()
    // Additional logic
  }
}

Linearization of Traits in Scala:

The linearization order of traits in Scala determines the method resolution order. It follows a depth-first, left-to-right approach.

trait A { def message: String }
trait B extends A { override def message: String = "B" }
trait C extends A { override def message: String = "C" }

class MyClass extends B with C
println(new MyClass().message)  // Output: C

Sealed Traits in Scala:

Sealed traits restrict their subclasses to be defined within the same file, promoting exhaustive pattern matching.

sealed trait Shape
case class Circle(radius: Double) extends Shape
case class Rectangle(width: Double, height: Double) extends Shape

def area(shape: Shape): Double = shape match {
  case Circle(r) => math.Pi * r * r
  case Rectangle(w, h) => w * h
}