Solving the Multi-Trait Object Problem in Rust

Reference · Through the layers

Rust is renowned for its memory safety, concurrency features, and zero-cost abstractions. However, like any language, it comes with its limitations. One such limitation is Rust's restriction on combining multiple traits into a single trait object.

The Problem

In Rust, you can easily work with dynamic trait objects for single traits. For instance, you can pass around a &mut dyn Read or &mut dyn Seek. But what happens if you need to work with a type that implements multiple traits, such as both Read and Seek?

Consider this scenario:

fn user(stream: &mut dyn Read) {
    // Can only use Read trait methods
}

fn user_with_seek(stream: &mut dyn Seek) {
    // Can only use Seek trait methods
}

You can’t pass a trait object that satisfies both Read and Seek dynamically, because Rust doesn’t support multi-trait objects like &mut (dyn Read + Seek).

If you try, you’ll encounter an error:

Copy code
error[E0225]: only auto traits can be used as additional traits in a trait object
 --> src/main.rs:3:38
  |
3 | fn user_dynamic(stream: &mut (Read + Seek)) {}
  |                                      ^^^^ non-auto additional trait

This is because Rust uses "fat pointers" for dynamic trait objects, and these pointers can only refer to one vtable at a time. Adding multiple traits to a dynamic object would mean multiple vtables, which Rust currently doesn’t support.

The Workaround: Composite Traits

Fortunately, there’s a neat solution: create a new composite trait that requires the two (or more) traits you need. Here’s how it works:

use std::io::{Read, Seek};

// Create a new composite trait that combines Seek and Read
trait SeekRead: Seek + Read {}

// Implement the composite trait for any type that implements both Seek and Read
impl<T: Seek + Read> SeekRead for T {}

// Now, you can use the composite trait dynamically
fn user_dynamic(stream: &mut dyn SeekRead) {
    // Can use both Read and Seek methods
}

In this example:

SeekRead is a new trait that requires both Seek and Read to be implemented. The implementation for SeekRead applies to any type that implements both Seek and Read, making this composite trait widely usable. Now, we can pass around &mut dyn SeekRead, and we can dynamically dispatch calls to methods from both Read and Seek.

How Does It Work?

Behind the scenes, Rust creates a new vtable for the composite trait, SeekRead. This new vtable contains pointers to both the Seek and Read methods, allowing dynamic dispatch for both traits in one object. This solution is both elegant and efficient within Rust’s safety model.

Here’s how you can use this in practice:

fn use_reader_and_seeker(stream: &mut dyn SeekRead) {
    let mut buffer = [0; 10];

    // Use Read methods
    stream.read(&mut buffer).unwrap();

    // Use Seek methods
    stream.seek(std::io::SeekFrom::Start(0)).unwrap();
}

What’s the Catch?

While this approach works well for dynamic dispatch across multiple traits, it does have one limitation: you cannot downcast the composite trait back into one of its constituent traits (e.g., from &mut dyn SeekRead to &mut dyn Seek or &mut dyn Read). Rust doesn’t yet support this kind of trait object upcasting.

If you only need one of the traits at a later point, you may need to revisit your design or introduce additional methods in your composite trait.

Conclusion

By defining a composite trait, you can work around Rust’s limitation of multi-trait objects. This approach is simple, efficient, and maintains Rust’s strict guarantees around memory safety and performance. Whether you're building complex systems or working with asynchronous I/O, this technique allows you to leverage Rust’s full potential in dynamic contexts.

Mastering Rust requires learning these kinds of workarounds, but each new trick strengthens your ability to write safe, high-performance systems.