Jaka jest różnica między typami własnymi a dziedziczeniem cech w Scali?

Gdy Googled, pojawia się wiele odpowiedzi na ten temat. Nie wydaje mi się jednak, aby któryś z nich dobrze ilustrował różnicę między tymi dwiema funkcjami. Chciałbym więc spróbować jeszcze raz, a konkretnie ...

Co można zrobić z typami własnymi, a nie z dziedziczeniem i odwrotnie?

Dla mnie powinna istnieć jakaś wymierna, fizyczna różnica między nimi, w przeciwnym razie są one tylko nominalnie różne.

Jeśli Cecha A rozciąga się na B lub typu B, to czy oba nie pokazują, że bycie B jest wymogiem? Jaka jest różnica?

Jeśli cecha A rozszerza B, wówczas mieszanie w A daje dokładnie B plus to, co A dodaje lub rozszerza. W przeciwieństwie do tego, jeśli cecha A ma własne odwołanie, które jest jawnie wpisane jako B, wówczas najwyższa klasa nadrzędna musi również mieszać B lub potomek B (i mieszać najpierw , co jest ważne).

To najważniejsza różnica. W pierwszym przypadku dokładny typ B krystalizuje się w punkcie A, który go wydłuża. W drugim przypadku projektant klasy nadrzędnej decyduje, która wersja B zostanie użyta w punkcie, w którym klasa macierzysta jest utworzona.

Inna różnica polega na tym, że A i B zapewniają metody o tej samej nazwie. Gdzie A rozszerza B, metoda A zastępuje B. Tam, gdzie A miesza się po B, metoda A po prostu wygrywa.

Wpisane na maszynie odnośniki dają znacznie więcej swobody; połączenie między A i B jest luźne.

AKTUALIZACJA:

Ponieważ nie masz pewności co do korzyści wynikających z tych różnic ...

Jeśli korzystasz z dziedziczenia bezpośredniego, tworzysz cechę A, którą jest B + A. Ułożyłeś związek w kamień.

Jeśli użyjesz samouczenia na maszynie, każdy, kto chce użyć twojej cechy A w klasie C., może

• Wymieszaj B, a następnie A w C.
• Wymieszaj podtyp B, a następnie A w C.
• Wymieszaj A w C, gdzie C jest podklasą B.

I to nie jest granica ich opcji, biorąc pod uwagę sposób, w jaki Scala pozwala na tworzenie instancji cechy bezpośrednio z blokiem kodu jako konstruktorem.

Jeśli chodzi o różnicę między wygraną metody A , ponieważ A jest pomieszane na końcu, w porównaniu do A przedłużającego B, rozważ to ...

Kiedy łączysz sekwencję cech, za każdym razem, gdy foo()wywoływana jest metoda , kompilator przechodzi do ostatniej wymieszanej cechy w celu jej wyszukania foo(), a następnie (jeśli nie została znaleziona), przechodzi przez sekwencję w lewo, aż znajdzie cechę, która implementuje foo()i wykorzystuje że. A ma również opcję wywoływania super.foo(), która również przechodzi przez sekwencję w lewo, aż znajdzie implementację i tak dalej.

Więc jeśli A ma wpisane na maszynie odniesienie do B, a pisarz A wie, że B implementuje foo(), A może zadzwonić super.foo()wiedząc, że jeśli nic innego nie zapewni foo(), B to zrobi. Jednak twórca klasy C ma możliwość upuszczenia dowolnej innej cechy, w której implementuje foo(), a zamiast tego dostanie to.

Ponownie, jest to o wiele bardziej wydajne i mniej ograniczający niż rozciągający B i bezpośrednio dzwoniąc wersja B z użytkownikiem foo().

Mam kod, który ilustruje niektóre różnice w widoczności wrt i „domyślne” implementacje przy rozszerzaniu vs ustawianie własnego typu. Nie ilustruje żadnej z omawianych już części na temat sposobu rozwiązywania rzeczywistych kolizji nazw, ale skupia się na tym, co jest możliwe i niemożliwe.

trait A1 {
  self: B =>

  def doit {
    println(bar)
  }
}

trait A2 extends B {
  def doit {
    println(bar)
  }
}

trait B {
  def bar = "default bar"
}

trait BX extends B {
  override def bar = "bar bx"
}

trait BY extends B {
  override def bar = "bar by"
}

object Test extends App {
  // object Thing1 extends A1  // FAIL: does not conform to A1 self-type
  object Thing1 extends A1 with B
  object Thing2 extends A2

  object Thing1X extends A1 with BX
  object Thing1Y extends A1 with BY
  object Thing2X extends A2 with BX
  object Thing2Y extends A2 with BY

  Thing1.doit  // default bar
  Thing2.doit  // default bar
  Thing1X.doit // bar bx
  Thing1Y.doit // bar by
  Thing2X.doit // bar bx
  Thing2Y.doit // bar by

  // up-cast
  val a1: A1 = Thing1Y
  val a2: A2 = Thing2Y

  // println(a1.bar)    // FAIL: not visible
  println(a2.bar)       // bar bx
  // println(a2.bary)   // FAIL: not visible
  println(Thing2Y.bary) // 42
}

Jedną ważną różnicą jest to, że IMO A1nie ujawnia, że ​​potrzebuje Bwszystkiego, co tylko ją widzi A1(jak pokazano w części up-cast). Jedynym kodem, który faktycznie zobaczy, że Bużywana jest szczególna specjalizacja , jest kod, który wyraźnie wie o typie złożonym (podobnym Think*{X,Y}).

Inną kwestią jest to, że A2(z rozszerzeniem) będzie faktycznie używane, Bjeśli nic innego nie zostanie określone, podczas gdy A1(własny typ) nie powie, że będzie używał, Bchyba że zostanie zastąpione, konkretne B musi zostać wyraźnie podane, gdy obiekty są tworzone.