Apa perbedaan antara tipe-diri dan subkelas sifat?

Tipe diri untuk suatu sifat A:

trait B
trait A { this: B => }

mengatakan bahwa " Atidak dapat dicampur ke dalam kelas konkret yang tidak juga diperluas B" .

Di sisi lain, berikut ini:

trait B
trait A extends B

mengatakan bahwa "setiap pencampuran kelas (konkret atau abstrak) Ajuga akan bercampur dalam B" .

Bukankah kedua pernyataan ini memiliki arti yang sama? Tipe diri tampaknya hanya berfungsi untuk menciptakan kemungkinan kesalahan waktu kompilasi sederhana.

Apa yang saya lewatkan?

Ini terutama digunakan untuk Injeksi Ketergantungan , seperti dalam Pola Kue. Ada artikel bagus yang membahas berbagai bentuk injeksi ketergantungan di Scala, termasuk Pola Kue. Jika Anda Google "Pola Kue dan Scala", Anda akan mendapatkan banyak tautan, termasuk presentasi dan video. Untuk saat ini, di sini ada tautan ke pertanyaan lain .

Sekarang, seperti apa perbedaan antara tipe diri dan memperluas sifat, itu sederhana. Jika Anda mengatakan B extends A, maka B adalah sebuah A. Ketika Anda menggunakan tipe-diri, B dibutuhkan sebuah A. Ada dua persyaratan khusus yang dibuat dengan tipe mandiri:

1. Jika Bdiperpanjang, maka Anda harus mencampur A.
2. Ketika kelas konkret akhirnya meluas / mencampur-dalam sifat-sifat ini, beberapa kelas / sifat harus diimplementasikan A.

Perhatikan contoh-contoh berikut:

scala> trait User { def name: String }
defined trait User

scala> trait Tweeter {
     |   user: User =>
     |   def tweet(msg: String) = println(s"$name: $msg")
     | }
defined trait Tweeter

scala> trait Wrong extends Tweeter {
     |   def noCanDo = name
     | }
<console>:9: error: illegal inheritance;
 self-type Wrong does not conform to Tweeter's selftype Tweeter with User
       trait Wrong extends Tweeter {
                           ^
<console>:10: error: not found: value name
         def noCanDo = name
                       ^

Jika Tweeteritu adalah subkelas dari User, tidak akan ada kesalahan. Pada kode di atas, kita diperlukan sebuah Usersetiap kali Tweeterdigunakan, namun Usertidak disediakan untuk Wrong, jadi kita punya kesalahan. Sekarang, dengan kode di atas masih dalam cakupan, pertimbangkan:

scala> trait DummyUser extends User {
     |   override def name: String = "foo"
     | }
defined trait DummyUser

scala> trait Right extends Tweeter with User {
     |   val canDo = name
     | }
defined trait Right 

scala> trait RightAgain extends Tweeter with DummyUser {
     |   val canDo = name
     | }
defined trait RightAgain

Dengan Right, persyaratan untuk mencampuradukkan Useradalah terpenuhi. Namun, persyaratan kedua yang disebutkan di atas tidak puas: beban implementasi Usermasih ada untuk kelas / sifat yang meluas Right.

Dengan RightAgainkedua persyaratan terpenuhi. A Userdan implementasi Userdisediakan.

Untuk kasus penggunaan yang lebih praktis, silakan lihat tautan di awal jawaban ini! Tapi, semoga sekarang Anda mengerti.

Jenis mandiri memungkinkan Anda untuk menentukan dependensi siklus. Misalnya, Anda dapat mencapai ini:

trait A { self: B => }
trait B { self: A => }

Penggunaan warisan extendstidak memungkinkan hal itu. Mencoba:

trait A extends B
trait B extends A
error:  illegal cyclic reference involving trait A

Dalam buku Odersky, lihat bagian 33.5 (Membuat bab UI lembar bentang) di mana ia menyebutkan:

Dalam contoh lembar bentang, Model kelas mewarisi dari Evaluator dan karenanya memperoleh akses ke metode evaluasinya. Dengan kata lain, class Evaluator mendefinisikan tipe dirinya sebagai Model, seperti ini:

package org.stairwaybook.scells
trait Evaluator { this: Model => ...

Semoga ini membantu.

Satu perbedaan tambahan adalah bahwa tipe diri dapat menentukan tipe non-kelas. Contohnya

trait Foo{
   this: { def close:Unit} => 
   ...
}

Tipe mandiri di sini adalah tipe struktural. Efeknya adalah untuk mengatakan bahwa apa pun yang bercampur di Foo harus menerapkan unit pengembalian metode "tutup" no-arg. Ini memungkinkan mixin aman untuk mengetik bebek.

Bagian 2.3 "Anotasi Selftipe" dari makalah Scalaable Scalable Component Abstraksi karya Martin Odersky sebenarnya menjelaskan tujuan selftype di luar komposisi mixin dengan sangat baik: memberikan cara alternatif untuk mengasosiasikan kelas dengan jenis abstrak.

Contoh yang diberikan di koran seperti berikut ini, dan sepertinya tidak memiliki koresponden subclass yang elegan:

abstract class Graph {
  type Node <: BaseNode;
  class BaseNode {
    self: Node =>
    def connectWith(n: Node): Edge =
      new Edge(self, n);
  }
  class Edge(from: Node, to: Node) {
    def source() = from;
    def target() = to;
  }
}

class LabeledGraph extends Graph {
  class Node(label: String) extends BaseNode {
    def getLabel: String = label;
    def self: Node = this;
  }
}

Hal lain yang belum disebutkan: karena tipe-diri bukan bagian dari hierarki kelas yang diperlukan, mereka dapat dikecualikan dari pencocokan pola, terutama ketika Anda secara menyeluruh mencocokkan dengan hierarki yang disegel. Ini nyaman ketika Anda ingin memodelkan perilaku ortogonal seperti:

sealed trait Person
trait Student extends Person
trait Teacher extends Person
trait Adult { this : Person => } // orthogonal to its condition

val p : Person = new Student {}
p match {
  case s : Student => println("a student")
  case t : Teacher => println("a teacher")
} // that's it we're exhaustive

TL; DR ringkasan jawaban lain:

• Tipe yang Anda rentangkan terkena tipe yang diwarisi, tetapi tipe diri tidak

  misalnya: class Cow { this: FourStomachs }memungkinkan Anda menggunakan metode yang hanya tersedia untuk ruminansia, seperti digestGrass. Namun sifat-sifat yang memperpanjang Sapi tidak akan memiliki hak istimewa seperti itu. Di sisi lain, class Cow extends FourStomachsakan mengekspos digestGrasskepada siapa saja yang extends Cow .

• tipe diri memungkinkan dependensi siklus, memperluas tipe lain tidak

Mari kita mulai dengan ketergantungan siklus.

trait A {
  selfA: B =>
  def fa: Int }

trait B {
  selfB: A =>
  def fb: String }

Namun, modularitas dari solusi ini tidak sebesar yang pertama kali muncul, karena Anda dapat mengesampingkan tipe diri seperti itu:

trait A1 extends A {
  selfA1: B =>
  override def fb = "B's String" }
trait B1 extends B {
  selfB1: A =>
  override def fa = "A's String" }
val myObj = new A1 with B1

Meskipun, jika Anda menimpa anggota tipe diri, Anda kehilangan akses ke anggota asli, yang masih dapat diakses melalui super menggunakan pewarisan. Jadi yang benar-benar didapat dari menggunakan warisan adalah:

trait AB {
  def fa: String
  def fb: String }
trait A1 extends AB
{ override def fa = "A's String" }        
trait B1 extends AB
{ override def fb = "B's String" }    
val myObj = new A1 with B1

Sekarang saya tidak bisa mengklaim memahami semua seluk-beluk pola kue, tetapi menurut saya metode utama menegakkan modularitas adalah melalui komposisi daripada tipe pewarisan atau mandiri.

Versi warisan lebih pendek, tetapi alasan utama saya lebih memilih warisan daripada tipe diri adalah bahwa saya merasa jauh lebih sulit untuk mendapatkan urutan inisialisasi yang benar dengan tipe diri. Namun, ada beberapa hal yang dapat Anda lakukan dengan tipe diri yang tidak dapat Anda lakukan dengan pewarisan. Tipe mandiri dapat menggunakan tipe sementara pewarisan memerlukan sifat atau kelas seperti pada:

trait Outer
{ type T1 }     
trait S1
{ selfS1: Outer#T1 => } //Not possible with inheritance.

Anda bahkan dapat melakukannya:

trait TypeBuster
{ this: Int with String => }

Meskipun Anda tidak akan pernah bisa instantiate. Saya tidak melihat alasan mutlak untuk tidak dapat mewarisi dari suatu tipe, tetapi saya tentu merasa akan berguna untuk memiliki kelas dan sifat path konstruktor karena kami memiliki tipe / kelas konstruktor tipe. Sayangnya

trait InnerA extends Outer#Inner //Doesn't compile

Kami punya ini:

trait Outer
{ trait Inner }
trait OuterA extends Outer
{ trait InnerA extends Inner }
trait OuterB extends Outer
{ trait InnerB extends Inner }
trait OuterFinal extends OuterA with OuterB
{ val myV = new InnerA with InnerB }

Atau ini:

  trait Outer
  { trait Inner }     
  trait InnerA
  {this: Outer#Inner =>}
  trait InnerB
  {this: Outer#Inner =>}
  trait OuterFinal extends Outer
  { val myVal = new InnerA with InnerB with Inner }

Satu hal yang harus lebih ditekankan adalah bahwa sifat dapat memperluas kelas. Terima kasih kepada David Maclver karena menunjukkan ini. Berikut ini contoh dari kode saya sendiri:

class ScnBase extends Frame
abstract class ScnVista[GT <: GeomBase[_ <: TypesD]](geomRI: GT) extends ScnBase with DescripHolder[GT] )
{ val geomR = geomRI }    
trait EditScn[GT <: GeomBase[_ <: ScenTypes]] extends ScnVista[GT]
trait ScnVistaCyl[GT <: GeomBase[_ <: ScenTypes]] extends ScnVista[GT]

ScnBasemewarisi dari kelas Swing Frame, sehingga dapat digunakan sebagai tipe mandiri dan kemudian dicampur di akhir (di instantiation). Namun, val geomRperlu diinisialisasi sebelum digunakan oleh pewarisan sifat. Jadi kita perlu kelas untuk menegakkan inisialisasi sebelumnya geomR. Kelas ScnVistakemudian dapat diwarisi dari beberapa sifat ortogonal yang dapat diwarisi sendiri. Menggunakan beberapa tipe parameter (generik) menawarkan bentuk modularitas alternatif.

trait A { def x = 1 }
trait B extends A { override def x = super.x * 5 }
trait C1 extends B { override def x = 2 }
trait C2 extends A { this: B => override def x = 2}

// 1.
println((new C1 with B).x) // 2
println((new C2 with B).x) // 10

// 2.
trait X {
  type SomeA <: A
  trait Inner1 { this: SomeA => } // compiles ok
  trait Inner2 extends SomeA {} // doesn't compile
}

Tipe mandiri memungkinkan Anda menentukan tipe apa yang diizinkan untuk menggabungkan suatu sifat. Misalnya, jika Anda memiliki sifat dengan tipe diri Closeable, maka sifat itu tahu bahwa satu-satunya hal yang diizinkan untuk menggabungkannya, harus mengimplementasikan Closeableantarmuka.

Pembaruan: Perbedaan utama adalah bahwa tipe-mandiri dapat bergantung pada beberapa kelas (saya akui itu adalah kasus sudut sedikit). Misalnya, Anda bisa memilikinya

class Person {
  //...
  def name: String = "...";
}

class Expense {
  def cost: Int = 123;
}

trait Employee {
  this: Person with Expense =>
  // ...

  def roomNo: Int;

  def officeLabel: String = name + "/" + roomNo;
}

Hal ini memungkinkan untuk menambahkan Employeemixin hanya untuk sesuatu yang merupakan subclass dari Persondan Expense. Tentu saja, ini hanya bermakna jika Expensediperluas Personatau sebaliknya. Intinya adalah bahwa menggunakan tipe diri Employeebisa independen dari hirarki kelas yang menjadi sandarannya. Tidak peduli apa yang memperpanjang apa - Jika Anda mengganti hierarki Expensevs Person, Anda tidak perlu memodifikasi Employee.

dalam kasus pertama, suatu sub-sifat atau sub-kelas B dapat dicampur ke dalam penggunaan apa pun A. Jadi B dapat menjadi sifat abstrak.