Can a macro simplify trait impl?

Question

I want to simplify files and indention levels for implementing several Traits for a given struct. Is there a way I can do something like this?

struct Foo { /* ommitted */ }

impl(Default(Foo)) fn default() -> Self {
  /* do something */
}

Obviously, it is possible to write

impl Default for Foo {
  fn default() -> Self {
    /* do something */
  }
}

but the enclosing text provides no more value than the macro I hope exists. Although I am new to Rust, I am well aware of (and frequently use)

#[derive(Default)]

but I am looking for a way to simplify actually implementing many traits. I would consider the following clear as well, but AFAIK it is not legal Rust. Note that the following is similar to rust-lang #1250:

impl Foo {
  type Index::Output = Bar;
  trait Default fn default() -> Self {
    // ...
  }
  trait Debug fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    // ...
  }
  trait Display fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    // ...
  }
  trait Index<usize> fn index(&self, (r, c): (usize, usize)) -> &Self::Index::Output {
    // ...
  }
  fn my_custom_thing() -> () {
    // ...
  }
}

Answer 1

Whenever I tried something like this, I found that it was easier to just write out the impls.

Thus, I would advise against it. But if you insist, you could start out with the following:

macro_rules! quick_impl {
    ($structname: ident, Default, $($t:tt)*) => {
          impl Default for $structname {
              fn default() -> Self {
                  Self {$($t)*}
              }
          }
    };
    ($structname: ident, Debug, $($field:ident),*) => {
        impl std::fmt::Debug for $structname {
            fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
                f.debug_struct(stringify!($tyname))
                $(
                    .field(stringify!($field), &self.$field)
                )*
                .finish()
            }
        }
    };
    // here be more implementations
}

Usable like this:

struct S {
    a: usize,
    b: bool,
    c: char,
}

quick_impl!(S, Default, a:1, b:true, c:'c');
quick_impl!(S, Debug, a, b, c);

This macro goes a step further in that you do not have to say trait or fn in the arguments (as this is clear anyway).