Dziedziczenie rdzy: wywołanie metody macierzystej

Question

W jaki sposób Rust wywołuje "metodę macierzystą"? Jak to w Java:

public class parent{ 
    ... 
    public void doSomething(){ 
     System.out.println("Parent method"); 
    } 
} 
public class child extends parent{ 
    ... 
    public void doSomething(){ 
     super.doSomething(); 
     System.out.println("Child method."); 
    } 
} 

w Go, możemy zasymulować przez anonimowych pól w struct:

type parent struct{} 

func (self *parent) doSomething() { 
    fmt.Println("parent method") 
} 

type child struct { 
    parent 
} 

func (self *child) doSomething() { 
    self.parent.doSomething() 
    fmt.Println("child method") 
} 
func main() { 
    var c1 child 
    c1.doSomething() 
} 

Jak zasymulować w Rust? Dzięki!

Answer 1

To nie całkiem tak samo pod maską, ale coś

trait DoThings { 
    fn do_something(&self); 
} 

struct Parent; 

impl DoThings for Parent { 
    fn do_something(&self) { println("doing something"); } 
} 

struct Child { 
    parent: Parent 
} 

impl DoThings for Child { 
    fn do_something(&self) { 
     self.parent.do_something(); 
     println("child"); 
    } 
} 

fn main() { 
    let c = Child { parent: Parent }; 
    c.do_something(); 
} 

Istnieje kilka propozycji do realizacji części tego automatyczny (np jeśli chcieliśmy tylko wywołać metodę rodzica bezpośrednio, tj don” t nadpisuje metodę w potomku, a obecnie należy jawnie wywołać samą metodę rodzica).

Answer 2

Punktem dziedziczenia jest możliwość nadpisania odziedziczonej metody. Dostarczone próbki nadal dotyczą delegacji, a nie dziedziczenia.

Rzućmy okiem na niektóre kodu Go to zilustrować:

type Base struct {} 
func (Base) Magic() { fmt.Print("base magic") } 
func (self Base) MoreMagic() { 
    self.Magic() 
} 

type Foo struct { 
    Base 
} 

func (Foo) Magic() { fmt.Print("foo magic") } 

Jeśli uruchomisz powyższy kod ten sposób

f := new(Foo) 
f.Magic() 

będzie wydrukować „foo magię” do konsoli i nie "magia podstawowa". Jeśli jednak uruchomimy ten kod:

f := new(Foo) 
f.MoreMagic() 

to nie będzie również drukować "magii foo", ale tym razem "magia podstawowa". Dzieje się tak z powodu braku dziedziczenia, a zatem nie jest w stanie nadpisać metody Magic (inaczej dynamiczne łączenie). Nadal mamy do czynienia z delegacją.

Możesz obejść to, np. zgodnie z opisem w sekcji "Wewnętrzny język" w artykule this. Nie wiem dokładnie o tym, co dotyczy Rust. Na pierwszy rzut oka wydaje się to takie samo.