A Deep Dive into Type Erasure Techniques

• 0:00:03 Introduction: The speaker introduces their interpretation of type erasure, inspired by Klaus, Archer O'Dwyer, and others.
• 0:00:24 Core Concept: The demonstration involves two independent classes, Cat and Dog, with no shared superclass or interface. Each has unique strategies for getting treats.
• 0:00:37 Strategies:
  • Cat uses meow and scratch (Strategy 1).
  • Dog uses sit and remembers the number of hairs shed (Strategy 2).
• 0:01:08 Smart Strategies: Strategies track the number of treats spent to avoid running out.
• 0:01:20 Goal: Create a vector of stateless, type-erased objects, matching each pet with a strategy (e.g., Rover with Strategy 2, Sleepy with Strategy 2), and call get_treat and get_petted for each.
• 0:01:49 Stateless Type Erasure Implementation:
  • Uses a "pimple" - a unique pointer to an interface.
  • The interface has a virtual destructor and pure virtual functions (get_treat, get_petted).
  • A templated Implementation class stores a copy of the object (Cat/Dog) and its strategy.
  • The constructor forwards the pet and strategy to the Implementation type.
  • get_treat and get_petted are forwarded through the pimple to the Implementation.
• 0:04:05 Philosophy: Similar to Smalltalk's "do as little as you can and know as little as you can."
• 0:04:22 Stateless Type Erasure in Action:
  • The StatelessTypeErasure class calls get_treat on the pimple.
  • The pimple, pointing to a vtable, calls the appropriate Implementation.
  • The Implementation uses the stored strategy and object.
• 0:06:31 Question and Answer: Clarifies that StatelessTypeErasure is the single point where independent classes are linked, and it makes copies of the objects and strategies.
• 0:07:25 Limitation: The original objects (e.g., Rover) don't participate directly in type erasure; their copies do. This prevents querying the original objects' states after they're part of the type-erased vector.
• 0:08:19 Stateful Type Erasure:
  • Introduces a StatefulTypeErasure to allow interaction with the original objects.
  • Implementation now stores shared pointers to the object and strategy.
  • get_treat and get_petted dereference these pointers.
  • A constructor macro determines if the input is a shared pointer and handles it accordingly.
• 0:11:44 Stateful Type Erasure Issues:
  • Three levels of indirection (one extra).
  • Objects must be created on the heap.
  • Passed objects cannot be shared pointers themselves (unless passed as a shared pointer to a shared pointer).
• 0:12:43 Advantage: Objects don't need to be copied or moved, useful for complex or uncopyable objects.
• 0:13:12 Question and Answer:
  • "Stateless" means the original object's state isn't tracked after type erasure.
  • Pimple is used to point to the vtable of any class, not necessarily a templated one.
  • "Interface" and "Implementation" were chosen for clarity over "Concept" and "Model."
  • The third indirection is the reference to the object.
• 0:17:22 Stateful Type Erasure Conclusion: The constructor either passes shared pointers directly or copies/moves objects into shared pointers.
• 0:18:02 Universal Type Erasure:
  • Aims to combine stateless and stateful approaches.
  • Copies non-shared pointer objects and uses shared pointers directly.
  • Uses a compile-time macro shared_pointer to differentiate.
  • Defines object and strategy functions to return a reference to the actual object, dereferencing shared pointers if necessary.
  • get_treat and get_petted use these functions.
• 0:20:54 Performance: The speed of the universal approach needs to be tested against stateless and stateful versions.
• 0:21:27 Q&A: Discusses the possibility of shared pointers within strategies and clarifies the evolution from two to three type erasure kinds.