Linearization order in Scala

by

An intuitive way to reason about linearisation is to refer to the construction order and to visualise the linear hierarchy.

You could think this way. The base class is constructed first; but before being able of constructing the base class, its superclasses/traits must be constructed first (this means construction starts at the top of the hierarchy). For each class in the hierarchy, mixed-in traits are constructed left-to-right because a trait on the right is added “later” and thus has the chance to “override” the previous traits. However, similarly to classes, in order to construct a trait, its base traits must be constructed first (obvious); and, quite reasonably, if a trait has already been constructed (anywhere in the hierarchy), it is not reconstructed again. Now, the construction order is the reverse of the linearisation. Think of “base” traits/classes as higher in the linear hierarchy, and traits lower in the hierarchy as closer to the class/object which is the subject of the linearisation.
The linearisation affects how `super´ is resolved in a trait: it will resolve to the closest base trait (higher in the hierarchy).

Thus:

var d = new A with D with C with B;

Linearisation of A with D with C with B is

  • (top of hierarchy) A (constructed first as base class)
  • linearisation of D
    • A (not considered as A occurs before)
    • D (D extends A)
  • linearisation of C
    • A (not considered as A occurs before)
    • B (B extends A)
    • C (C extends B)
  • linearisation of B
    • A (not considered as A occurs before)
    • B (not considered as B occurs before)

So the linearization is: A-D-B-C.
You could think of it as a linear hierarchy where A is the root (highest) and is constructed first, and C is the leaf (lowest) and constructed last. As C is constructed last, it means that may override “previous” members.

Given these intuitive rules, d.foo calls C.foo, which returns a “C” followed by super.foo() which is resolved on B (the trait on the left of B, i.e. higher/before, in the linearization), which returns a “B” followed by super.foo() which is resolved on D, which returns a “D” followed by super.foo() which is resolved on A, which finally returns “A”. So you have “CBDA”.

As another example, I prepared the following one:

class X { print("X") }
class A extends X { print("A") }
trait H { print("H") }
trait S extends H { print("S") }
trait R { print("R") }
trait T extends R with H { print("T") }
class B extends A with T with S { print("B") }

new B  // X A R H T S B     (the prints follow the construction order)

// Linearization is the reverse of the construction order.
// Note: the rightmost "H" wins (traits are not re-constructed)
// lin(B) = B >> lin(S) >> lin(T) >> lin(A)
//        = B >> (S >> H) >> (T >> H >> R) >> (A >> X)
//        = B >> S >> T >> H >> R >> A >> X

More Related Contents:

  1. What is the difference between self-types and trait subclasses?
  2. What is the advantage of using abstract classes instead of traits?
  3. What is a sealed trait?
  4. Mixing in a trait dynamically
  5. When to use val or def in Scala traits?
  6. Cake pattern with overriding abstract type don’t work with Upper Type Bounds
  7. Why can a Scala trait extend a class?
  8. Scala single method interface implementation
  9. How to define “type disjunction” (union types)?
  10. How to define partitioning of DataFrame?
  11. In Scala, what is an “early initializer”?
  12. Case class equality in Apache Spark
  13. What is the difference between Scala’s case class and class?
  14. What is the motivation for Scala assignment evaluating to Unit rather than the value assigned?
  15. Dropping a nested column from Spark DataFrame
  16. How to model type-safe enum types?
  17. What’s the difference between == and .equals in Scala?
  18. Reading DataFrame from partitioned parquet file
  19. Scala: convert map to case class
  20. Build.scala, % and %% symbols meaning
  21. Result type of an implicit conversion must be more specific than AnyRef
  22. DataFrame-ified zipWithIndex
  23. How are Scala traits compiled into Java bytecode?
  24. How to access parameter list of case class in a dotty macro
  25. How to print the contents of RDD?
  26. Can I import from multiple packages all at once in Scala?
  27. Scala start Play server in production
  28. Scala-Spark Dynamically call groupby and agg with parameter values
  29. Joining two dataframes without a common column
  30. Scala best way of turning a Collection into a Map-by-key?

Leave a Comment