C++ History Collection: Software Preservation Group
https://softwarepreservation.computerhistory.org/c_plus_plus/

https://redd.it/1seulk2
@r_cpp

Latest News From Upcoming C++ Conferences (2026-04-07)

This is the latest news from upcoming C++ Conferences. You can review all of the news at [https://programmingarchive.com/upcoming-conference-news/](https://programmingarchive.com/upcoming-conference-news/)

**TICKETS AVAILABLE TO PURCHASE**

The following conferences currently have tickets available to purchase

* **C++Now (4th - 8th May)** \- Regular tickets available to purchase at [https://cppnow.org/registration/](https://cppnow.org/registration/)
* **CppNorth/NDC Toronto (5th - 8th May)** \- Tickets are open and can be purchased at [https://ndctoronto.com/tickets](https://ndctoronto.com/tickets)
* **ACCU on Sea (15th - 20th June)** \- You can buy early bird tickets at [https://accuonsea.uk/tickets/](https://accuonsea.uk/tickets/) with discounts available for ACCU members.
* **CppCon (12th - 18th September)** \- You can buy early bird tickets until June 26th at [https://cppcon.org/registration/](https://cppcon.org/registration/)
* **Meeting C++ (NEW - 26th - 28th November)** \- You can buy early bird tickets at [https://meetingcpp.com/2026/](https://meetingcpp.com/2026/)

**OPEN CALL FOR SPEAKERS**

There are currently no open calls.

**OTHER OPEN CALLS**

There are currently no open calls.

**TRAINING COURSES AVAILABLE FOR PURCHASE**

Conferences are offering the following training courses:

**LAST CHANCE TO REGISTER**

1. **Performance and Safety in C++ Crash Course** \- Jason Turner - 1 day online workshop available on *Thursday 9th April 12:00 - 20:00 UTC -* [https://cpponline.uk/workshop/performance-and-safety-in-cpp-crash-course/](https://cpponline.uk/workshop/performance-and-safety-in-cpp-crash-course/) \- £345/$460/€400 (£90/$120/€105 for students)
2. **Stop Thinking Like a Junior** **- The Soft Skills That Make You Senior** \- Sandor Dargo - Half Day online workshop available on *Friday 10th April 13:00 - 16:30 UTC* \- [https://cpponline.uk/workshop/stop-thinking-like-a-junior/](https://cpponline.uk/workshop/stop-thinking-like-a-junior/) \- £172.50/$230/€200 (£45/$60/€55 for students)
3. **Jumpstart to C++ in Audio - Learn Audio Programming & Create Your Own Music Plugin/App with the JUCE C++ Framework** \- Jan Wilczek - 1 day online workshop available on both Tuesday 14th April 13:00 - 20:00 UTC - [https://cpponline.uk/workshop/jumpstart-to-cpp-in-audio/](https://cpponline.uk/workshop/jumpstart-to-cpp-in-audio/) \- £150/$200/€175 (£90/$120/€105 for students)
4. **Essential GDB and Linux System Tools** \- Mike Shah - 1 day online workshop available on *Friday 17th April 13:00 - 21:00 UTC* \- [https://cpponline.uk/workshop/essential-gdb-and-linux-system-tools/](https://cpponline.uk/workshop/essential-gdb-and-linux-system-tools/) \- £345/$460/€400 (£90/$120/€105 for students)

**C++Online One Day Workshops** \- £345/$460/€400 (£90/$120/€105 for students)

1. **Performance and Safety in C++ Crash Course** \- Jason Turner - 1 day online workshop available on *Thursday 9th April 12:00 - 20:00 UTC -* [https://cpponline.uk/workshop/performance-and-safety-in-cpp-crash-course/](https://cpponline.uk/workshop/performance-and-safety-in-cpp-crash-course/)
2. **Essential GDB and Linux System Tools** \- Mike Shah - 1 day online workshop available on *Friday 17th April 13:00 - 21:00 UTC* \- [https://cpponline.uk/workshop/essential-gdb-and-linux-system-tools/](https://cpponline.uk/workshop/essential-gdb-and-linux-system-tools/)
3. **Concurrency Tools in the C++ Standard Library** \- Mateusz Pusz - 1 day online workshop available on *Friday 24th April 09:00 - 17:00 UTC* \- [https://cpponline.uk/workshop/concurrency-tools-in-the-cpp-standard-library/](https://cpponline.uk/workshop/concurrency-tools-in-the-cpp-standard-library/)
4. **C++ Software Design** \- Klaus Iglberger - 1 day online workshop available on *Thursday 30th April 09:00 - 17:00 UTC* \- [https://cpponline.uk/workshop/cpp-software-design/](https://cpponline.uk/workshop/cpp-software-design/)
5. **Safe C++** \- Klaus Iglberger - 1 day online workshop available on *Friday 1st May 09:00 - 17:00 UTC* \-

[https://cpponline.uk/workshop/safe-cpp/](https://cpponline.uk/workshop/safe-cpp/)
6. **Safe and Efficient C++ for Embedded Environments** \- Andreas Fertig - 1 day online workshop available on *Tuesday 12th May 09:00 - 17:00 UTC* \- [https://cpponline.uk/workshop/safe-and-efficient-cpp-for-embedded-environments/](https://cpponline.uk/workshop/safe-and-efficient-cpp-for-embedded-environments/)
7. **Mastering std::execution (Senders/Receivers)** \- Mateusz Pusz - 1 day online workshop available on *Friday 15th May 09:00 - 17:00 UTC* \- [https://cpponline.uk/workshop/mastering-stdexecution-senders-receivers/](https://cpponline.uk/workshop/mastering-stdexecution-senders-receivers/)
8. **How C++ Actually Works - Hands-On With Compilation, Memory, and Runtime** \- Assaf Tzur-El - One day online workshop that runs over two days on *May 18th - May 19th 16:00 - 20:00 UTC* \- [https://cpponline.uk/workshop/how-cpp-actually-works/](https://cpponline.uk/workshop/how-cpp-actually-works/)
9. **AI++ 101 - Build an AI Coding Assistant in C++** \- Jody Hagins - 1 day online workshop available on *Friday 22nd May 09:00 - 17:00 UTC* \- [https://cpponline.uk/workshop/ai-101/](https://cpponline.uk/workshop/ai-101/)

**C++Online One Day Beginner Workshops** \- **Reduced from £345 to £150/$200/€175** (£90/$120/€105 for students)

1. **Jumpstart to C++ in Audio - Learn Audio Programming & Create Your Own Music Plugin/App with the JUCE C++ Framework** \- Jan Wilczek - 1 day online workshop available on both Tuesday 14th April 13:00 - 20:00 UTC & Tuesday 28th April 07:00 - 14:00 UTC - [https://cpponline.uk/workshop/jumpstart-to-cpp-in-audio/](https://cpponline.uk/workshop/jumpstart-to-cpp-in-audio/)
2. **From Hello World to Real World - A Hands-On C++ Journey from Beginner to Advanced** \- Amir Kirsh - 1 day online workshop available on *Thursday 21st May 08:30 - 16:30 UTC -* [https://cpponline.uk/workshop/from-hello-world-to-real-world/](https://cpponline.uk/workshop/from-hello-world-to-real-world/)

**C++Online Half Day Workshops** \- £172.50/$230/€200 (£45/$60/€55 for students)

1. **Stop Thinking Like a Junior** **- The Soft Skills That Make You Senior** \- Sandor Dargo - Half Day online workshop available on *Friday 10th April 13:00 - 16:30 UTC* & *Friday 8th May 20:00 - 23:30 UTC* \- [https://cpponline.uk/workshop/stop-thinking-like-a-junior/](https://cpponline.uk/workshop/stop-thinking-like-a-junior/)
2. **Splice & Dice - A Field Guide to C++26 Static Reflection** \- Koen Samyn - Half Day online workshop available on *Monday 25th May 09:00 - 12:30 UTC* \- [https://cpponline.uk/workshop/splice-and-dice/](https://cpponline.uk/workshop/splice-and-dice/)

**C++Online Two Day Workshops** \- £690/$920/€800 (£180/$240/€210 for students)

1. **AI++ 201 - Build a Matching Engine with Claude Code** \- Jody Hagins - 2 day online workshop available on *April 20th - April 21st 13:00 - 21:00 UTC & May 28th - May 29th 09:00 - 17:00 UTC* \- [https://cpponline.uk/workshop/ai-201/](https://cpponline.uk/workshop/ai-201/)

Eleven of these workshops had previews at the main C++Online Conference which took place on the 11th - 13th March. You can watch these preview sessions here: [https://www.youtube.com/playlist?list=PLHG0uo5c6V3KIeoLqvBbIqy5AXt\_Me\_cm](https://www.youtube.com/playlist?list=PLHG0uo5c6V3KIeoLqvBbIqy5AXt_Me_cm)

**Anyone who purchased a C++Online Main Conference ticket can also get a discount of however much they paid to attend the main conference.** 

Also if anyone is from a lower-income background or live in a country where purchasing power is limited, then it is recommended to reach out to C++Online on [[email protected]](mailto:[email protected]) as they will be able to give you a discount.

**OTHER NEWS**

* **(NEW) C++Online Keynote Released** \- C++Online have released the first of their keynotes on YouTube! New videos will be released each week so subscribe to the YouTube channel here [https://www.youtube.com/@CppOnline/videos](https://www.youtube.com/@CppOnline/videos)
* **(NEW) C++Online Beginner Workshops Discounted** \- C++Online

have discounted the following workshops by 50% to now be 150/$200/€175
1. **From Hello World to Real World - A Hands-On C++ Journey from Beginner to Advanced** \- Amir Kirsh - 1 day online workshop available on *Thursday 21st April 09:00 - 17:00 UTC -* [https://cpponline.uk/workshop/from-hello-world-to-real-world/](https://cpponline.uk/workshop/from-hello-world-to-real-world/)
2. **Jumpstart to C++ in Audio - Learn Audio Programming & Create Your Own Music Plugin/App with the JUCE C++ Framework** \- Jan Wilczek - 1 day online workshop available on both Tuesday 14th April 13:00 - 20:00 UTC & Tuesday 28th April 07:00 - 14:00 UTC - [https://cpponline.uk/workshop/jumpstart-to-cpp-in-audio/](https://cpponline.uk/workshop/jumpstart-to-cpp-in-audio/)
* **(NEW) C++Now Full Schedule Announced** \- C++Now have announced their full schedule which includes 50 talks across the five days. View the full schedule at [https://schedule.cppnow.org](https://schedule.cppnow.org)
* **(NEW) C++Now Final Keynote Announced** \- C++Now have announced the following keynote which is **Benchmarking – It’s About Time** by Matt Godbolt - [https://cppnow.org/announcements/2026/03/cppnow-keynote-benchmarking/](https://cppnow.org/announcements/2026/03/cppnow-keynote-benchmarking/)
* **(NEW) ACCU On Sea Schedule Announced** \- The ACCU on Sea schedule has been announced and includes over 60 sessions across the four days. Visit [https://accuonsea.uk/schedule/](https://accuonsea.uk/schedule/) for the full schedule.
* **(NEW) CppCon Call For Authors Now Open!** \- CppCon are looking for book authors who want to engage with potential reviewers and readers. Read the full announcement at [https://cppcon.org/call-for-author-2026/](https://cppcon.org/call-for-author-2026/) 
* **(NEW) Meeting C++ 2026 Announced** \- Meeting C++ will take place on the 26th - 28th November and will be hybrid. Visit [https://meetingcpp.com/meetingcpp/news/items/Announcing-Meeting-Cpp-2026-.html](https://meetingcpp.com/meetingcpp/news/items/Announcing-Meeting-Cpp-2026-.html) to find out more
* **CppCon Registration Now Open** \- You can now buy early bird tickets until June 26th at [https://cppcon.org/registration/](https://cppcon.org/registration/)
* **CppCon Academy Classes Announced** \- CppCon have announced 16 classes/workshops which will take place either before or after the main conference. You can view the full list of classes available at [https://cppcon.org/cppcon-academy-2026/](https://cppcon.org/cppcon-academy-2026/)
* **Hudson River Trading Scholarship Annouced For CppCon 2026** \- CppCon have announced a new scholarship program that will provide scholarships that cover lodging, travel, food, and conference registration for twenty to twenty-five students for this year's CppCon. Find out more including how to apply at [https://cppcon.org/announce-scholarship-2026/](https://cppcon.org/announce-scholarship-2026/)
* **C++Online Workshops Announced** \- C++Online have announced 14 workshops that will take place between the end of March and the start of June with more potentially being added if any workshops are oversubscribed. Find out more including the workshops that are available at [https://cpponline.uk/workshop-tickets-for-cpponline-2026-now-available/](https://cpponline.uk/workshop-tickets-for-cpponline-2026-now-available/)

https://redd.it/1sezs6b
@r_cpp

Inside Boost.Container: comparing different deque implementations

I put together a comparison of std::deque internals across libc++, libstdc++, MSVC STL, and boost::container::deque (Boost 1.90). The article looks at the internal data structures, member layouts, sizeof(deque), and includes some benchmarks on common operations.

Boost 1.90 shipped a complete rewrite of its deque — the old SGI-derived layout was replaced with a more compact design (32 bytes vs the previous 80). The article digs into what changed, how the new implementation compares to the three standard library implementations, and how much block size alone affects performance across all of them.

https://boostedcpp.net/2026/03/30/deque/

https://redd.it/1sf210b
@r_cpp

Hashing in C++26
https://blog.infotraining.pl/hashing-in-cpp-26

https://redd.it/1sfmsm9
@r_cpp

std::core_dump - The Newsletter of Boost and the C++ Alliance - April 2026
https://dl.cpp.al/newsletters/boost-newsletter-2026-04.pdf

https://redd.it/1sfzsr8
@r_cpp

0xd34df00d/you-dont-know-cpp: and neither do I
https://github.com/0xd34df00d/you-dont-know-cpp

https://redd.it/1sgf6tx
@r_cpp

beast2 networking & std::execution

I was looking for a new networking layer foundation for a few of my projects, stumbled on beast2 library which looks brand new, based on C++20 coroutines. I used boost.beast in the past which was great. Here's the link https://github.com/cppalliance/beast2. I also considered std::execution since it seems to be the way to go forward, accepted in C++26.

Now, what got me wondering is this paragraph

>The C++26 std::execution API offers a different model, designed to support heterogenous computing. Our research indicates it optimizes for the wrong constraints: TCP servers don't run on GPUs. Networking demands zero-allocation steady-state, type erasure without indirection, and ABI stability across (e.g.) SSL implementations. C++26 delivers things that networking doesn't need, and none of the things that networking does need.

Now I'm lost a bit, does that mean std::execution is not the way to go for networking? Does anyone have any insights on cppalliance research on the matter?

https://redd.it/1sgjube
@r_cpp

Jumpstart to C++ in Audio C++ Online 2026 Workshop
https://cpponline.uk/workshop/jumpstart-to-cpp-in-audio/

https://redd.it/1sgn5sb
@r_cpp

Orbit - a fast lock-free MPMC queue in C++20

Orbit is a single-header lock-free MPMC bounded queue, designed from first principles and tuned to get the most out of modern hardware. In my benchmarks, it consistently outperforms other implementations like atomic_queue, moodycamel::concurrent_queue or xenium::ramalhete_queue on both x86 and ARM, often by a significant margin.

## Key features

- Cross-platform: Support for x86/ARM, GCC/Clang/MSVC
- Supports any default-constructible type, not just atomics, with move semantics for non-trivially-copyable types
- Configurable to optimise for either latency or throughput
- Simple and versatile interface
- Easily tunable spin pause lengths for different platforms

I wrote a technical blog post covering the implementation details and optimisation process if you are interested.

https://redd.it/1sfqu2h
@r_cpp

Managing Versions Programmatically with LibGit2
https://www.youtube.com/watch?v=Vrc95KdNHHA

https://redd.it/1sgsi0g
@r_cpp

Why committee doesn't decide on a package format?

Why pkgconf or cmake package or CPS isn't officially endorsed by the committee?

Can't cmake or meson guys, who go to meetings and conferences pressure the higher ups to get something accepted?

Multiple build systems are ok, multiple package formats are not. Why no one solves this issue?

https://redd.it/1sgkyog
@r_cpp

Per-op allocs: can we get these all to zero?

The benchmark builds read streams at three abstraction levels on beman::execution and beman::execution::task to measure per-operation cost and allocations across execution models.

Per-operation allocation counts for I/O read_some, three stream abstraction levels:

awaitable (capy::task) native: 0 abstract: 0 type-erased: 0
sender (pipeline) native: 0 abstract: 1 type-erased: 1
sender (beman::task) native: 0 abstract: 1 type-erased: 1

The awaitable path preallocates at stream construction because coroutine_handle is already type-erased. The sender path heap-allocates per operation because connect produces a type-dependent operation state.

github.com/cppalliance/capy/tree/develop/bench/beman

Can someone help me get the sender rows to zero?

Here's a more detailed supporting analysis:

https://gist.github.com/sgerbino/2a64990fb221f6706197325c03e29a5e

https://redd.it/1sgvh2o
@r_cpp

C++23 Support in MSVC Build Tools 14.51
https://devblogs.microsoft.com/cppblog/c23-support-in-msvc-build-tools-14-51/

https://redd.it/1sh074n
@r_cpp

Writing only decoupled code
https://middleraster.github.io/DAG/HeaderOnlyNoForwardDeclarations.html

https://redd.it/1sh0wvt
@r_cpp

Interesting point of view from Daniel Lemire

If you’re not already familiar with Daniel Lemire, he is a well-known performance-focused researcher and the author of widely used libraries such as simdjson.

He recently published a concise overview of the evolution of the C and C++ programming languages:

https://lemire.me/blog/2026/04/09/a-brief-history-of-c-c-programming-languages/

It’s a worthwhile read for anyone interested in the historical context and development of systems programming languages.

https://redd.it/1sh7zxn
@r_cpp

Why do SBOM tools keep getting C++ wrong? Is anyone actually solving this?

Ran into this again recently and curious if others have hit the same wall.

The structural problem: every mainstream approach answers "what did this build use?" at the wrong time.

Pre-build scanners read your manifests and build scripts. They report declarations, not execution. Miss vendored code, anything downloaded at configure time, conditional compilation paths that only activate on certain platforms.

Post-build binary analysis is better for dynamic deps but falls apart on statically linked code. Once the linker's done its job, the symbols are stripped and version info is gone. You know something's in there. You can't always tell what.

Someone ran Syft against OpenCV recently as a sanity check — 92 components, with FFmpeg flagged 6 times as a build component. FFmpeg is never compiled into OpenCV. Optional, platform-specific, loaded at runtime if available. The actual vendored deps in 3rdparty/ mostly didn't show up.

The gap is structural, not a tooling bug. You're trying to capture build-time information before or after the build exists.

Curious how others are handling this — especially on embedded or automotive stacks where static linking is basically the default. Is anyone doing something smarter than scanner + manual review?

https://redd.it/1sha7b8
@r_cpp

Freestanding standard library
https://www.sandordargo.com/blog/2026/04/08/cpp-freestanding

https://redd.it/1she4xf
@r_cpp

We benchmarked sender-based I/O against coroutine-based I/O. Here's what we found.

When I/O operations return senders, they incur an unnecessary per-operation allocation. This explains why.

|Stream Type|capy::task|bex::task|sender pipeline|
|:-|:-|:-|:-|
|Native|0|0|0|
|Abstract|0|1|1|
|Type-erased|0|1|1|

When an I/O stream is type-erased, sender/receiver's connect() produces an operation state whose type depends on both the sender and the receiver. The size is unknown at construction time. It must be heap-allocated per operation. Under awaitables, await_suspend takes a coroutine_handle<> — the consumer type is already erased — so the awaitable can be preallocated once and reused. The allocation cannot be eliminated. It follows from connect producing a type that depends on both the sender and the receiver.

We measured this. The benchmark executes 20,000,000 read_some calls per configuration on a single thread using a stream that isolates the execution model overhead from I/O latency. Five independent runs plus warmup; values are mean ± standard deviation. The benchmark source is public:

https://github.com/cppalliance/capy/tree/develop/bench/beman

Anyone is invited to inspect the code, suggest improvements, and help make it better. The architects of P2300 are especially welcome — their expertise would strengthen the comparison.

Two papers address the cost asymmetry. P4003R0 "Coroutines for I/O" defines the IoAwaitable protocol for standard I/O operations. P4126R0 "A Universal Continuation Model" is purely additive — it gives sender/receiver pipelines zero-allocation access to every awaitable ever written. Together they make coroutines and senders both first-class citizens of the I/O stack.

# Benchmark Results

All values are mean ± stddev over 5 runs (warmup pass discarded). Each table measures one execution model consuming two I/O return types (awaitable and sender). The native column is the model's own I/O type; the other column goes through a bridge.

# Table 1: sender/receiver pipeline

|Stream Type|sender (native)|awaitable (bridge)|
|:-|:-|:-|
|Native|34.3 ± 0.1 ns/op, 0 al/op|46.3 ± 0.0 ns/op, 1 al/op|
|Abstract|47.1 ± 0.2 ns/op, 1 al/op|46.4 ± 0.0 ns/op, 1 al/op|
|Type-erased|57.5 ± 0.0 ns/op, 1 al/op|54.1 ± 0.1 ns/op, 1 al/op|
|Synchronous|2.6 ± 0.3 ns/op, 0 al/op|5.1 ± 0.1 ns/op, 0 al/op|

# Table 2: capy::task

|Stream Type|awaitable (native)|sender (bridge)|
|:-|:-|:-|
|Native|31.4 ± 0.2 ns/op, 0 al/op|48.1 ± 0.3 ns/op, 0 al/op|
|Abstract|32.3 ± 0.2 ns/op, 0 al/op|72.2 ± 0.2 ns/op, 1 al/op|
|Type-erased|36.4 ± 0.1 ns/op, 0 al/op|72.1 ± 0.0 ns/op, 1 al/op|
|Synchronous|1.0 ± 0.2 ns/op, 0 al/op|19.0 ± 0.0 ns/op, 0 al/op|

# Table 3: beman::execution::task

Note: bex::task's await_transform calls the sender's as_awaitable member directly when available, bypassing connect and start. Table 3's native sender column measures the as_awaitable path, not the full sender protocol.

|Stream Type|sender (native)|awaitable (bridge)|
|:-|:-|:-|
|Native|31.9 ± 0.0 ns/op, 0 al/op|43.5 ± 0.1 ns/op, 1 al/op|
|Abstract|55.2 ± 0.0 ns/op, 1 al/op|43.4 ± 0.0 ns/op, 1 al/op|
|Type-erased|55.2 ± 0.0 ns/op, 1 al/op|48.7 ± 0.1 ns/op, 1 al/op|
|Synchronous|1.0 ± 0.2 ns/op, 0 al/op|2.9 ± 0.2 ns/op, 0 al/op|

The full formatted report with detailed analysis is here: https://gist.github.com/sgerbino/2a64990fb221f6706197325c03e29a5e

# Analysis

Native performance is equivalent. Both models achieve \~31–34 ns/op with zero allocations when consuming their native I/O type on a concrete stream. There is no inherent speed advantage to either model at the baseline.

Type erasure costs diverge. capy::any_read_stream adds \~5 ns/op and zero allocations. The awaitable is preallocated at stream construction and reused across every read_some call. This is possible because

await_suspend takes a type-erased coroutine_handle<> — the consumer type is already erased, so the awaitable's size is known at construction time. The sender equivalents add \~21–23 ns/op and one allocation per operation. The sender's connect(receiver) produces an op_state whose type depends on both the sender and the receiver. Since either may be erased, the operation state must be heap-allocated.

Bridges are competitive. Both bridges add 11–17 ns for native streams with zero bridge allocations. The allocations visible in the bridged columns come from the target model's own machinery (type-erased connect, executor adapter posting), not from the bridges themselves.

std::execution provides compile-time sender composition, structured concurrency guarantees, and a customization point model that enables heterogeneous dispatch. These are real achievements for real domains — GPU dispatch, work-graph pipelines, heterogeneous execution. Coroutines serve a different domain. They cannot express compile-time work graphs or target heterogeneous dispatch. What they do is serial byte-oriented I/O — reads, writes, timers, DNS lookups, TLS handshakes — the work that networked applications spend most of their time on.

# Trade-off Summary

|Feature|IoAwaitable|sender/receiver|
|:-|:-|:-|
|Native concrete performance|\~31 ns/op, 0 al/op|\~32–34 ns/op, 0 al/op|
|Type erasure cost|\+5 ns/op, 0 al/op|\+21–23 ns/op, 1 al/op|
|Type erasure mechanism|preallocated awaitable|heap-allocated op_state|
|Why erasure allocates|it does not|op_state depends on sender AND receiver types|
|Synchronous completion|\~1 ns/op via symmetric transfer|\~2.6 ns/op via trampoline|
|Looping|native for loop|requires repeat_until \+ trampoline|
|Bridge to other model (native)|\~17 ns/op, 0 al/op|\~12 ns/op, 1 al/op|
|Bridge to other model (erased)|\~36 ns/op, 1 al/op|\~12 ns/op, 1 al/op|

https://redd.it/1shmwzz
@r_cpp