Using rust 1.2.0
Problem
I'm still in the process of learning Rust (coming from a Javascript background) and am trying to figure out if it is possible for one struct StructB
to extend an existing struct StructA
such that StructB
has all the fields defined on StructA
.
In Javascript (ES6 syntax) I could essentially do something like this...
class Person { constructor (gender, age) { this.gender = gender; this.age = age; } } class Child extends Person { constructor (name, gender, age) { super(gender, age); this.name = name; } }
Constraints
StructA
is from an external cargo
package that I have no control over.Current Progress
I found this blog post on single-inheritance which sounds like exactly what I need.
But trying to implement it resulted in this error message error: virtual structs have been removed from the language
. Some searching later and I found out that it had been implemented and then removed per RFC-341 rather quickly.
Also found this thread about using traits, but since StructA
is from an external cargo package I don't think it is possible for me to turn it into a trait.
So what would be the correct way to accomplish this in Rust?
There is no struct inheritance in Rust. Instead we use composition and include an instance of Foo in Bar (since the field is a value, it is stored inline, so if there were fields, they would have the same layout in memory as the Java version (probably, you should use #[repr(C)] if you want to be sure)).
A struct cannot inherit from another struct or class, and it cannot be the base of a class. Structs, however, inherit from the base class Object. A struct can implement interfaces, and it does that exactly as classes do.
Inheritance as a Type System and as Code SharingIf a language must have inheritance to be an object-oriented language, then Rust is not. There is no way to define a struct that inherits the parent struct's fields and method implementations.
Keyword structA type that is composed of other types. Structs in Rust come in three flavors: Structs with named fields, tuple structs, and unit structs.
There is nothing that exactly matches that. There are two concepts that come to mind.
Structural composition
struct Person { age: u8, } struct Child { person: Person, has_toy: bool, } impl Person { fn new(age: u8) -> Self { Person { age: age } } fn age(&self) -> u8 { self.age } } impl Child { fn new(age: u8, has_toy: bool) -> Self { Child { person: Person::new(age), has_toy: has_toy } } fn age(&self) -> u8 { self.person.age() } } fn main() { let p = Person::new(42); let c = Child::new(7, true); println!("I am {}", p.age()); println!("My child is {}", c.age()); }
You can simply embed one struct into another. The memory layout is nice and compact, but you have to manually delegate all the methods from Person
to Child
or lend out a &Person
.
Traits
trait SayHi { fn say_hi(&self); } struct Person { age: u8, } struct Child { age: u8, has_toy: bool, } impl SayHi for Person { fn say_hi(&self) { println!("Greetings. I am {}", self.age) } } impl SayHi for Child { fn say_hi(&self) { if self.has_toy { println!("I'm only {}, but I have a toy!", self.age) } else { println!("I'm only {}, and I don't even have a toy!", self.age) } } } fn greet<T>(thing: T) where T: SayHi { thing.say_hi() } fn main() { let p = Person { age: 42 }; let c = Child { age: 7, has_toy: true }; greet(p); greet(c); }
You can combine these two concepts, of course.
As DK. mentions, you could choose to implement Deref
or DerefMut
. However, I do not agree that these traits should be used in this manner. My argument is akin to the argument that using classical object-oriented inheritance simply for code reuse is the wrong thing. "Favor composition over inheritance" => "favor composition over Deref
". However, I do hold out hope for a language feature that enables succinct delegation, reducing the annoyance of composition.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With