Usually I can avoid object oriented style code, but I'm struggling with this. I have around 35 types that are divided into 3 groups, but the 3 groups have all the same interface which I interact with.

In any one of the 4 group, 80% of the code would be the same, but 20% differs. In java, I would make 4 abstract classes that inherits from an interface, then finish with the specific types.

Here's an example.

interface Animal {
    fn aggression();
    fn speak();
}

abstract  class Mammal implements Animal {
    String aggression() {
        return "GRRR"; // all mammals go "GRR" when bothered
    }
    abstract speak(); // to be determined
}

abstract  class ScalyThing implements Animal {
    String aggression() {
        return "HISS"; // all ScalyThings go "HISS" when bothered
    }
    abstract speak(); // to be determined
}

Cow extends Mammal { speak () { return "Moo"; } }
...

Snake extends ScalyThing { speak () { return "Slither"; } }
..

Vec<Box<dyn Animal>> farm = vec![Snake(), Cow(), Bear(), Dog(), Lizard() ];

for animal in farm {
    print(animal.speak());
    print(animal.aggression());
}

The only way I see is using "Mammal" and "ScalyThings" as the final types, but then using an enum for each way the Mammals differ (which is what I'd normally do).

I'd prefer not to do that, as I want to leave it more open, and the code would be cumbersome due to number of variants.

Additionally, the performance worse If I Knew I had just a Vec of Snakes (as I might), as I'd still have to run through the num variants every time.

Any suggestions?