“类声明头” { val_name : Type => 的语法含义是什么？ `类体`}”

Question

在阅读一些有关 Scala 的文章时，我发现了一些语法奇怪的示例，我可能会理解错误

class Child[C <: Child[C]] {
  some_name : C =>                   // here, what does it mean?
   var roomie : Option[C] = None

   def roomWith(aChild : C)= { 
     roomie = Some(aChild)
     aChild.roomie = Some(this) 
   }
}
class Boy extends Child[Boy]

我发现了类似的具有特征的例子。

这是否意味着我在类作用域中将 this 对象声明为 C 类型？

Answer 1

它是一个自我类型注释。

这意味着类Child 必须是C 类型，即创建必须满足给定类的继承依赖关系。

一个小例子：

scala> trait Baz
defined trait Baz


scala> class Foo {
     | self:Baz => 
     | }
defined class Foo


scala> val a = new Foo
<console>:9: error: class Foo cannot be instantiated because it does not conform to its self-type Foo with Baz
       val a = new Foo
               ^

scala> val a = new Foo with Baz
a: Foo with Baz = $anon$1@199de181


scala> class Bar extends Foo with Baz
defined class Bar

在这种情况下，Foo 也需要是 Baz。
满足该要求后，可以创建一个 Foo 实例。
此外，定义一个新类（在本例中为 Bar）还要求它也是 Baz。

看：
http://www.scala-lang.org/node/124

Answer 2

self 类型的一个非常有用的应用是 CRTP 的不太详细的实现（ http://en.wikipedia.org /wiki/Curiously_recurring_template_pattern ），例如

abstract class Base[Sub] {
  self:Sub =>
  def add(s:Sub) : Sub
}

case class Vec3(x:Double,y:Double,z:Double) extends Base[Vec3] {
  def add(that:Vec3) = Vec3(this.x+that.x, this.y+that.y, this.z+that.z)
}

尝试用继承“欺骗”是行不通的：

class Foo extends Base[Vec3] {
  add(v:Vec3) = v
}

//error: illegal inheritance;
//self-type Foo does not conform to Base[Vec3]'s selftype Base[Vec3] with Vec3
//      class Foo extends Base[Vec3] {

Answer 3

除了 JaimeJorge 响应中的继承要求之外，如果您想从内部类引用外部实例，还可以使用 self 类型为外部实例命名：

scala> class Company(name: String) {
     |   company =>
     |   class Department(name: String) {
     |     override def toString = "Department "+ name +" of "+ company.name
     |   }
     | }
defined class Company

scala> val c = new Company("ACME")
c: Company = Company@56a57bb2

scala> val d = new c.Department("Marketing")
d: c.Department = Department Marketing of ACME