Type Erasure: Value-Based Polymorphism Without Inheritance

// Classical polymorphism: callers must inherit
struct IDrawable {
    virtual void draw() const = 0;
    virtual ~IDrawable() = default;
};

struct Circle : IDrawable {      // must derive
    void draw() const override { /* ... */ }
};

void render(const IDrawable& d) { d.draw(); }

// Type erasure: no inheritance required
struct AnyDrawable {
    template<typename T> AnyDrawable(T obj);   // wraps anything with .draw()
    void draw() const;                         // non-virtual public interface
};

struct Square { void draw() const { /* ... */ } };  // no base class

AnyDrawable d{Square{}};   // just works — Square never heard of AnyDrawable
d.draw();

// Step 1: define the "affordances" — what callers need to do with the erased type
struct IConcept {
    virtual void draw() const = 0;
    virtual std::unique_ptr<IConcept> clone() const = 0;  // if copyable
    virtual ~IConcept() = default;
};

// Step 2: adapt any T to IConcept
template<typename T>
struct Model : IConcept {
    T obj_;
    explicit Model(T obj) : obj_(std::move(obj)) {}
    void draw() const override { obj_.draw(); }
    std::unique_ptr<IConcept> clone() const override {
        return std::make_unique<Model>(obj_);
    }
};

// Step 3: the public type-erased wrapper
class AnyDrawable {
    std::unique_ptr<IConcept> pimpl_;

public:
    template<typename T>
    AnyDrawable(T obj)
        : pimpl_(std::make_unique<Model<T>>(std::move(obj)))
    {}

    // Copyable because IConcept has clone():
    AnyDrawable(const AnyDrawable& other)
        : pimpl_(other.pimpl_->clone())
    {}

    AnyDrawable(AnyDrawable&&) noexcept = default;

    void draw() const { pimpl_->draw(); }
};

struct Circle  { void draw() const { /* ... */ } };
struct Square  { void draw() const { /* ... */ } };
struct Texture { void draw() const { /* ... */ } };

std::vector<AnyDrawable> scene;
scene.emplace_back(Circle{});
scene.emplace_back(Square{});
scene.emplace_back(Texture{});

for (const auto& d : scene) d.draw();   // runtime dispatch without virtual base

#include <functional>

std::function<int(int)> f;

// Stores a lambda — heap-allocated internally (may be SBO for small lambdas)
f = [capture = large_data](int x) { return x + capture.value; };

// Stores a function pointer — no allocation, stored directly
f = &some_free_function;

// Stores a member function via bind:
f = [&obj](int x) { return obj.method(x); };

#include <any>

std::any a = 42;
std::any b = std::string{"hello"};

// Type-checked get:
int v = std::any_cast<int>(a);       // throws std::bad_any_cast if wrong type
int* p = std::any_cast<int>(&a);     // returns nullptr if wrong type (no throw)

// Check stored type:
if (a.type() == typeid(int)) { /* ... */ }

// Erase:
a.reset();            // a is now empty
a.has_value();        // false

// Conceptual layout of std::function:
struct FunctionStorage {
    alignas(std::max_align_t) char sbo_buf[sizeof(void*) * 3];  // ~24 bytes
    void* heap_ptr;      // used when SBO is too small
    FunctionVtable* vt;  // destroy, call, copy, move
};

class AnyCallable {
    static constexpr std::size_t SBO_SIZE = 32;
    alignas(std::max_align_t) std::byte sbo_[SBO_SIZE];
    bool on_heap_ = false;
    IConcept* concept_ptr_ = nullptr;

    template<typename T>
    void store(T obj) {
        if constexpr (sizeof(Model<T>) <= SBO_SIZE &&
                      alignof(Model<T>) <= alignof(std::max_align_t) &&
                      std::is_nothrow_move_constructible_v<T>) {
            // In-place: no heap allocation
            new (&sbo_) Model<T>(std::move(obj));
            concept_ptr_ = reinterpret_cast<IConcept*>(&sbo_);
            on_heap_ = false;
        } else {
            // Heap allocation for large/throwing objects
            auto* p = new Model<T>(std::move(obj));
            concept_ptr_ = p;
            on_heap_ = true;
        }
    }
    // ... destructor must check on_heap_ before delete
};

#include <functional>

auto make_handler = [](std::unique_ptr<Resource> r) {
    return std::move_only_function<void()>{
        [res = std::move(r)]() { res->handle(); }
    };
};

std::move_only_function<void()> h = make_handler(std::make_unique<Resource>());
h();
// Can be moved:
auto h2 = std::move(h);
// Cannot be copied:
// auto h3 = h2;   // compile error

// In shared library header (no templates crossing the boundary):
class EXPORT_API AnyRenderer {
    struct IConcept;
    std::unique_ptr<IConcept> impl_;
public:
    template<typename T>
    AnyRenderer(T r) : impl_(make_model(std::move(r))) {}  // templated constructor: caller-side
    void render(Frame&) const;
};

// In shared library .cpp:
void AnyRenderer::render(Frame& f) const {
    impl_->render(f);  // virtual dispatch through stable IConcept interface
}

#include <any>
#include <cstdio>

// Small type — stored inline, no heap allocation:
struct SmallTag { int id; };
// sizeof(SmallTag) == 4, is_nothrow_move_constructible == true → inline

// Large type — heap-allocated by std::any:
struct LargeData { char buf[128]; };
// sizeof(LargeData) == 128 → heap

std::any a = SmallTag{42};    // inline: std::any is on the stack, no malloc
std::any b = LargeData{};     // heap: std::any object holds a pointer internally

// What libc++ does internally (simplified):
union Storage {
    alignas(alignof(void*)) char buf[sizeof(void*) * 3]; // inline storage
    void* ptr;                                            // heap pointer
};

struct VTable {
    void (*destroy)(Storage&);
    void (*copy)(Storage& dst, const Storage& src);
    void (*move)(Storage& dst, Storage& src) noexcept;
};

// Each type T that goes into std::any gets a VTable instantiation:
template<typename T>
struct AnyOps {
    static constexpr bool use_inline =
        sizeof(T) <= sizeof(Storage::buf) &&
        alignof(T) <= alignof(void*) &&
        std::is_nothrow_move_constructible_v<T>;

    static void destroy(Storage& s) {
        if constexpr (use_inline)
            reinterpret_cast<T*>(s.buf)->~T();
        else
            delete static_cast<T*>(s.ptr);
    }
};

#include <functional>
#include <memory>

// Fails with std::function — lambda is not copyable:
// std::function<void()> bad = [p = std::make_unique<int>(42)]() { /* ... */ };

// Works with std::move_only_function:
std::move_only_function<void()> ok =
    [p = std::make_unique<int>(42)]() { *p += 1; };

ok();              // call it
auto ok2 = std::move(ok);   // move it — ok is now empty
ok2();

// Attempting to copy is a compile error:
// auto ok3 = ok2;  // error: copy constructor is deleted

// Requires the stored callable to be const-callable:
std::move_only_function<int() const> f = []() { return 42; };

// A mutable lambda cannot satisfy "const" — compile error if uncommented:
// int x = 0;
// std::move_only_function<int() const> g = [x]() mutable { return x++; };

#include <functional>

// Source 1: Heap allocation on construction
// If the callable exceeds the SBO buffer (~24–32 bytes), std::function
// calls operator new. Benchmark: ~50-100 ns one-time cost.
auto big_lambda = [a=1,b=2,c=3,d=4,e=5,f=6](int x) { return a+b+c+d+e+f+x; };
std::function<int(int)> fn = big_lambda;  // heap alloc (6×int = 24 bytes, borderline)

// Source 2: Indirect call (virtual dispatch)
// Every invocation goes through a function pointer stored in the vtable.
// Branch predictor can warm up if the same callable is called repeatedly;
// it fails for heterogeneous dispatch. Benchmark: +5-15 ns per call.
fn(42);

// Source 3: Type-check on assignment (not on call — common misconception)
// The type check happens when you assign a new callable, not when you call.
// Assignment is O(1) but does require RTTI lookup if you use target<T>().

// Source 4: Pointer indirection through the stored callable's state
// If the callable itself holds a pointer (e.g., a captured reference or
// pointer-to-member), that's an extra indirection on top of the vtable call.

// Dyno-style pseudocode (simplified from the actual library API):
#include <dyno.hpp>

// 1. Define the "concept" as a dyno::requires_:
struct Drawable : decltype(dyno::requires_(
    dyno::CopyConstructible{},
    "draw"_s = dyno::method<void() const>
)) {};

// 2. Define how types map to the concept's methods:
template<typename T>
auto const dyno::concept_map<Drawable, T> = dyno::make_concept_map(
    "draw"_s = [](const T& t) { t.draw(); }
);

// 3. The type-erased poly type uses the vtable strategy as a template parameter:
using LocalVtable  = dyno::poly<Drawable, dyno::local_storage<32>>;
using RemoteVtable = dyno::poly<Drawable, dyno::remote_storage<>>;

struct Circle { void draw() const { /* ... */ } };
struct Square { void draw() const { /* ... */ } };

LocalVtable  c{Circle{}};  // vtable stored inline alongside object data
RemoteVtable s{Square{}};  // vtable stored separately, object heap-allocated
c.virtual_("draw"_s)();

// plugin_api.h — shared between host and all plugins (C-compatible layout):
#ifdef __cplusplus
extern "C" {
#endif

typedef struct {
    void* obj;                          // opaque pointer to the plugin object
    void  (*render)(void* obj, int w, int h);
    void  (*update)(void* obj, float dt);
    void  (*destroy)(void* obj);        // plugin manages its own lifetime
} PluginVTable;

// Plugin entry point — must be exported with C linkage:
typedef PluginVTable (*PluginFactory)(void);

#ifdef __cplusplus
}  // extern "C"
#endif

// plugin.cpp — compiled independently, possibly with a different compiler:
#include "plugin_api.h"

class MyPlugin {
public:
    void render(int w, int h) { /* ... */ }
    void update(float dt)     { /* ... */ }
};

extern "C" PluginVTable create_plugin() {
    auto* p = new MyPlugin{};
    return PluginVTable{
        .obj     = p,
        .render  = [](void* o, int w, int h) { static_cast<MyPlugin*>(o)->render(w, h); },
        .update  = [](void* o, float dt)     { static_cast<MyPlugin*>(o)->update(dt); },
        .destroy = [](void* o) { delete static_cast<MyPlugin*>(o); },
    };
}

// host.cpp — wraps the raw table in a safe RAII type:
#include "plugin_api.h"
#include <dlfcn.h>

class Plugin {
    PluginVTable vt_;
public:
    explicit Plugin(PluginVTable vt) : vt_{vt} {}
    ~Plugin() { vt_.destroy(vt_.obj); }

    Plugin(const Plugin&)            = delete;
    Plugin& operator=(const Plugin&) = delete;
    Plugin(Plugin&&)                 = default;

    void render(int w, int h) { vt_.render(vt_.obj, w, h); }
    void update(float dt)     { vt_.update(vt_.obj, dt); }
};

Plugin load_plugin(const char* path) {
    void* lib = dlopen(path, RTLD_LAZY);
    auto* factory = reinterpret_cast<PluginFactory>(dlsym(lib, "create_plugin"));
    return Plugin{factory()};
}

// Benchmark setup (Google Benchmark style):
#include <benchmark/benchmark.h>
#include <functional>
#include <memory>
#include <vector>

struct Base { virtual int work(int x) = 0; virtual ~Base() = default; };
struct Derived : Base { int work(int x) override { return x * 2 + 1; } };

// 1. Virtual dispatch through pointer:
static void BM_Virtual(benchmark::State& state) {
    std::vector<std::unique_ptr<Base>> objs;
    for (int i = 0; i < 1000; ++i) objs.push_back(std::make_unique<Derived>());
    int sum = 0;
    for (auto _ : state)
        for (auto& p : objs) benchmark::DoNotOptimize(sum += p->work(sum));
}

// 2. Type-erased via std::function:
static void BM_StdFunction(benchmark::State& state) {
    std::vector<std::function<int(int)>> fns;
    for (int i = 0; i < 1000; ++i)
        fns.push_back([](int x) { return x * 2 + 1; });
    int sum = 0;
    for (auto _ : state)
        for (auto& f : fns) benchmark::DoNotOptimize(sum += f(sum));
}

// 3. Template (static dispatch — can be inlined):
static void BM_Template(benchmark::State& state) {
    auto work = [](int x) { return x * 2 + 1; };
    int sum = 0;
    for (auto _ : state)
        for (int i = 0; i < 1000; ++i) benchmark::DoNotOptimize(sum += work(sum));
}

BENCHMARK(BM_Virtual);
BENCHMARK(BM_StdFunction);
BENCHMARK(BM_Template);