Confused about forwarding a reference through multiple functions

Question

I'm having trouble understanding how references get forwarded through functions. The following scenario seems to compile as expected:

trait Trait {}

struct ImplementsTrait {}
impl Trait for ImplementsTrait {}

fn foo(t: &mut Trait) {
    // ... use the mutable reference
}

fn forward(t: &mut Trait) {
    foo(t); // forward the type '&mut Trait' to foo
}

fn main() {
    let mut t = ImplementsTrait{};
    forward(&mut t); // need to pass as reference because Trait has no static size
}

However, in using the API for the capnp crate, I get unexpected behavior:

fn parse_capnp(read: &mut BufRead) {
    let reader = serialize_packed::read_message(read, message::ReaderOptions::new());
    Ok(())
}

fn main() {
    // ... ///
    let mut br = BufReader::new(f);
    parse_capnp(&mut br);
    Ok(())
}

error[E0277]: the trait bound `std::io::BufRead: std::marker::Sized` is not satisfied
  --> src/main.rs:18:16
   |
18 |     let reader = serialize_packed::read_message(read, message::ReaderOptions::new());
   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `std::io::BufRead` does not have a constant size known at compile-time

The signature of read_message is:

pub fn read_message<R>(
    read: &mut R, 
    options: ReaderOptions
) -> Result<Reader<OwnedSegments>> 
where
    R: BufRead,

It appears that read is getting passed by value when it is a &mut BufRead and read_message is expecting a &mut BufRead. The only way to get this snippet to compile for me is changing this to:

fn parse_capnp(mut read: &mut BufRead) {
    let reader = serialize_packed::read_message(&mut read, message::ReaderOptions::new());
    Ok(())
}

I believe I am missing something simple about the types here. To me, this appears to pass a &mut &mut BufRead, which is not the expected type, but compiles.

Could someone add clarity to the types of read and t for the two examples?

I've looked at the following threads:

• Use of mut in function signature
• What are Rust's exact auto-dereferencing rules?

For the first thread, I'd say the comparison to C-style pointers is faulty due to the dereferencing rules that Rust applies.

Answer 1

Creating a Minimal, Complete, and Verifiable example that reproduces the problem is a useful step:

use std::io::BufRead;

pub fn read_message<R>(read: &mut R)
where
    R: BufRead,
{}

fn parse_capnp(read: &mut BufRead) {
    read_message(read);
}

fn main() {}

error[E0277]: the trait bound `std::io::BufRead: std::marker::Sized` is not satisfied
 --> src/main.rs:9:5
  |
9 |     read_message(read);
  |     ^^^^^^^^^^^^ `std::io::BufRead` does not have a constant size known at compile-time
  |
  = help: the trait `std::marker::Sized` is not implemented for `std::io::BufRead`
note: required by `read_message`
 --> src/main.rs:3:1
  |
3 | / pub fn read_message<R>(read: &mut R)
4 | | where
5 | |     R: BufRead,
6 | | {}
  | |__^

The error message is well covered in existing questions:

• Why does a generic method inside a trait require trait object to be sized?
• What does "Sized is not implemented" mean?
• Working with trait objects requiring sized
• Why is the `Sized` bound necessary in this trait?

TL;DR: trait objects aren't guaranteed to have a size, but generics have a Sized trait bound by default.

read is getting passed by value

Yes, everything in Rust is always passed by value. Sometimes that value happens to be a reference though.

read_message is expecting a &mut BufRead

It is not. It is expecting a generic type that implements the trait BufRead. These two signatures are different:

// Reference to a concrete type
pub fn read_message<R>(read: &mut R)
where
    R: BufRead,

// Trait object
pub fn read_message<R>(read: &mut BufRead)

See also:

• What is the difference between <T: Trait> Box<T> and &Trait / Box<Trait>?
• What makes something a "trait object"?

a &mut &mut BufRead, which is not the expected type

It's a perfectly cromulent type. BufRead is implemented for any mutable reference to any type that implements BufRead itself:

impl<'a, B: BufRead + ?Sized> BufRead for &'a mut B

Besides, in this case you don't have a &mut &mut BufRead, you have a &mut &mut R. The concrete monomorphization for the types you've shown is actually a &mut &mut Bufreader.

---

You can fix it by :

1. changing the read_message function to accept unsized types. This is fine since R is always behind a pointer:

   pub fn read_message<R>(read: &mut R)
   where
       R: ?Sized + BufRead,
   

2. changing the parse_capnp function to take a reference to a concrete type instead of a trait object:

   fn parse_capnp<R>(read: &mut R)
   where
       R: BufRead,
   {
       read_message(read);
   }
   

3. changing the parse_capnp function to take a concrete type instead of a trait object. You then need to take a reference to it yourself:

   fn parse_capnp<R>(mut read: R)
   where
       R: BufRead,
   {
       read_message(&mut read);
   }