Context passing in Scala

Context.scala

trait IsContext {
  def contextualContent: List[HasContext[this.type]] = List()
  contextualContent.map { item => item.setContext(this) }
}
trait HasContext[+Context] {
  private var ctx: Any = null
  def setContext(context: Any) {
    assert(ctx == null)
    ctx = context
  }
  lazy val context = ctx.asInstanceOf[Context]
}
trait Contextual[+Context] extends IsContext with HasContext[Context]

Better, just pass along values in mutual recursive definitions:

object simpleContext {

  trait HasContext[+Context] {
    has =>
    def context: Context
    trait ThisContext extends HasContext[Context] {
      def context = has.context
    }
  }
  trait IsContext[+Context] extends HasContext[Context] {
    this: Context =>
    override def context: this.type = this
  }

  // Using it...
  trait Page {
    def show () : Unit
  }

  trait User {
    val name : String
  }
  trait UserContext extends IsContext[UserContext] {
    val user : User
    val mainPage : Page
  }
  trait HelloPage extends Page with HasContext[UserContext] {
    def show () = println("Hello, " + context.user.name)
  }
  val ctx1 = new UserContext {
    val user = new User { val name = "Alice" }
    val mainPage = new HelloPage with ThisContext
  }

  // Refining it...
  trait Player extends User {
    var points : Int
  }
  trait PlayerContext extends IsContext[PlayerContext] with UserContext {
    val user: Player
  }
  trait ScorePage extends HelloPage with HasContext[PlayerContext] {
    override def show () = {
      super.show ()
      println("You have " + context.user.points + " points")
    }
  }
  val ctx2 = new PlayerContext {
    ctx =>
    val user = new Player {
      val name = "Bob"
      var points = 99
    }
    val mainPage = new ScorePage with ThisContext
  }
  def main(args: Array[String]): Unit = {
    ctx1.mainPage.show()
    ctx2.mainPage.show()
  }
}