Запутался в пересылке ссылки через несколько функций

Question

У меня проблемы с пониманием того, как ссылки передаются через функции.Кажется, что следующий сценарий компилируется должным образом:

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
}

Однако при использовании API для ящика capnp я получаю неожиданное поведение:

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

Подпись read_message:

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

Похоже, что read передается по значению, когда это &mut BufRead, а read_message ожидает &mut BufRead.Единственный способ заставить этот фрагмент для меня скомпилировать - это изменить его на:

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

Я полагаю, что упускаю что-то простое в типах здесь.Мне кажется, это передает &mut &mut BufRead, который не является ожидаемым типом, но компилируется.

Может ли кто-то добавить ясность в типы read и t для двух примеров?

Я просмотрел следующие темы:

• Использование mut в сигнатуре функции
• Что такое точный автоматический режим Rustправила разыменования?

Для первого потока я бы сказал, что сравнение с указателями в стиле C неверно из-за правил разыменования, применяемых Rust.

Answer 1

Создание Минимального, завершенного и проверяемого примера , воспроизводящего проблему, является полезным шагом:

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 | | {}
  | |__^

Сообщение об ошибке хорошо освещено в существующих вопросах:

• Почему универсальный метод внутри признака требует, чтобы размер объекта признака был измерен?
• Что означает "Размер не реализован"?
• Работа с объектами черт, требующими размера
• Почему для этой черты необходима граница Sized?

TL; DR: объекты признаков не гарантированно имеют размер, но у обобщенных элементов по умолчанию есть ограничение Sized.

read передается по значению

Да, все в Rust всегда передается по значению.Иногда это значение оказывается ссылкой.

read_message ожидает &mut BufRead

Это не так.Ожидается универсальный тип, который реализует черту BufRead.Эти две подписи различны:

// 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)

См. Также:

• В чем разница междуBox и & Trait / Box ?
• Что делает что-то «объектом черты»?

a &mut &mut BufRead, который не является ожидаемым типом

Это совершенно раскрашенный тип.BufRead - это , реализованный для любой изменяемой ссылки на любой тип, который сам реализует BufRead:

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

Кроме того, в этом случае у вас нет &mut &mut BufRead, выесть &mut &mut R.Конкретная мономорфизация для показанных вами типов - это на самом деле &mut &mut Bufreader.

---

. Вы можете исправить это следующим образом:

1. изменив функцию read_messageпринимать нестандартные типы.Это нормально, поскольку R всегда находится за указателем:

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

2. изменяя функцию parse_capnp так, чтобы она ссылалась на конкретный тип вместо объекта черты:

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

3. изменение функции parse_capnp для получения конкретного типа вместо объекта черты.Затем вам нужно взять ссылку на него самостоятельно:

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