Ý nghĩa cú pháp của "` khai báo lớp `{val_name: Type =>` lớp body`} "

Question

Khi đọc một số bài viết về Scala, tôi tìm thấy một số ví dụ với một cú pháp tò mò, mà tôi có thể hiểu sai

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] 

Tôi đã tìm thấy các ví dụ tương tự với các đặc điểm.

Điều đó có nghĩa là tôi tuyên bố đối tượng this trong phạm vi lớp theo loại C?

Answer 1

Đây là chú thích tự nhập.

Điều này có nghĩa là lớp Child phải thuộc loại C, tức là tạo phụ thuộc thừa kế phải thỏa mãn cho một lớp nhất định.

Một ví dụ nhỏ:

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 

Trong trường hợp này Foo được yêu cầu cũng là một Baz. Đáp ứng yêu cầu đó, một cá thể Foo có thể được tạo. Ngoài ra, xác định một lớp mới (trong trường hợp này là Bar) cũng có yêu cầu là Baz.

Xem: http://www.scala-lang.org/node/124

Answer 2

Ngoài các yêu cầu thừa kế để đáp ứng JaimeJorge của, tự loại có thể được sử dụng để cung cấp cho các ví dụ bên ngoài một tên nếu bạn muốn đề cập đến nó từ một lớp bên trong:

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 

Answer 3

Một ứng dụng rất hữu ích của các loại tự thực hiện ít chi tiết hơn về CRTP (http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern), ví dụ:

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) 
} 

Nỗ lực để "ăn gian" với thừa kế sẽ không làm việc:

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] {