Was ist der Unterschied zwischen Selbsttypen und Eigenschaftsunterklassen?

Question

Ein Selbsttyp für ein Merkmal A :

trait B
trait A { this: B => }

sagt, dass " A kann nicht in eine konkrete Klasse gemischt werden, die nicht auch die B " .

Auf der anderen Seite, die folgenden:

trait B
trait A extends B

sagt, dass "jede (konkrete oder abstrakte) Klasse, die in A wird auch in B gemischt" .

Bedeuten diese beiden Aussagen nicht das Gleiche? Der Selbsttyp scheint nur dazu zu dienen, die Möglichkeit eines einfachen Kompilierfehlers zu schaffen.

Was übersehe ich?

Answer 1

Es wird vor allem verwendet für Injektion von Abhängigkeiten wie z. B. beim Tortenmuster. Es gibt eine großartiger Artikel über viele verschiedene Formen von Dependency Injection in Scala, einschließlich des Cake Patterns. Wenn Sie "Cake Pattern und Scala" googeln, erhalten Sie viele Links, einschließlich Präsentationen und Videos. Für den Moment ist hier ein Link zu weitere Frage .

Was nun der Unterschied zwischen einem Selbsttyp und der Erweiterung einer Eigenschaft ist, ist ganz einfach. Wenn Sie sagen B extends A dann B es eine A . Wenn Sie Selbsttypen verwenden, B erfordert eine A . Es gibt zwei spezifische Anforderungen, die mit Selbsttypen geschaffen werden:

1. Si B erweitert wird, dann sind Sie erforderlich zum Einmischen eines A .
2. Wenn eine konkrete Klasse schließlich diese Traits erweitert/vermischt, muss eine Klasse/ein Trait Folgendes implementieren A .

Betrachten Sie die folgenden Beispiele:

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
                       ^

Si Tweeter war eine Unterklasse von User würde es keinen Fehler geben. In dem obigen Code müssen wir erforderlich a User wenn Tweeter verwendet wird, jedoch eine User nicht zur Verfügung gestellt wurde Wrong und wir bekamen einen Fehler. Nun, mit dem Code oben immer noch in Reichweite, betrachten:

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

Mit Right das Erfordernis der Einmischung eines User erfüllt ist. Die zweite oben genannte Voraussetzung ist jedoch nicht erfüllt: Die Last der Umsetzung User bleibt für Klassen/Traits, die die Right .

Mit RightAgain beide Anforderungen erfüllt sind. A User und eine Implementierung von User sind vorgesehen.

Weitere praktische Anwendungsfälle finden Sie unter den Links am Anfang dieser Antwort! Aber jetzt haben Sie es hoffentlich verstanden.

Answer 2

Selbsttypen ermöglichen es Ihnen, zyklische Abhängigkeiten zu definieren. Sie können zum Beispiel folgendes erreichen:

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

Vererbung mit extends lässt dies nicht zu. Versuchen Sie es:

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

Im Odersky-Buch finden Sie in Abschnitt 33.5 (Kapitel "Erstellen von Tabellenkalkulationen") einen Hinweis darauf:

Im Tabellenkalkulationsbeispiel erbt die Klasse Model von Evaluator und erhält somit Zugriff auf dessen Bewertungsmethode. Um den umgekehrten Weg zu gehen, definiert die Klasse Evaluator ihren eigenen Typ als Model definiert, etwa so:

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

Ich hoffe, das hilft.

Answer 3

Ein weiterer Unterschied besteht darin, dass Selbsttypen Nicht-Klassentypen angeben können. Zum Beispiel

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

Der Typ self ist hier ein Strukturtyp. Das bedeutet, dass alles, was sich in Foo mischt, eine "close"-Methode ohne Argumente implementieren muss, die unit zurückgibt. Dies ermöglicht sichere Mixins für Duck-Typing.

Answer 4

Eine weitere Sache, die noch nicht erwähnt wurde: Da Selbsttypen nicht Teil der Hierarchie der erforderlichen Klasse sind, können sie vom Musterabgleich ausgeschlossen werden, vor allem, wenn Sie einen umfassenden Abgleich mit einer versiegelten Hierarchie vornehmen. Dies ist praktisch, wenn Sie orthogonale Verhaltensweisen modellieren wollen, wie z. B.:

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

Answer 5

TL;DR Zusammenfassung der anderen Antworten:

• Typen, die Sie erweitern, sind vererbten Typen ausgesetzt, Selbsttypen jedoch nicht

  z. B: class Cow { this: FourStomachs } können Sie Methoden anwenden, die nur für Wiederkäuer zur Verfügung stehen, wie z. B. digestGrass . Eigenschaften, die die Kuh verlängern, haben jedoch keine solchen Privilegien. Auf der anderen Seite, class Cow extends FourStomachs wird aufdecken digestGrass für jeden, der extends Cow .

• Selbsttypen erlauben zyklische Abhängigkeiten, die Erweiterung anderer Typen ist nicht möglich.