Beautiful Type Erasure with C++26 Reflection

The article introduces rjk::duck, a C++26 library that aims to revolutionize type erasure by leveraging new reflection capabilities, promising to eliminate boilerplate while maintaining customization and performance. It details how C++26 reflection can simplify complex type-erasure patterns.

• rjk::duck replaces verbose type erasure implementations like Boost.TypeErasure with a single-header library, using C++26 reflection.
• It utilizes annotations like [[=rjk::trait]] to define interfaces, which are then processed by reflection features (^^, members_of, annotations_of) to generate internal "tags."
• Code generation for vtables is achieved via consteval blocks and the new splice operator [: expr :], dynamically creating function pointers based on trait members.
• Overload resolution is cleverly managed by generating overload_set objects for each function, allowing the compiler to handle dispatch rather than manual re-implementation.
• A key optimization, the "pointer-interconvertibility trick," reduces duck object size by allowing reinterpret_cast between base and derived objects in standard layout types, effectively vanishing the this pointer for vtable_function objects.
• Performance tuning options allow for inlining specific function pointers directly into the duck object to avoid cold vtable lookups, trading object size for direct call efficiency.
• Many components are constexpr by design, hinting at future compile-time type erasure once C++ standards evolve further.

The author asserts that rjk::duck demonstrates reflection's power beyond simple code generation, enabling shorter, safer, and highly tunable solutions for complex problems like type erasure without runtime overhead.