如何在选项中引用特征对象？

Question

我想在结构中的Option 中存储对io::Write 特征对象的引用，但我不知道如何。我可以像这样直接把引用放进去：

pub struct Parameters<'a> {
    pub log: &'a (io::Write + 'a),
    // Other elements removed
}

然后从（例如）BufWriter 分配它，如下所示：

let logstream = &BufWriter::new(f);
let parameters = Parameters {
    log: logstream, // Other elements removed
};

这可行，但我希望 logstream 是可选的。如果我尝试：

pub struct Parameters<'a> {
    pub log: Option<&'a(io::Write + 'a)>,
    // Other elements removed
}

和

let logstream = match f {
    Some(f) => Some(&BufWriter::new(f)),
    None => None,
};

let parameters = Parameters {
    log: logstream,
    // Other elements removed
};

我明白了：

error[E0308]: mismatched types
  --> src/main.rs:17:14
   |
17 |         log: logstream,
   |              ^^^^^^^^^ expected trait std::io::Write, found struct `std::io::BufWriter`
   |
   = note: expected type `std::option::Option<&dyn std::io::Write>`
              found type `std::option::Option<&std::io::BufWriter<std::vec::Vec<u8>>>`

这里有什么合适的方法？

Answer 1

您必须以某种方式显式键入带有 trait 类型的 BufWriter，并且您还必须更加小心生命周期。

这是如何工作的草图：

use std::io;
use std::io::BufWriter;
use std::str::from_utf8;

pub struct Parameters<'a> {
    pub log: Option<&'a mut io::Write>,
    // Other elements removed
}

fn main() {
    let mut w = BufWriter::new(Vec::new());
    let rw: &mut std::io::Write = &mut w;
    let logstream = Some(rw);

    let parameters = Parameters {
        log: logstream,
        // Other elements removed
    };
    parameters.log.unwrap().write(b"hello world").ok();

    println!("{}", from_utf8(&w.into_inner().unwrap()).unwrap());
}

Answer 2

use std::io;
use std::io::BufWriter;

pub struct P<'a> {
    pub log: Option<&'a mut io::Write>,
}

fn file() -> Option<Vec<u8>> {
    Some(Vec::new())
}

fn main() {
    let mut ow = file().map(|f| BufWriter::new(f));
    let p = P {
        log: ow.as_mut().map(|w| w as &mut io::Write),
    };

    p.log.unwrap().write(b"Hi!").ok();

    println!(
        "{}",
        String::from_utf8(ow.unwrap().into_inner().unwrap()).unwrap()
    );
}

与其采用Option<W> 并尝试将其一次性转换为Option<&mut io::Write>，不如分三步完成：

• Option<W> -> Option<io::BufWriter<W>> 使 ow。这就是拥有BufWriter 的东西。正如另一个答案中所指出的，如果您尝试在模式匹配中创建一个BufWriter，然后立即对其进行引用，则该引用的生命周期范围在模式匹配的分支内，因此借用检查器会抱怨。
• 下一步是使用as_mut() 将Option<io::BufWriter<W>> 转换为Option<&mut io::BufWriter<W>>。
• 最终从对实现的引用转换为通用特征对象。在这种情况下，地图包含演员表。我曾尝试使用into，但似乎没有实现在对特征的实现者的引用和对特征对象的引用之间进行转换。

在本例中，file() 返回 Vec<u8> 作为底层编写器，我这样做是为了解决方案是 testable in a Rust playground，但这也可以是 File。

最后，我删除了 trait 对象的生命周期约束，类型系统/借用检查器似乎认为没有必要。

Answer 3

感谢以上回答。在他们发布之前，我自己有一个想法并想出了这个（简化为一个或多或少显示我正在尝试做的事情的最小示例）：

use std::{env, process};
use std::fs::File;
use std::io::{self, BufWriter};

pub struct Parameters {
    pub log: Option<Box<dyn io::Write>>,
}


fn main() {
    let args: Vec<String> = env::args().collect();
    let logfile = if args.len() > 1 {
        Some(&args[1])
    } else {
        None
    };

    let logstream: Option<Box<dyn io::Write>> = match logfile {
        Some(logfile) => {
            let f = File::create(logfile).unwrap_or_else(|err| {
                eprintln!("ERROR opening logfile: {}", err);
                process::exit(1);
            });
            let logstream = BufWriter::new(f);
            Some(Box::new(logstream))
        }
        None => {
            None
        },
    };

    let parameters = Parameters {
        log: logstream,
    };
    play(parameters);
}

fn play(parameters: Parameters) {
    // Rest of code removed
    if let Some(mut stream) = parameters.log {
        stream.write("Testing\n".as_bytes()).unwrap_or_else(|err| {
            eprintln!("ERROR writing to logfile: {}", err);
            process::exit(1);
        });
    }
}

这是一个好的解决方案还是上面建议的其中一个更好？