The only solution I could think of was this one: trait CanCopy[T <: CanCopy[T]] { self: T => type Self >: self.type <: T def copy(newId: Int): Self } abstract class A(id: Int) { self:CanCopy[_] => def copy(newId: Int): Self } The following would compile: class B(id: Int, x: String) extends A(id) with CanCopy[B] { … Read more
It is an alias for this. Your first example is useful for ensuring that the trait has been mixed in to an appropriate type, and makes those methods available. The second example is useful when you have inner classes with naming conflicts, to make the outer scope visible. For example: trait U { self => … Read more
Self type annotations allow you to express cyclic dependencies. For instance: trait A extends B trait B { self: A => } This is not possible with simple inheritance.
This is what this.type is for: scala> abstract class Abstract0 { | def setOption(j: Int): this.type | } defined class Abstract0 scala> class Concrete0 extends Abstract0 { | var i: Int = 0 | def setOption(j: Int) = {i = j; this} | } defined class Concrete0 scala> (new Concrete0).setOption(1).setOption(1) res72: Concrete0 = Concrete0@a50ea1 As … Read more
It is predominately used for Dependency Injection, such as in the Cake Pattern. There exists a great article covering many different forms of dependency injection in Scala, including the Cake Pattern. If you Google “Cake Pattern and Scala”, you’ll get many links, including presentations and videos. For now, here is a link to another question. … Read more