Out of the Box Dynamic Dispatch

14 March 2020

Rust’s generics give us a whole lot of flexibility. A method that takes a trait bound argument does not need to care about the actual type of the argument it is called with. For example:

fn parse_read(r: impl Read) -> MyParseableType {
    todo!();
}

However, this will monomorphize the method: For each Read instance, one instance will be created, potentially ballooning up the code size and increasing compile time. But Rust gives us dynamic dispatch, too, e.g.

fn parse_read(r: &mut dyn Read) -> MyParseableType {
    todo!();
}

This makes each call on r dynamic. Only one version of this method needs to be created, but whenever r’s methods are called, the method must be looked up at runtime. This is done by having one static data per type that tells us where to find the respective methods. This so-called vtable is referenced whenever we need dynamic dispatch.

Now let’s say we want to pass our Read instance through to the method. For our example, we want to use Stdin or some File.

let readable = todo!();
parse_read(readable)

How should we initialize readable? The novice’s initial attempt is foiled by the type system:

let readable = if arg == "-" {
    io::stdin()
} else {
    fs::File::open(arg)?
};

The type checker is having none of it.

error[E0308]: if and else have incompatible types
 --> src/main.rs:5:9
  |
2 |       let readable = if arg == "-" {
  |  _____________________-
3 | |         std::io::stdin()
  | |         ---------------- expected because of this
4 | |     } else {
5 | |         std::fs::File::open(arg)?
  | |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected struct `std::io::Stdin`, found struct `std::fs::File`
6 | |     };
  | |_____- if and else have incompatible types

error: aborting due to previous error

Now the novice asks around and finds that Boxes can hold dynamic types.

let readable = if arg == "-" {
    Box::new(io::stdin())
} else {
    Box::new(fs::File::open(arg)?)
};

This still doesn’t work, because we haven’t told the compiler to make the type dynamic. And alas, the error message isn’t quite helpful. We can annotate the type to make it work:

let readable: Box<dyn io::Read> = if arg == "-" {
    Box::new(io::stdin())
} else {
    Box::new(fs::File::open(arg)?)
};

Box can have a little dynamic dispatch, as a treat. This will store the vtable pointer along with our Read instance in the Box’s allocated memory.

However, we are Rustaceans, so we don’t want to Box to get dynamic dispatch. And luckily since Rust 1.79.0, we get what we want without any further ado:

let readable: &mut dyn io::Read = if arg == "-" {
    &mut io::stdin()
} else {
    &mut fs::File::open(arg)?
};

Before Rust 1.79.0 which gave us automatic lifetime extension, we needed two places to hold our Read instances that live long enough to use them:

// these must live longer than `readable`
let (mut stdin_read, mut file_read);
let readable: &mut dyn io::Read = if arg == '-' {
    stdin_read = io::stdin();
    &mut stdin_read
} else {
    file_read = fs::File::open(arg)?;
    &mut file_read
};

The readable is out of the box! What happens is that we declare two stack slots that may alternately stay uninitialized or used, depending on arg. Then we take a &mut dyn mutable dynamic reference on it, which means the type will have a non-null pointer to the object (either stdin_read or file_read, depending on the branch taken) and a second reference to the vtable of either the Stdin type or the File type.

As an aside, this technique can also be used to create an Option<&T> where we don’t want to initialize the T unless needed:

let t_holder;
let opt_t = if has_t {
    t_holder = get_t();
    Some(&t_holder)
} else {
    None
}