¿Cuál es la diferencia entre los tipos propios y las subclases de rasgos?

Un auto-tipo para un rasgo A:

trait B
trait A { this: B => }

dice que " Ano se puede mezclar en una clase concreta que no se extienda B" .

Por otro lado, lo siguiente:

trait B
trait A extends B

dice que "cualquier clase (concreta o abstracta) que se mezcle Atambién se mezclará en B" .

¿Estas dos afirmaciones no significan lo mismo? El auto-tipo parece servir solo para crear la posibilidad de un simple error en tiempo de compilación.

¿Qué me estoy perdiendo?

Se utiliza principalmente para la inyección de dependencia , como en el patrón de pastel. Existe un gran artículo que cubre muchas formas diferentes de inyección de dependencia en Scala, incluido el Patrón de pastel. Si buscas en Google "Cake Pattern and Scala", obtendrás muchos enlaces, incluidas presentaciones y videos. Por ahora, aquí hay un enlace a otra pregunta .

Ahora, en cuanto a cuál es la diferencia entre un auto tipo y extender un rasgo, eso es simple. Si dices B extends A, entonces B es un A. Cuando usas auto-tipos, B requiere un A. Hay dos requisitos específicos que se crean con autotipos:

1. Si Bse prolonga, entonces usted está obligado a mezclar en una A.
2. Cuando una clase concreta finalmente extiende / mezcla estos rasgos, se debe implementar alguna clase / rasgo A.

Considere los siguientes ejemplos:

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 Tweeterfuera una subclase de User, no habría error. En el código anterior, que requiere una Usercada vez que Tweeterse utiliza, sin embargo, un Userno se proporcionó a Wrong, así que conseguimos un error. Ahora, con el código anterior todavía en el alcance, considere:

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

Con Right, Userse cumple el requisito de mezclar a . Sin embargo, el segundo requisito mencionado anteriormente no se cumple: la carga de la implementación Usersigue siendo para las clases / rasgos que se extienden Right.

Con RightAgainambos requisitos se cumplen. A Usery una implementación de Userse proporcionan.

Para casos de uso más prácticos, consulte los enlaces al comienzo de esta respuesta. Pero, con suerte ahora lo entiendes.

Los tipos propios le permiten definir dependencias cíclicas. Por ejemplo, puedes lograr esto:

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

El uso de la herencia extendsno lo permite. Tratar:

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

En el libro de Odersky, mire la sección 33.5 (Creación del capítulo de la UI de la hoja de cálculo) donde menciona:

En el ejemplo de la hoja de cálculo, la clase Modelo hereda del Evaluador y, por lo tanto, obtiene acceso a su método de evaluación. Para ir hacia otro lado, la clase Evaluador define su auto tipo como Modelo, de esta manera:

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

Espero que esto ayude.

Una diferencia adicional es que los autotipos pueden especificar tipos que no son de clase. Por ejemplo

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

El auto tipo aquí es un tipo estructural. El efecto es decir que cualquier cosa que se mezcle en Foo debe implementar una unidad de retorno del método "cerrar" sin argumentos. Esto permite mezclas seguras para la tipificación de patos.

La sección 2.3 "Anotaciones de autotipo" del papel Scala original de Martin Odersky. Las abstracciones de componentes escalables en realidad explican muy bien el propósito del autotipo más allá de la composición mixin: proporcionar una forma alternativa de asociar una clase con un tipo abstracto.

El ejemplo dado en el documento fue el siguiente, y no parece tener un corresponsal de subclase elegante:

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

Otra cosa que no se ha mencionado: debido a que los autotipos no son parte de la jerarquía de la clase requerida, se pueden excluir de la coincidencia de patrones, especialmente cuando se compara exhaustivamente con una jerarquía sellada. Esto es conveniente cuando desea modelar comportamientos ortogonales como:

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 resumen de las otras respuestas:

• Los tipos que extiende están expuestos a los tipos heredados, pero los autotipos no

  Por ejemplo: le class Cow { this: FourStomachs }permite utilizar métodos solo disponibles para rumiantes, como digestGrass. Sin embargo, los rasgos que extienden Cow no tendrán tales privilegios. Por otro lado, class Cow extends FourStomachsexpondrá digestGrassa quien sea extends Cow .

• los auto-tipos permiten dependencias cíclicas, extender otros tipos no

Comencemos con la dependencia cíclica.

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

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

Sin embargo, la modularidad de esta solución no es tan buena como podría parecer en un principio, ya que puede anular los tipos propios de esta manera:

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

Sin embargo, si anula un miembro de tipo automático, pierde el acceso al miembro original, al que aún se puede acceder a través de super usando la herencia. Entonces, lo que realmente se gana con el uso de la herencia es:

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

Ahora no puedo afirmar que entiendo todas las sutilezas del patrón de pastel, pero me sorprende que el método principal para imponer la modularidad es a través de la composición en lugar de la herencia o los tipos propios.

La versión de herencia es más corta, pero la razón principal por la que prefiero la herencia sobre los tipos propios es que me resulta mucho más difícil obtener el orden de inicialización correcto con los tipos propios. Sin embargo, hay algunas cosas que puede hacer con los tipos propios que no puede hacer con la herencia. Los tipos propios pueden usar un tipo mientras que la herencia requiere un rasgo o una clase como en:

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

Incluso puedes hacer:

trait TypeBuster
{ this: Int with String => }

Aunque nunca podrás instanciarlo. No veo ninguna razón absoluta para no poder heredar de un tipo, pero ciertamente creo que sería útil tener clases y rasgos de constructor de ruta ya que tenemos rasgos / clases de constructor de tipo. Como lamentablemente

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

Tenemos esto:

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 }

O esto:

  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 }

Un punto que debería empatizarse más es que los rasgos pueden extender las clases. Gracias a David Maclver por señalar esto. Aquí hay un ejemplo de mi propio código:

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]

ScnBasehereda de la clase Swing Frame, por lo que podría usarse como un tipo automático y luego mezclarse al final (en la instanciación). Sin embargo, val geomRdebe inicializarse antes de que se use heredando rasgos. Por lo tanto, necesitamos una clase para imponer la inicialización previa de geomR. La clase ScnVistapuede ser heredada de múltiples rasgos ortogonales de los cuales ellos mismos pueden ser heredados. El uso de múltiples parámetros de tipo (genéricos) ofrece una forma alternativa de modularidad.

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
}

Un tipo automático le permite especificar qué tipos se pueden mezclar en un rasgo. Por ejemplo, si tiene un rasgo con un tipo automático Closeable, ese rasgo sabe que las únicas cosas que pueden mezclarlo deben implementar la Closeableinterfaz.

Actualización: una diferencia principal es que los auto-tipos pueden depender de múltiples clases (admito que es un caso de esquina). Por ejemplo, puedes tener

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

Esto permite agregar el Employeemixin a cualquier cosa que sea una subclase de Persony Expense. Por supuesto, esto solo tiene sentido si se Expenseextiende Persono viceversa. El punto es que el uso de auto-tipos Employeepuede ser independiente de la jerarquía de las clases de las que depende. No le importa qué extiende qué: si cambia la jerarquía de Expensevs Person, no tiene que modificar Employee.

en el primer caso, una subcaracter o subclase de B se puede mezclar con cualquier uso de A. Entonces B puede ser una característica abstracta.