Границы признаков в признаках Fn

Единственное, что можно получить от замены BufWriter в подписи, — это ослабить гарантии вашего API, когда write_using_writer_a является общедоступным. Если вам это не нужно, оставьте BufWriter. Если да, то читайте дальше.

На самом деле вы не хотите, чтобы write_using_writer_a было слишком общим W. Это означало бы, что вызывающая сторона может решить, какой W использовать, но в вашем случае вам нужно принять функцию, которая принимает конкретную запись, но не хотите, чтобы вызывающая сторона знала, какую из них.

В Rust для этого уже есть синтаксис, который выглядит следующим образом:

fn write_using_writer_a<F>(file: &Path, f: F) -> Result<()>
where
    F: for<W: Write> Fn(W) -> Result<()>,

Это называется границей черты более высокого ранга (HRTB), но в настоящее время она работает только на протяжении всей жизни. Вместо этого вы можете создать свой собственный тип, который предоставляет только тот API, который вам нужен — признак Write — и заставить функцию использовать его.

pub struct WriteWrapper<'a>(&'a mut BufWriter<File>);

// implement all methods so that all behavior is preserved
impl Write for WriteWrapper<'_> {
    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
        self.0.write(buf)
    }
    fn flush(&mut self) -> std::io::Result<()> {
        self.0.flush()
    }
    fn write_vectored(&mut self, bufs: &[std::io::IoSlice<'_>]) -> std::io::Result<usize> {
        self.0.write_vectored(bufs)
    }
    fn write_all(&mut self, buf: &[u8]) -> std::io::Result<()> {
        self.0.write_all(buf)
    }
    fn write_fmt(&mut self, fmt: std::fmt::Arguments<'_>) -> std::io::Result<()> {
        self.0.write_fmt(fmt)
    }
}

fn write_using_writer_a<F>(file: &Path, f: F) -> Result<()>
where
    F: Fn(WriteWrapper) -> Result<()>,
{
    let file = File::create(file)?;
    let mut writer = BufWriter::new(file);
    f(WriteWrapper(&mut writer))?;
    writer.flush()?;
    Ok(())
}

Теперь вы можете сделать write_using_writer_a общедоступным, и изменение внутреннего BufWriter не будет кардинальным изменением.

Интересный факт: эта функция использует неявный HRTB на протяжении всей жизни WriteWrapper. Это эквивалентно этому:

fn write_using_writer_a<F>(file: &Path, f: F) -> Result<()>
where
    F: for<'a> Fn(WriteWrapper<'a>) -> Result<()>,

Вы пытаетесь сказать, что вызывающая сторона write_using_writer_a может предоставить замыкание, которое принимает некоторый тип W, который они выберут, но что бы они ни выбрали, вместо этого вы передадите &mut BufWriter<File>. Очевидно, это не может сработать.

Если вы не хотите называть BufWriter<File>, на самом деле вы хотите сказать, что вызывающая сторона write_using_writer_a должна предоставить замыкание, которое принимает некоторый тип W, который вы выбираете, и что им нужно знать только, что W реализует Write. В настоящее время это невозможно в стабильной версии Rust, но можно сделать каждую ночь, используя черту Impl в псевдонимах типов:

#![feature(type_alias_impl_trait)]

use std::fs::File;
use std::path::Path;
use std::io::{ BufWriter, Result, Write };

pub type MyWriter = impl Write;

pub fn write_using_writer_a<F>(file: &Path, f: F) -> Result<()> 
where
    F: Fn(&mut MyWriter) -> Result<()>,
{
    // let _ = ensure_dir(file)?;
    let file = File::create(file)?;
    let mut writer = BufWriter::new(file);
    let _ = f(&mut writer)?;
    writer.flush()?;
    Ok(())
}

Детская площадка

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

Для этого нам нужно создать типаж, который будет выполнять функцию:

trait MyFun {
    fn my_f<W: Write>(&self, w: W) -> Result<(), Error>;
}

Затем мы можем реализовать эту черту для «функций», которые мы отправляем в функцию:

struct ExampleFun;

impl MyFun for ExampleFun {
    fn my_f<W: Write>(&self, w: W) -> Result<(), Error> {
        todo!()
    }
}

Фактическая функция, использующая это:

fn write_using_writer_a<F>(file: &Path, f: F) -> Result<(), Error> 
where
    F: MyFun
{
    let file = File::create(file)?;
    let mut writer = BufWriter::new(file);
    let _ = f.my_f(&mut writer)?;
    writer.flush()?;
    Ok(())
}

И пример main:

fn main() {
    write_using_writer_a(Path::new("/test.txt"), ExampleFun).unwrap();
}

детская площадка