[tracking] fmt

[dignifiedquire]

When trying to implement io::Write::write_fmt, I ran into the issue that the implementation requires the use of a second Write trait, the one in fmt.

If we want to properly implement this, I believe an async version of that is required as well, which in turn triggers usages like implementing the write! macro in an async form.

Ref: #245 #131

Usage: https://github.com/rust-lang/rust/blob/master/src/libstd/io/mod.rs#L1412

Tracking List

Structs

• Arguments (re-export)
• DebugList (re-export)
• DebugMap (re-export)
• DebugSet (re-export)
• DebugStruct (re-export)
• DebugTuple (re-export)
• Error (re-export)
• Formatter (re-export)

Enums

• Alignment (re-export)

Traits

• Binary (re-export)
• Debug (re-export)
• Display (re-export)
• LowerExp (re-export)
• LowerHex (re-export)
• Octal (re-export)
• Pointer (re-export)
• UpperExp (re-export)
• UpperHex (re-export)
• Write

Functions

• fmt::format (re-export)
• fmt::write

Type Defintions

• Result (re-export)

[yoshuawuyts]

@dignifiedquire as we've talked about in chat, I agree with the reasoning here and we should indeed create a new fmt submodule.

I'll update your initial comment to include a list of things to port, and label this as a tracking issue.

I don't think we need an async version of std::fmt::Write because that trait is only implemented on String and Formatter, which are not async data structures.

The only part of fmt that could be asyncified, I think, is the std::fmt::write function. But it's not used that often in practice and we could just provide an async version of the write! macro instead.

[yoshuawuyts]

The only part of fmt that could be asyncified, I think, is the std::fmt::write function. But it's not used that often in practice and we could just provide an async version of the write! macro instead.

Just checked the signatures and I think I'm mostly agreeing here tbh. The macro seems relatively straight forward too: https://doc.rust-lang.org/src/core/macros.rs.html#388-390.

Okay yeah I'm on board with not implementing async_std::fmt, and relying on std::fmt::Write instead. As for the specific implementation here: I think we should probably write some custom code for the implementation as std::fmt::Write doesn't seem to appear in any signatures.

@dignifiedquire how does this sound?