Angenommen, ich möchte "Erase" mit "Erasure" eingeben.

Ich kann Pseudomethoden für Varianten erstellen, die ein natürliches Verhalten ermöglichen:

pseudo_method print = [](auto&& self, auto&& os){ os << self; };

std::variant<A,B,C> var = // create a variant of type A B or C

(var->*print)(std::cout); // print it out without knowing what it is

Meine Frage ist, wie kann ich dies auf ein @ erweitestd::any?

Es kann nicht "im Rohzustand" gemacht werden. Aber an dem Punkt, an dem wir ein @ zuweisen / konstruierstd::any Wir haben die Typinformationen, die wir brauchen.

Also, in der Theorie, ein Augmentedany:

template<class...OperationsToTypeErase>
struct super_any {
  std::any data;
  // or some transformation of OperationsToTypeErase?
  std::tuple<OperationsToTypeErase...> operations;
  // ?? what for ctor/assign/etc?
};

könnte irgendwie automatisch einen Code neu binden, so dass die obige Art von Syntax funktionieren würde.

Idealerweise wäre es im Gebrauch so knapp, wie es in der Variante der Fall ist.

template<class...Ops, class Op,
  // SFINAE filter that an op matches:
  std::enable_if_t< std::disjunction< std::is_same<Ops, Op>... >{}, int>* =nullptr
>
decltype(auto) operator->*( super_any<Ops...>& a, any_method<Op> ) {
  return std::get<Op>(a.operations)(a.data);
}

Now kann ich dies zu einem @ haltAr, doch vernünftigerweise die Lambda-Syntax verwenden, um die Dinge einfach zu halten?

ch möchte:

any_method<void(std::ostream&)> print =
  [](auto&& self, auto&& os){ os << self; };

using printable_any = make_super_any<&print>;

printable_any bob = 7; // sets up the printing data attached to the any

int main() {
  (bob->*print)(std::cout); // prints 7
  bob = 3.14159;
  (bob->*print)(std::cout); // prints 3.14159
}

oder ähnliche Syntax. Ist das unmöglich? Undurchführbar? Einfach