Compile time code generation about dyno HOT 3 CLOSED

namespace dyno {
  constexpr std::meta::type vtable_layout_impl(std::meta::type interface) {
    auto vtable = reflexpr(struct { });
    for (auto method : interface.methods()) {
      // signature of the method, with void* as first argument
      auto signature = method.signature().insert_argument(0, reflexpr(void*));
      vtable.add_public_member(method.name(), method.add_ptr());
    }
    return vtable;
  }

  template <typename Interface>
  using vtable_layout_t = unreflexpr(vtable_layout_impl(reflexpr(Interface)));

  constexpr auto fill_vtable(std::meta::type interface, std::meta::type model) {
    vtable_layout_t<Interface> vtable;
    constexpr {
      for (auto method : interface) {
        // -> { vtable. (. method.name() .) = (. method.address() .) }
        vtable.unreflexpr(method.name()) = unreflexpr(method.address());
      }
    }
    return vtable;
  }

  template <typename Interface, typename Model>
  static constexpr vtable_layout_t<Interface> vtable_for =
                          fill_vtable(reflexpr(Interface), reflexpr(Model));
}

template <typename Signature>
struct Callable;

template <typename R, typename ...Args>
struct Callable<R(Args...)> {
  R operator()(Args...) const;
  ~Callable();
};

template <typename Signature>
class function

template <typename R, typename ...Args>
class function<R(Args...)> {
  using VTable = dyno::vtable_layout_t<Callable<R(Args...)>>;
  VTable* vtable_;
  void* storage_;

public:
  template <typename Function>
  function(Function f)
    : vtable_{&dyno::vtable_for<Callable≤...≥, Function>}
    , storage_{new Function{f}}
  { }

  R operator()(Args ...args) const {
    return vtable_->operator()(storage_, args...);
  }

  ~function() {
    vtable_->~???(storage_);
  }
};