Metafunction for rule of zero

[JohelEGP]

The thread starting at #453 (comment)
demonstrates that it's not feasible to author Cpp2 types with the rule of zero.
You need either non-contextual knowledge of the members involved (so no luck with generic programming),
or attempt to simulate how the language does rule of zero, e.g.:

t: <A, B, C> type = {
  a: A = ();
  b: B = ();
  c: C = ();

  operator=: (out this) requires std::default_initializable<A>
                              && std::default_initializable<B>
                              && std::default_initializable<C> = { }
  operator=: (out this, that) requires std::copyable<A>
                                    && std::copyable<B>
                                    && std::copyable<C> = { }
  operator=: (out this, move that) requires std::movable<A>
                                         && std::movable<B>
                                         && std::movable<C> = { }
  operator=: (inout this, that) requires std::copy_assignable<A>
                                      && std::copy_assignable<B>
                                      && std::copy_assignable<C> = { }
  operator=: (inout this, move that) requires std::move_assignable<A>
                                           && std::move_assignable<B>
                                           && std::move_assignable<C> = { }
}

So I argue that we need a metafunction for the rule of zero.

[JohelEGP]

For my current use case (implementation inheritance),
if I don't need to wrap any constructor,
I can just make it a @struct to employ the rule of zero.
Then I save myself having to apply #453 (comment).

[JohelEGP]

Closing in favor of #665.