Judge me by my C++, not my WordPress
Some colleagues of mine and I have been working for the past few years to give C++ a standard async programming model. That effort has resulted in a proposal, P2300, that has been design-approved for C++26. If you know me Continue reading What are Senders Good For, Anyway?
As you may have heard by now, Ranges got merged and will be part of C++20. This is huge news and represents probably the biggest shift the Standard Library has seen since it was first standardized way back in 1998. Continue reading Standard Ranges
Disclaimer: these are my early thoughts. None of this is battle ready. You’ve been warned. Hello, Coroutines! At the recent C++ Committee meeting in Toronto, the Coroutines TS was forwarded to ISO for publication. That roughly means that the coroutine Continue reading Ranges, Coroutines, and React: Early Musings on the Future of Async in C++
This is the fourth and final post in a series about proxy iterators, the limitations of the existing STL iterator concept hierarchy, and what could be done about it. The first three posts describe the problems of proxy iterators, the Continue reading Iterators++, Part 3
Disclaimer: This is a long, boring post about minutia. For serious library wonks only. This is the third in a series about proxy iterators, the limitations of the existing STL iterator concept hierarchy, and what could be done about it. Continue reading Iterators++, Part 2
In the last post, I described the so-called proxy iterator problem: the fact that iterators that return proxy references instead of real references don’t sit comfortably within the STL’s framework. Real, interesting, and useful iterators fall foul of this line, Continue reading Iterators++, Part 1
Way back in 1999, when the ink on the first C++ standard was still damp, Herb Sutter posed a GoTW puzzler in the still extant C++ Report (RIP): When Is a Container Not a Container? In that article, Herb described Continue reading To Be or Not to Be (an Iterator)
(Disclaimer: here be esoteric language wonkery. Abandon all hope.) If you read or write Generic-code-with-a-capitol-‘G’, you may have written or seen code like this: using std::swap; swap( a, b ); The first line brings std::swap into consideration, and the second Continue reading Customization Point Design in C++11 and Beyond
I’ve been hard at work fleshing out my range library and writing a proposal to get range support into the standard. That proposal describes a foundational range concept: Iterable. An Iterable is anything we can pass to std::begin() and std::end() Continue reading Ranges in C++: Counted Iterables and Efficiency
Last time, I introduced a new concept, Iterable, and showed how it solved many of the problems with pair-of-iterator-style ranges. This time around, I’m going to extend Iterable in small ways to make programming with infinite ranges safer and more Continue reading Range Concepts, Part 4 of 4: To Infinity And Beyond