Add fmt::Write to io::Write adapter

[SUPERCILEX]

Proposal

Problem statement

There is no easy way to use fmt::Write to write bytes to an io stream.

Motivation, use-cases

If you know the format data you'll be creating must always be valid utf8, then you should use the fmt::Write trait. Unfortunately, it is harder than necessary to then lower that data down into a byte stream.

This basically comes down to being able to interchangeably use a String buffer or a io::stdout() buffer (for example). You could argue that you should use a Vec<u8> and then convert it to a string, but now you've lost the type safety of guaranteed utf8.

Solution sketches

rust-lang/rust#104389

The big open question is error handling, but I don't believe this needs to be addressed while the feature is unstable.

API:

struct FmtWriteAdapter<'a, W: Write + ?Sized> { ... }

impl FmtWriteAdapter {
    pub fn err(&self) -> &Option<Error>
    pub fn mut_err(&mut self) -> &mut Option<Error>
}

impl<W: Write + ?Sized> fmt::Write for FmtWriteAdapter<'_, W>

impl io::Write {
  fn fmt_adapter(&mut self) -> FmtWriteAdapter<'_, Self> where Self: Sized
}

Usage:

let mut output1 = String::new();
let mut output2 = io::stdout();

my_common_writer(&mut output1).unwrap();
my_common_writer(&mut output2.fmt_adapter()).unwrap();

fn my_common_writer(output: &mut impl fmt::Write) -> fmt::Result {
    writeln!(output, "Hello World!")
}

Links and related work

Existing issue: rust-lang/rust#77733

Note: the other direction (i.e. writing through an io stream to a format stream) does not make sense because the data does not have to be utf8. Even it was and error handling could be taken care of, the window of data the io stream is currently viewing may not be aligned to valid utf8 data, meaning the data may actually be utf8 but the order in which the writes appeared made the data invalid.

[Noratrieb]

rust-lang/rust#77733 (comment) mentions that this is a breaking change, because someone could implement fmt::Write and io::Write for their type and adding the blanket impl breaks this.
So I don't think this can be done.

[SUPERCILEX]

Hence why I went the adapter route. To be clear, this is NOT a blanket impl. From the docs in my PR:

/// #![feature(impl_fmt_write_for_io_write)]
/// # use std::{fmt, io};
/// # use std::io::FmtWriteAdapter;
///
/// let mut output1 = String::new();
/// let mut output2 = io::stdout();
/// let mut output2 = FmtWriteAdapter::from(&mut output2);
///
/// my_common_writer(&mut output1).unwrap();
/// my_common_writer(&mut output2).unwrap();
///
/// fn my_common_writer(output: &mut impl fmt::Write) -> fmt::Result {
///     writeln!(output, "Hello World!")
/// }

[Noratrieb]

Oh, I misread that, oops.

[the8472]

Solution sketches

Neither this issue nor the linked PR outline the actual proposed APIs.

[SUPERCILEX]

Right, my bad. I added a simplified version of the API. @Nilstrieb @the8472 is that clear?

[the8472]

Using From might not be the most ergonomic thing. Having a defaulted method on the io::Write trait could produce this struct more ergonomically.

[Noratrieb]

From<&mut io::Write> should this be a generic? But I agree that From isn't very good for this

[SUPERCILEX]

Having a defaulted method on the io::Write trait could produce this struct more ergonomically.

Oooh, that's a neat idea. Updated the proposed API and PR.

@Nilstrieb Yeah, it's generic but I thought that would be noise. The API now has the full definitions.

[SUPERCILEX]

Updated the proposed API and PR.

Oh, I should note that I couldn't figure out a way to include the fmt_adapter method on the io::Write trait directly due to object safety, hence the extra conversion trait.

[the8472]

putting where Self: Sized on the method should work, you can find examples of that on Iterator.

[SUPERCILEX]

Wouldn't we not want that though? Otherwise I don't think you'd be able to write to an &mut [u8]. Or am I getting confused?

[sfackler]

If you know the format data you'll be creating must always be valid utf8, then you should use the fmt::Write trait.

Why?