Few of the things I use inheritance or composition for can be implemented without storing some extra data.
As an example, say a buffered Stream, that takes a Stream instance and adds buffered access. This BufferedStream would need to store the buffer data somewhere.
struct MyEntity {
cache: RenderingCache,
}
impl Drawable for MyEntity {
fn draw(&self, canvas: &mut Canvas) {
self.cache.draw_cached(canvas, |cache_canvas| {
cache_canvas.render(ASSET);
});
}
}
const ASSET: Asset = load_asset("foo.png");Think Rust differs enough that it's a bit hard for me to draw direct comparisons with my primary languages, but with the emphasis on interfaces like that it does seem like a nicer way to implement extension methods.
class MyEntity {
RenderingCache cache;
}
now MyEntity implements Drawable {
void draw(Canvas canvas) {
this.cache.draw_cached(canvas ...);
}
}If you know haskell, Rust's traits are very similar to type classes, except it also has c++-like generics (templates) and is primarily expression-based like ocaml.
traits vs haskell type classes:
trait -> class struct -> data instance -> impl
I was just curious what OP was using these traits for, as in my non-Rust experience seldom have the need to compose stuff without storing additional data.
[1]: https://doc.rust-lang.org/src/std/io/buffered/bufwriter.rs.h...