FEATURE: `format!` macro equivalent

[JakubKoralewski]

What do you think of having a format_tiny! macro? I could try it.

It would probably look a bit different as I think the string based "{}" approach is a compiler intrinsic.

[ThatsNoMoon]

Sorry for the delay (I thought I would get notifications for this repo); that sounds like a solid addition to me. I think it should be fairly easy to implement as TinyString/ArrayString already implement std::fmt::Write. Such a macro should also allow specification of the type of backing array to use, like tinyvec's macros do.

The naming seems like it might be the most difficult part, my initial thought was tiny_format! and array_format!, but I'm not sure if there are better options or not.

I'll get to this when I have some more free time, otherwise I'll try to review any PRs ASAP.

[2moe]

My idea was something like format_args!("{fmt}") |> TinyString::format (pseudocode), so that we wouldn’t have to create a new macro.

I’m no longer using this crate, but I hope the code below can be helpful to others.

use core::{fmt, fmt::Write};

use tinyvec_string::TinyString;

/// ## Example
///
/// ```
/// let s: TString<5> = "Hello".into();
/// assert_eq!(s, "Hello");
/// ```
pub type TString<const N: usize> = TinyString<[u8; N]>;

pub trait Formattable<const N: usize>: Write {
  fn format(fmt_args: fmt::Arguments) -> Result<Self, fmt::Error>
  where
    Self: core::marker::Sized;
}

impl<const N: usize> Formattable<N> for TString<N> {
  /// Formats a new `TString` with the generic parameter `const N` (representing
  /// the inline byte size). If the capacity is exceeded, it will overflow to
  /// the heap.
  ///
  /// ## Example
  ///
  /// ```
  /// use tap::Pipe;
  /// // use crate::TString;
  /// // use crate::Formattable;
  ///
  /// let s = format_args!("Hello, {name}!", name = "World")
  ///   .pipe(TString::<16>::format);
  /// assert_eq!(s.as_deref(), Ok("Hello, World!"));
  /// assert_eq!(s.map(|x| x.is_inline()), Ok(true))
  /// ```
  fn format(fmt_args: fmt::Arguments) -> Result<Self, fmt::Error> {
    let mut output = TString::new();
    output.write_fmt(fmt_args)?;
    Ok(output)
  }
}