From 53cc6e453b64c44016731dedfdb9fb956b681e05 Mon Sep 17 00:00:00 2001
From: "Jonathan B. Coe" <jonathanbcoe@gmail.com>
Date: Mon, 11 May 2026 16:07:00 +0100
Subject: [PATCH 1/3] Add presentation for lightning talk at C++ London

---
 presentations/protocol_2026_05_11.md | 217 +++++++++++++++++++++++++++
 1 file changed, 217 insertions(+)
 create mode 100644 presentations/protocol_2026_05_11.md

diff --git a/presentations/protocol_2026_05_11.md b/presentations/protocol_2026_05_11.md
new file mode 100644
index 0000000..01ab4f1
--- /dev/null
+++ b/presentations/protocol_2026_05_11.md
@@ -0,0 +1,217 @@
+---
+marp: true
+theme: default
+paginate: true
+size: 16:9
+#footer: https://github.com/jbcoe/cc-protocol
+---
+
+# Structural Subtyping for C++
+
+## [P4148R0](https://wg21.link/P4148R0)
+
+### 11 May 2026
+
+---
+
+# Introduction
+
+We propose adding two new class templates to the C++ Standard Library to support structural sub-typing at runtime:
+
+```c++
+template <typename T, typename Allocator = std::allocator<T>>
+class protocol;
+```
+
+```c++
+template <typename T>
+class protocol_view;
+```
+
+---
+
+# Polymorphism
+
+polymorphism (from the Greek for "many forms") is the ability of different objects to respond to the same function call in their own specific ways.
+
+C++ achieves polymorphism through mechanisms: Compile-time and Runtime.
+
+---
+
+# Compile-time Polymorphism
+
+Overloaded functions or function templates allow the compiler to detemrine which function to call during the build process:
+
+```c++
+double func(const A& a);
+double func(const B& b);
+double func(const C& c);
+```
+
+```c++
+<template typename T>
+double func(const T& t);
+```
+
+---
+
+# Runtime Polymorphism
+
+Inheritance-based polymorphism enables runtime dispatch by using base-class interfaces to invoke overridden virtual functions across an extensible, open set of derived types.
+
+```c++
+struct Shape {
+    virtual size_t sides() const = 0; 
+    virtual ~Shape() = default;
+};
+
+class Triangle : public Shape {
+public:
+    size_t sides() const override { return 3; }
+};
+
+class Square : public Shape {
+public:
+    size_t sides() const override { return 4; }
+};
+```
+
+---
+
+# Closed set Runtime Polymorphism
+
+In C++ we can use `std::variant` and `std::visit` to implement closed-set polymorphism: runtime dispatch over a predefined set of types. 
+
+```c++
+template<class... Ts> struct overload : Ts... { using Ts::operator()...; };
+
+...
+
+std::variant<int, std::string> myData = "Polymorphic String";
+
+std::visit(overload {
+    [](int val) { 
+        std::cout << "Processing int: " << val * 2 << "\n"; 
+    },
+    [](const std::string& val) { 
+        std::cout << "Processing string: " << val << " (length: " << val.size() << ")\n"; 
+    }
+}, myData);
+```
+
+---
+
+# Type erasure
+
+Type erasure enables runtime polymorphism for an open set of unrelated types.
+
+```c++
+class AnyDrawable {
+    struct Interface { 
+        virtual ~Interface() = default; 
+        virtual void draw() = 0; 
+    };
+
+    template<typename T> struct Model : Interface {
+        T d; Model(T t) : d(t) {}
+        void draw() override { d.draw(); }
+    };
+
+    Interface* i_;
+
+    void draw() { i_->draw(); }
+};
+```
+
+---
+
+# `polymorphic (C++26)` 
+
+C++ 26 introduces `polymorphic<T, A>`, a value-type which owns an object of a class derived from `T`.
+
+`polymorphic` is a value-type: only const qualified methods of the owned object can be accessed from a const-access path; copies have their own distinct, non-sliced, copies of the owned object.
+
+As it is an owning type, `polymorphic` takes a second template argument for the allocator.  If no allocator is specified, the default allocator will be used.
+
+`polymorphic` provides `operator->` and `operator*` to access the owned object.
+
+--- 
+
+# `protocol (Proposed addition)`
+
+The class template `protocol<T, A>` owns an object whose interface structurally subtypes the interface of the first template argument `T`.
+
+As it is an owning type, `protocol` takes a second template argument for the allocator.  If no allocator is specified, the default allocator will be used.
+
+`protocol` is a value-type: only const qualified methods of the owned object can be accessed from a const-access path; copies have their own distinct, non-sliced, copies of the owned object.
+
+`protocol<T>` has all of the member functions of `T` and forwards them to the owned object.
+
+---
+
+# `protocol_view (Proposed addition)`
+
+The class template `protocol_view<T>` is a non-owning view on an object whose interface structurally subtypes the interface of the template argument `T`.
+
+`protocol_view` can be cheaply copied and passed by value.
+
+`protocol<T>` has all of the member functions of `T` and forwards them to the viewed object.
+
+`protocol_view<const T>` can be used for const-only access to an object in a similar manner to `std::span`.
+
+---
+
+# Function-like objects
+
+C++ has a plethora of function-like type-erasing class templates.
+
+- `std::function` (C++11)
+- `std::function_ref` (C++26)
+- `std::move_only_function` (C++23)
+- `std::copyable_function` (C++26)
+
+Each of these can be implemented using `protocol<T>` or `protocol_view<T>` by defining a suitable `T`.
+
+---
+
+# Overload sets
+
+`protocol` and `protocol_view` can be used to implement an overload set that can be used as a class member or passed as a function argument.
+
+```c++
+struct OverloadedFunction {
+    R1 operator()(Args1&&... args) const;
+    R2 operator()(Args2&&... args);
+    R3 operator()(Args3&&... args);
+};
+```
+
+---
+
+# Indexed containers
+
+`protocol` and `protocol_view` can be used for indexed container access.
+
+```c++
+struct IndexedContainer<T> {
+    const T& operator[](size_t i) const;
+    T& operator[](size_t i);
+    size_t size() const;
+};
+```
+
+---
+
+# Implementation
+
+A reference implementation, using an AST-based Python code generator to simulate
+post-C++26 code injection, is available at <https://github.com/jbcoe/cc-protocol>. 
+
+There is an open PR to illustrate the work (currently) needed to add new types
+<https://github.com/jbcoe/cc-protocol/pull/53>
+
+--- 
+
+# Future work
+
+Future extensions to C++ reflection should allow `protocol` and `protocol_view` to be  implemented without the need for a custom build step.
\ No newline at end of file

From f372aa8bdc2e19736872fd262ade9adbbe8c6b99 Mon Sep 17 00:00:00 2001
From: "Jonathan B. Coe" <jonathanbcoe@gmail.com>
Date: Mon, 11 May 2026 16:12:20 +0100
Subject: [PATCH 2/3] Fix pre-commit issues

---
 presentations/protocol_2026_05_11.md | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/presentations/protocol_2026_05_11.md b/presentations/protocol_2026_05_11.md
index 01ab4f1..5f59968 100644
--- a/presentations/protocol_2026_05_11.md
+++ b/presentations/protocol_2026_05_11.md
@@ -61,7 +61,7 @@ Inheritance-based polymorphism enables runtime dispatch by using base-class inte
 
 ```c++
 struct Shape {
-    virtual size_t sides() const = 0; 
+    virtual size_t sides() const = 0;
     virtual ~Shape() = default;
 };
 
@@ -80,7 +80,7 @@ public:
 
 # Closed set Runtime Polymorphism
 
-In C++ we can use `std::variant` and `std::visit` to implement closed-set polymorphism: runtime dispatch over a predefined set of types. 
+In C++ we can use `std::variant` and `std::visit` to implement closed-set polymorphism: runtime dispatch over a predefined set of types.
 
 ```c++
 template<class... Ts> struct overload : Ts... { using Ts::operator()...; };
@@ -90,11 +90,11 @@ template<class... Ts> struct overload : Ts... { using Ts::operator()...; };
 std::variant<int, std::string> myData = "Polymorphic String";
 
 std::visit(overload {
-    [](int val) { 
-        std::cout << "Processing int: " << val * 2 << "\n"; 
+    [](int val) {
+        std::cout << "Processing int: " << val * 2 << "\n";
     },
-    [](const std::string& val) { 
-        std::cout << "Processing string: " << val << " (length: " << val.size() << ")\n"; 
+    [](const std::string& val) {
+        std::cout << "Processing string: " << val << " (length: " << val.size() << ")\n";
     }
 }, myData);
 ```
@@ -107,9 +107,9 @@ Type erasure enables runtime polymorphism for an open set of unrelated types.
 
 ```c++
 class AnyDrawable {
-    struct Interface { 
-        virtual ~Interface() = default; 
-        virtual void draw() = 0; 
+    struct Interface {
+        virtual ~Interface() = default;
+        virtual void draw() = 0;
     };
 
     template<typename T> struct Model : Interface {
@@ -125,7 +125,7 @@ class AnyDrawable {
 
 ---
 
-# `polymorphic (C++26)` 
+# `polymorphic (C++26)`
 
 C++ 26 introduces `polymorphic<T, A>`, a value-type which owns an object of a class derived from `T`.
 
@@ -135,7 +135,7 @@ As it is an owning type, `polymorphic` takes a second template argument for the
 
 `polymorphic` provides `operator->` and `operator*` to access the owned object.
 
---- 
+---
 
 # `protocol (Proposed addition)`
 
@@ -205,13 +205,13 @@ struct IndexedContainer<T> {
 # Implementation
 
 A reference implementation, using an AST-based Python code generator to simulate
-post-C++26 code injection, is available at <https://github.com/jbcoe/cc-protocol>. 
+post-C++26 code injection, is available at <https://github.com/jbcoe/cc-protocol>.
 
 There is an open PR to illustrate the work (currently) needed to add new types
 <https://github.com/jbcoe/cc-protocol/pull/53>
 
---- 
+---
 
 # Future work
 
-Future extensions to C++ reflection should allow `protocol` and `protocol_view` to be  implemented without the need for a custom build step.
\ No newline at end of file
+Future extensions to C++ reflection should allow `protocol` and `protocol_view` to be  implemented without the need for a custom build step.

From b0a2f92ec42bcc56b5abc8d0c3d9d4300663dedf Mon Sep 17 00:00:00 2001
From: "Jonathan B. Coe" <jonathanbcoe@gmail.com>
Date: Tue, 12 May 2026 12:14:10 +0100
Subject: [PATCH 3/3] Re-order polymorphic slide lines for consistency with
 following slide

---
 presentations/protocol_2026_05_11.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/presentations/protocol_2026_05_11.md b/presentations/protocol_2026_05_11.md
index 5f59968..9787ccb 100644
--- a/presentations/protocol_2026_05_11.md
+++ b/presentations/protocol_2026_05_11.md
@@ -129,10 +129,10 @@ class AnyDrawable {
 
 C++ 26 introduces `polymorphic<T, A>`, a value-type which owns an object of a class derived from `T`.
 
-`polymorphic` is a value-type: only const qualified methods of the owned object can be accessed from a const-access path; copies have their own distinct, non-sliced, copies of the owned object.
-
 As it is an owning type, `polymorphic` takes a second template argument for the allocator.  If no allocator is specified, the default allocator will be used.
 
+`polymorphic` is a value-type: only const qualified methods of the owned object can be accessed from a const-access path; copies have their own distinct, non-sliced, copies of the owned object.
+
 `polymorphic` provides `operator->` and `operator*` to access the owned object.
 
 ---