interop with Boost.TypeErasure

.drone.jsonnet

@@ -297,14 +297,27 @@ local windows_pipeline(name, image, environment, arch = "amd64") =
         "clang-18",
     ),
 
+    # One C++ standard per stage: the Catalina runner is the slowest in the
+    # fleet, and 17,2a in a single stage was killed at Drone's 60-minute step
+    # timeout, halfway into the second standard.
     macos_pipeline(
-        "MacOS 10.15 Xcode 12.2 UBSAN",
-        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '17,2a' } + ubsan,
+        "MacOS 10.15 Xcode 12.2 UBSAN C++17",
+        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '17' } + ubsan,
     ),
 
     macos_pipeline(
-        "MacOS 10.15 Xcode 12.2 ASAN",
-        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '17,2a' } + asan,
+        "MacOS 10.15 Xcode 12.2 UBSAN C++2a",
+        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '2a' } + ubsan,
+    ),
+
+    macos_pipeline(
+        "MacOS 10.15 Xcode 12.2 ASAN C++17",
+        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '17' } + asan,
+    ),
+
+    macos_pipeline(
+        "MacOS 10.15 Xcode 12.2 ASAN C++2a",
+        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '2a' } + asan,
     ),
 
     macos_pipeline(

CLAUDE.md

@@ -159,6 +159,39 @@ Tests require these C++17 features (checked by Boost.Build):
 - structured bindings
 - `<charconv>`, `<string_view>`, `<variant>` headers
 
+### Documentation (AsciiDoc)
+
+Prose lives in `doc/modules/ROOT/pages/*.adoc`; explanations belong there, not in comments inside
+the example sources under `doc/modules/ROOT/examples/`, which are pulled into the rendered page
+verbatim through `include::example$file.cpp[tag=content]`. Pages hard-wrap at ~79 columns and use
+`cpp:name[]` for API names that have a reference page.
+
+**Render the docs; do not just eyeball the `.adoc`.** `doc/build_antora.sh` (~2 min, writes the
+gitignored `doc/html/`) is the only way to catch markup that is silently mis-parsed — asciidoctor
+emits no warning for it.
+
+**The backtick-apostrophe trap**: never write a possessive right after a code span. Asciidoctor
+parses ``` `any`'s ``` as `` ` `` + `any` + the **`` `' `` curly-apostrophe shorthand**, which
+consumes the *closing* backtick; the opening one is then left unmatched and pairs with the next
+backtick in the same paragraph. Two things break at once — a literal `` ` `` appears in the output,
+and the following code span loses its `<code>` formatting:
+
+```
+source:   is part of the `any`'s type - whereas the `typeid_of`-based dispatch above
+rendered: is part of the any's type - whereas the `typeid_of-based dispatch above
+```
+
+Reword instead: "the reference types of the `any`", "separate from that of `default_registry`".
+``{apos}`` also works and matches the house style (`shared_libraries.adoc` uses ``{empty}`` for
+plurals: ``` `virtual_ptr`{empty}s ```), but rewording is safer and reads better. Before building:
+
+```bash
+grep -rn "\`'" doc/modules/ROOT/pages/*.adoc    # must return nothing
+```
+
+After building, no stray backticks should survive outside code blocks —
+`grep -n '\`' doc/html/openmethod/<page>.html` should only hit backticks inside C++ comments.
+
 ## Common Development Patterns
 
 ### Working with Shared Libraries / DLL Support

CMakeLists.txt

@@ -94,6 +94,8 @@ set(
 
 if (BOOST_OPENMETHOD_BUILD_TESTS OR BOOST_OPENMETHOD_MRDOCS_BUILD)
     list(APPEND BOOST_OPENMETHOD_DEPENDENCIES Boost::smart_ptr)
+    list(APPEND BOOST_OPENMETHOD_DEPENDENCIES Boost::any)
+    list(APPEND BOOST_OPENMETHOD_DEPENDENCIES Boost::type_erasure)
 endif()
 
 foreach (BOOST_OPENMETHOD_DEPENDENCY ${BOOST_OPENMETHOD_DEPENDENCIES})

doc/modules/ROOT/examples/type_erasure.cpp

@@ -0,0 +1,67 @@
+// Copyright (c) 2018-2026 Jean-Louis Leroy
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// clang-format off
+
+// tag::content[]
+#include <iostream>
+#include <string>
+
+#include <boost/mpl/vector.hpp>
+#include <boost/type_erasure/any.hpp>
+#include <boost/type_erasure/builtin.hpp>
+#include <boost/type_erasure/is_empty.hpp>
+
+#include <boost/openmethod.hpp>
+#include <boost/openmethod/interop/boost_type_erasure.hpp>
+
+namespace te = boost::type_erasure;
+using namespace boost::openmethod;
+
+// `relaxed` implies `typeid_<>`, which dispatch relies on.
+using Concept = boost::mpl::vector<te::copy_constructible<>, te::relaxed>;
+using erased = te::any<Concept>;
+
+struct Dog {
+    std::string name;
+};
+
+// The owning `any`, `any<Concept>`, becomes the common base of the types
+// the `any` may bind.
+BOOST_OPENMETHOD_REGISTER(use_type_erasure_types<erased, Dog, std::string, int>);
+
+BOOST_OPENMETHOD(name, (virtual_<const erased&>), std::string);
+
+// An overrider takes the bound value...
+BOOST_OPENMETHOD_OVERRIDE(name, (const Dog& dog), std::string) {
+    return dog.name + " the dog";
+}
+
+BOOST_OPENMETHOD_OVERRIDE(name, (const std::string& name), std::string) {
+    return name;
+}
+
+// ...or the `any` itself, which makes it a catch-all.
+BOOST_OPENMETHOD_OVERRIDE(name, (const erased& value), std::string) {
+    return te::is_empty(value) ? "nothing" : "something else";
+}
+
+#include <boost/openmethod/initialize.hpp>
+
+int main() {
+    initialize();
+
+    const erased spot(Dog{"Spot"});
+    const erased felix(std::string("Felix the cat"));
+    const erased answer(42);
+
+    std::cout << name(spot) << "\n";  // Spot the dog
+    std::cout << name(felix) << "\n"; // Felix the cat
+
+    // `int` is registered, but has no overrider of its own, so the
+    // catch-all applies.
+    std::cout << name(answer) << "\n"; // something else
+}
+// end::content[]

doc/modules/ROOT/examples/type_erasure_concept.cpp

@@ -0,0 +1,60 @@
+// Copyright (c) 2018-2026 Jean-Louis Leroy
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// clang-format off
+
+// tag::content[]
+#include <iostream>
+#include <string>
+
+#include <boost/mpl/vector.hpp>
+#include <boost/type_erasure/any.hpp>
+#include <boost/type_erasure/builtin.hpp>
+#include <boost/type_erasure/is_empty.hpp>
+
+#include <boost/openmethod.hpp>
+#include <boost/openmethod/interop/boost_type_erasure.hpp>
+
+namespace te = boost::type_erasure;
+using namespace boost::openmethod;
+
+struct Dog {
+    std::string name;
+};
+
+// The concept must name the Concept it is part of, so the Concept is
+// defined as a struct.
+struct Dispatchable
+    : boost::mpl::vector<
+          te::copy_constructible<>, te::relaxed,
+          openmethod_vptr<Dispatchable>> {};
+
+using erased = te::any<Dispatchable>;
+
+// No use_type_erasure_types: binding a value to the `any` registers its
+// type.
+
+BOOST_OPENMETHOD(name, (virtual_<const erased&>), std::string);
+
+BOOST_OPENMETHOD_OVERRIDE(name, (const Dog& dog), std::string) {
+    return dog.name + " the dog";
+}
+
+BOOST_OPENMETHOD_OVERRIDE(name, (const erased& value), std::string) {
+    return te::is_empty(value) ? "nothing" : "something else";
+}
+
+#include <boost/openmethod/initialize.hpp>
+
+int main() {
+    initialize();
+
+    const erased spot(Dog{"Spot"});
+    const erased answer(42);
+
+    std::cout << name(spot) << "\n";   // Spot the dog
+    std::cout << name(answer) << "\n"; // something else
+}
+// end::content[]

doc/modules/ROOT/examples/type_erasure_ref.cpp

@@ -0,0 +1,59 @@
+// Copyright (c) 2018-2026 Jean-Louis Leroy
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// clang-format off
+
+// tag::content[]
+#include <iostream>
+#include <string>
+
+#include <boost/mpl/vector.hpp>
+#include <boost/type_erasure/any.hpp>
+#include <boost/type_erasure/builtin.hpp>
+
+#include <boost/openmethod.hpp>
+#include <boost/openmethod/interop/boost_type_erasure.hpp>
+
+namespace te = boost::type_erasure;
+using namespace boost::openmethod;
+
+using Concept = boost::mpl::vector<te::copy_constructible<>, te::relaxed>;
+using erased_ref = te::any<Concept, te::_self&>;
+
+struct Dog {
+    std::string name;
+};
+
+BOOST_OPENMETHOD_REGISTER(use_type_erasure_types<erased_ref, Dog, int>);
+
+// An any reference is a cheap handle; it is passed by value.
+BOOST_OPENMETHOD(poke, (virtual_<erased_ref>), std::string);
+
+BOOST_OPENMETHOD_OVERRIDE(poke, (Dog& dog), std::string) {
+    dog.name += "!";
+    return dog.name;
+}
+
+BOOST_OPENMETHOD_OVERRIDE(poke, (int& value), std::string) {
+    ++value;
+    return "poked";
+}
+
+#include <boost/openmethod/initialize.hpp>
+
+int main() {
+    initialize();
+
+    Dog snoopy{"Snoopy"};
+    int count = 41;
+
+    // mutations reach the referents
+    std::cout << poke(erased_ref(snoopy)) << "\n"; // Snoopy!
+    std::cout << snoopy.name << "\n";              // Snoopy!
+
+    std::cout << poke(erased_ref(count)) << "\n"; // poked
+    std::cout << count << "\n";                   // 42
+}
+// end::content[]

doc/modules/ROOT/examples/type_erasure_virtual_any.cpp

@@ -0,0 +1,60 @@
+// Copyright (c) 2018-2026 Jean-Louis Leroy
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// clang-format off
+
+// tag::content[]
+#include <iostream>
+#include <string>
+
+#include <boost/mpl/vector.hpp>
+#include <boost/type_erasure/any.hpp>
+#include <boost/type_erasure/builtin.hpp>
+
+#include <boost/openmethod.hpp>
+#include <boost/openmethod/interop/boost_type_erasure.hpp>
+
+namespace te = boost::type_erasure;
+using namespace boost::openmethod;
+
+using Concept = boost::mpl::vector<te::copy_constructible<>, te::relaxed>;
+using erased = te::any<Concept>;
+
+struct Dog {
+    std::string name;
+};
+
+BOOST_OPENMETHOD_REGISTER(use_type_erasure_types<erased, Dog, std::string>);
+
+BOOST_OPENMETHOD(name, (const virtual_any<erased>&), std::string);
+
+BOOST_OPENMETHOD_OVERRIDE(name, (const Dog& dog), std::string) {
+    return dog.name + " the dog";
+}
+
+BOOST_OPENMETHOD_OVERRIDE(name, (const std::string& name), std::string) {
+    return name;
+}
+
+#include <boost/openmethod/initialize.hpp>
+
+int main() {
+    initialize();
+
+    // from a value: the v-table pointer is set statically
+    virtual_any<erased> rex = Dog{"Rex"};
+    std::cout << (rex.vptr() == default_registry::static_vptr<Dog>) << "\n"; // 1
+
+    // from an `any`: one lookup, here, and none in the calls below
+    erased spot_any(Dog{"Spot"});
+    virtual_any<erased> spot = spot_any;
+
+    std::cout << name(rex) << "\n";  // Rex the dog
+    std::cout << name(spot) << "\n"; // Spot the dog
+
+    spot = std::string("Felix the cat");
+    std::cout << name(spot) << "\n"; // Felix the cat
+}
+// end::content[]

doc/modules/ROOT/examples/virtual_any.cpp

@@ -0,0 +1,63 @@
+// Copyright (c) 2018-2026 Jean-Louis Leroy
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// clang-format off
+
+// tag::content[]
+#include <any>
+#include <iostream>
+#include <string>
+
+#include <boost/openmethod.hpp>
+#include <boost/openmethod/interop/std_any.hpp>
+
+using namespace boost::openmethod;
+
+struct Dog {
+    std::string name;
+};
+
+// `std::any` becomes the common base of the types it may contain.
+BOOST_OPENMETHOD_REGISTER(use_std_any_types<Dog, std::string, int, float>);
+
+BOOST_OPENMETHOD(name, (virtual_<const std::any&>), std::string);
+
+// An overrider takes the contained value...
+BOOST_OPENMETHOD_OVERRIDE(name, (const Dog& dog), std::string) {
+    return dog.name + " the dog";
+}
+
+BOOST_OPENMETHOD_OVERRIDE(name, (const std::string& name), std::string) {
+    return name;
+}
+
+BOOST_OPENMETHOD_OVERRIDE(name, (const int& value), std::string) {
+    return std::to_string(value) + " the integer";
+}
+
+// ...or the `any` itself, which makes it a catch-all.
+BOOST_OPENMETHOD_OVERRIDE(name, (const std::any&), std::string) {
+    return "something else";
+}
+
+#include <boost/openmethod/initialize.hpp>
+
+int main() {
+    initialize();
+
+    std::any spot = Dog{"Spot"};
+    std::any felix = std::string("Felix the cat");
+    std::any answer = 42;
+    std::any pi = 3.14f;
+
+    std::cout << name(spot) << "\n";   // Spot the dog
+    std::cout << name(felix) << "\n";  // Felix the cat
+    std::cout << name(answer) << "\n"; // 42 the integer
+
+    // `float` is registered, but has no overrider of its own, so the
+    // catch-all applies.
+    std::cout << name(pi) << "\n";     // something else
+}
+// end::content[]