How do I solve this inheritance problem in rust?

Question

first of all the obligatory "I am new to Rust": I am.

So I have the following problem:

I have two(or more) structs of data, that all implement some common behaviour in addition their own behaviour. I have a list of these structs (or rather: of the 'supertype'), I need to access some of their shared behaviour and some of their individual behaviour. My Question is: how do I do that in Rust.

To further illustrate my question I have come up with a code comparision between Kotlin and Rust. Kotlin works as I want it to, Rust does not (yet).

In Kotlin the code may look like this(using the plain, old inheritance abstraction):

interface Animal {
    fun eat()
    fun sleep()
}
class Cat(val name: String) : Animal {
    fun meow()              { println("meow") }

    override fun eat()      { println("cat $name is eating fish(or lasagne)") }
    override fun sleep()    { println("cat $name sleeps inside") }
}
class Lion(val tag_id: Int) : Animal {
    fun roar()              { println("roar") }

    override fun eat()      { println("lion(tag=${tag_id} is eating gazelle") }
    override fun sleep()    { println("lion(tag=${tag_id} sleeps outside") }
}

var animals: MutableList<Animal> = ArrayList()
fun main() {
    animals.add(Cat("Garfield"))
    animals.add(Lion(12))
    //later:
    for (animal in animals) {
        animal.sleep()
        if (animal is Lion)
            animal.roar()
    }
}

In Rust I came up with the following code (which does not allow an 'instance_of' type function):

trait Animal {
    fn eat(&self);
    fn sleep(&self);
}

struct Cat {
    name: String
}
impl Cat {
    fn meow(&self)      { println!("meow") }
}
impl Animal for Cat {
    fn eat(&self)       { println!("cat {} is eating fish(or lasagne)", self.name) }
    fn sleep(&self)     { println!("cat {} sleeps inside", self.name) }
}

struct Lion {
    tag_id: usize
}
impl Lion {
    fn roar(&self)      { println!("roar") }
}
impl Animal for Lion {
    fn eat(&self)       { println!("lion(tag={}) is eating fish(or lasagne)", self.tag_id) }
    fn sleep(&self)     { println!("lion(tag={}) sleeps inside", self.tag_id) }
}

fn main() {
    let animals:Vec<Box<dyn Animal>> = vec![
                Box::new(Cat {name: "Garfield".to_string()}),
                Box::new(Lion {tag_id: 12})
    ];
    //later:
    for animal in animals {
        animal.sleep()
        //HOW DO I ACCESS THE CONCRETE STRUCT HERE?
    }
}

Playground

I realize this may be a stupid question, or show how I am 'still trapped in the non-Rust thinking', but I am at kind of an Impass here and need just a little bit of assistence.

Answer 1

Try doing it with composition instead

trait Animal {
    fn voicebox(&self) -> Voicebox;
}
enum Voicebox {
    CatVoicebox, LionVoicebox
}

impl Voicebox {
    fn make_sound(&self) {
        match *self {
            Voicebox::CatVoicebox => println!("meow"),
            Voicebox::LionVoicebox => println!("roar!")
        }
    }
}

impl Animal for Cat {
    fn voicebox(&self) -> Voicebox {
      Voicebox::CatVoicebox
    }
}

impl Animal for Lion {
    fn voicebox(&self) -> Voicebox {
        Voicebox::LionVoicebox
    }
}

fn main() {
    let animals:Vec<Box<dyn Animal>> = vec![Box::new(Cat {name: "Garfield".to_string()}), Box::new(Lion {tag_id: 12})];
    //later:
    for animal in animals {
        animal.sleep();
        match animal.voicebox() {
            vb@Voicebox::LionVoicebox => vb.make_sound(),
            _ => ()
        }
    }
}

Output:

cat Garfield sleeps inside
lion(tag=12) sleeps inside
roar!

Rust playground

Answer 2

Type checked conditions can be implemented by providing a as_<type> function for every subtype:

trait Animal {
    fn eat(&self);
    fn sleep(&self);
    fn as_roaring(&self)->Option<&dyn Roaring>;
    fn as_meowing(&self)->Option<&dyn Meowing>;
}

The implementation of Lion would look like:

impl Animal for Lion {
    fn eat(&self)       { println!("lion(tag={}) is eating fish(or lasagne)", self.tag_id) }
    fn sleep(&self)     { println!("lion(tag={}) sleeps inside", self.tag_id) }
    fn as_roaring(&self)->Option<&dyn Roaring> {Some(self)}
    fn as_meowing(&self)->Option<&dyn Meowing> {None}
}

and of the loop:

    for animal in animals {
        animal.sleep();
        if let Some(roaring) = animal.as_roaring() {
          roaring.roar();
        }
    }

Playground.

Answer 3

You can try something like this

use std::any::Any;

trait Animal {
    fn eat(&self);
    fn sleep(&self);
    fn as_any(&self) -> &dyn Any;
}

struct Cat {
    name: String
}
impl Cat {
    fn meow(&self)      { println!("meow") }
}
impl Animal for Cat {
    fn eat(&self)       { println!("cat {} is eating fish(or lasagne)", self.name) }
    fn sleep(&self)     { println!("cat {} sleeps inside", self.name) }
    fn as_any(&self) -> &dyn Any { self }
}

struct Lion {
    tag_id: usize
}
impl Lion {
    fn roar(&self)      { println!("roar") }
}
impl Animal for Lion {
    fn eat(&self)       { println!("lion(tag={}) is eating fish(or lasagne)", self.tag_id) }
    fn sleep(&self)     { println!("lion(tag={}) sleeps inside", self.tag_id) }
    fn as_any(&self) -> &dyn Any { self }
}

fn main() {
    let animals:Vec<Box<dyn Animal>> = vec![
                Box::new(Cat {name: "Garfield".to_string()}),
                Box::new(Lion {tag_id: 12})
    ];
    //later:
    for animal in animals.iter() {
        animal.sleep();
        if let Some(animal) = animal.as_any().downcast_ref::<Lion>() {
            animal.roar();
        }
    }
}

Answer 4

Personally, I prefer to avoid the use of any or Box<dyn X>, prefering explicit enum wrapper. Often you get a tiny bit of boilerplate per type but I find that it does give additional type-safety and performance.

In this case I'd use an explicit enum Animal wrapping two types, struct Cat and Struct Lion that each implement a trait AnimalCore.

Then when I have an Animal and I want to use the shared behaviour I can just do animal.eat(), and if I want Lion specific behaviour I can pattern match on the enum like this: if let Animal::Lion(lion) = animal { lion.roar() }.

A complete implementation would look like this:

trait AnimalCore {
    fn eat(&self);
    fn sleep(&self);
}

struct Cat {
    name: String,
}

impl Cat {
    fn meow(&self) {
        println!("meow");
    }
}

impl AnimalCore for Cat {
    fn eat(&self) {
        println!("cat {} is eating fish(or lasagne)", self.name);
    }
    fn sleep(&self) {
        println!("cat {} sleeps inside", self.name);
    }
}

struct Lion {
    tag_id: i64,
}

impl Lion {
    fn roar(&self) {
        println!("roar");
    }
}

impl AnimalCore for Lion {
    fn eat(&self) {
        println!("lion(tag={}) is eating gazelle", self.tag_id)
    }
    fn sleep(&self) {
        println!("lion(tag={}) sleeps outside", self.tag_id)
    }
}

enum Animal {
    Cat(Cat),
    Lion(Lion),
}

impl Animal {
    fn as_core(&self) -> &dyn AnimalCore {
        match self {
            Animal::Cat(v) => v,
            Animal::Lion(v) => v,
        }
    }
    fn eat(&self) {
        self.as_core().eat()
    }
    fn sleep(&self) {
        self.as_core().sleep()
    }
}

fn main() {
    let animals = vec![
        Animal::Cat(Cat {
            name: String::from("Garfield"),
        }),
        Animal::Lion(Lion { tag_id: 12 }),
    ];

    //later:
    for animal in animals {
        animal.sleep();
        if let Animal::Lion(animal) = animal {
            animal.roar()
        }
    }
}

Which you can see on the playground

Aside: If I had lots of code that was conditional on whether the object was a lion I'd add a helper function like:

impl Animal {
  fn as_lion(&self) -> Option<&Lion> {
     match(self) { 
       Animal::Lion(lion) => Some(lion),
       _ => None
     }
  }
}

which I could then use as:

  animal.as_lion().map(Lion::roar)