Big news of the week, via Hacker News: Someone has engineered a 1D spaceship in Conway’s Game of Life! That is, there exists a pattern which initially fits into a bounding box of dimensions \(3\,707\,300\,605\times 1\) — that “1” is what makes it “1D” — and, when evolved for \(133\,076\,755\,768\) steps, reforms itself into exactly the same pattern shifted two cells to the left.

In C++, when we have a type that carries no data — whose only “identity” is its type — we conventionally call that a “tag type.” When you see code like struct X {}; it’s often the case that X is a tag type. However, not all tag types are created equal: there are at least two major disjoint use-cases for tag types, and the STL (as of 2025) therefore uses two distinct naming conventions for their identifiers.

There is no widely recognized nomenclature for these two kinds of tag types, as far as I know, so I’m going to call them disambiguation tags and concept tags.

C++20 added atomic_ref<T> to the Standard Library (see “Guard nouns or guard verbs?” (2023-11-11)). But somehow C++20 overlooked atomic_ref<const T>; it’s finally permitted in C++26, thanks to Gonzalo Brito Gadeschi’s P3323. But then there was a new problem: since const T& binds to both lvalues and rvalues, suddenly it is legal to write

This afternoon I presented a paper at the quarterly meeting of the “Three Garridebs,” Westchester’s scion society of the Baker Street Irregulars. Here it is for posterity, almost entirely as delivered (minus a brief ad-lib apology for its being more about Miss Marple than about Sherlock Holmes).

The Kona WG21 meeting was two weeks ago. This was the (first) big “resolve NB comments for C++26” meeting. Last month I wrote about some of the NB comments, and whether they might actually lead to removal of the offending features. Well, big news: P2786’s non-trivial “trivial” relocation was successfully removed in Kona, satisfying the 6+ NB comments that asked for that removal! This is good news for everyone who uses trivial relocation today, and I’m very happy that we finally got enough “adults in the room” (read: library implementors) to make the right call. Of course we’ll probably do it all over again for C++29. See below.

In the pre-Kona WG21 mailing is P3858R0 “A Lifetime-Management Primitive for Trivially Relocatable Types” (std::restart_lifetime) (Sankel, Bauman, Halpern). A correspondent asks for my thoughts on it.

The pre-Kona WG21 mailing includes N5028 “SoV and Collated Comments,” which is the collation of all 26 National Bodies’ comments on the C++26 CD. Nineteen NBs submitted comments. It is important to note that different NBs have different mechanisms for soliciting their comments. The US NB simply submits every comment it receives — no filter. My impression is that some other NBs (UK? Sweden?) have a technical discussion about every comment and submit only comments that win consensus within the NB.

C++26 is notable for the large number of relatively unimplemented and novel features it specifies; and the NB comments on C++26 are notable for the many comments of the form “We should completely remove novel feature X.” By my count:

In “What breaks without implicit T*-to-bool conversion?” (2025-10-05) I wrote that in a proprietary C++17 codebase my audit turned up “one non-explicit operator bool, and zero bugs.” On closer inspection we found that that non-explicit operator bool actually was causing a real bug! Consider this hypothetical type that behaves something like unique_ptr<int> (Godbolt):

struct IntPtr {
  explicit IntPtr() = default;
  explicit IntPtr(int *p) : p_(p) {}
  int& operator*() const { return *p_; }
  int *operator->() const { return p_; }
  operator bool() const { return bool(p_); }
  friend bool operator==(IntPtr a, IntPtr b) { return a.p_ == b.p_; }

  int *get() const { return p_; }
private:
  int *p_ = nullptr;
};

std::set<IntPtr> myset;
int i, j;
myset.emplace(&i);
myset.emplace(&j);
assert(myset.size() == 2); // fails!

After emplacing two items, myset.size() is only 1!

C++20 took a small step by deciding (via P1957) that a T*-to-bool conversion should be considered narrowing, and thus forbidden in list-initialization. But could we go further and make T*-to-bool conversion non-implicit?

I patched my local copy of Clang to forbid implicit conversion from T* to bool. Here’s all the things that broke when I compiled LLVM/Clang itself with my patched compiler.

Yesterday my wife and I went to see Waiting for Godot at the Hudson Theatre on Broadway, starring Alex Winter (you know, Bill) as Vladimir and Keanu Reeves (you know, Ted) as Estragon. This is of course stunt casting to the extreme. We went knowing this. Still, I feel like I have to get this off my chest: If you are not a “Godot” fan, you probably will not like this “Godot” — and if you are a “Godot” fan, you certainly will not like this “Godot.”

Someone on the cpplang Slack asks: How can I view a std::pair<T, T> as if it were a range of two Ts? That is, fill in the blank in this sample program:

template<std::ranges::range R>
void increment_all(R&& rg) {
  for (auto&& elt : rg) {
    elt = elt + 1;
  }
}

template<class T>
auto F(std::pair<T, T>& kv) { ~~~~ }

int main() {
  std::pair<int, int> kv = {1, 2};
  increment_all(F(kv));
  assert(kv.first == 2 && kv.second == 3);
  std::ranges::fill(F(kv), 4);
  assert(kv.first == 4 && kv.second == 4);
}

Jorge Luis Borges, The Masked Dyer, Hakim of Merv (1934, tr. N. T. di Giovanni):

Cervantes wrote satirically of a poet who had written—

“that part of the history of King Arthur of England which Archbishop Turpin left unwritten, together with the history of the quest of the Holy Grail; and all in heroic verse, part in rhymes and part in blank verse; but entirely dactylically—I mean in dactylic noun substantives, without admitting any verb whatsoever.”

In part 2 we saw that he didn’t really mean no verbs, just no line-terminal verbs; and likewise the word “dactylic” (“todo … en esdrújulos”) referred only to the line-terminal stress pattern, not to the contents of his dictionary. But what if he had meant those constraints in the most restrictive sense possible? Discarding (read: forgetting) the “part in rhymes” constraint, he might have written something like the following — which one might in dactylic substantives christen the Turpentine Comedy:

I.  Argument.

poesy chronicle history Camelot
emperor majesty conqueror Caliburn

Previously: “A poem all in dactylic noun substantives, part 1” (2025-08-28). Cervantes wrote satirically of a poet who had written—

“that part of the history of King Arthur of England which Archbishop Turpin left unwritten, together with the history of the quest of the Holy Grail; and all in heroic verse, part in rhymes and part in blank verse; but entirely dactylically—I mean in dactylic noun substantives, without admitting any verb whatsoever.”

Over on Literature StackExchange, Clara Díaz Sánchez explains that in the late 16th and early 17th century, there was in fact a fad for poetry in which many lines ended in dactyls.

In Cervantes’ Coloquio de los perros (published 1613), a dog recounts all the colorful characters he’s met in his life. One is this frustrated poet:

“I have strictly observed the rule laid down by Horace in his Poetica not to bring to light any work until ten years after it has been composed. Now I have a work on which I was engaged for twenty years, and which has lain by me for twelve […] a lofty, sonorous, heroic poem, delectable and full of matter; and yet I cannot find a prince to whom I may dedicate it.”

“What is the subject of the work?” inquired the alchemist.

“It treats,” said the poet, “of that part of the history of King Arthur of England which Archbishop Turpin left unwritten, together with the history of the quest of the Holy Grail; and all in heroic verse, part in rhymes and part in blank verse; but entirely dactylically—I mean in dactylic noun substantives, without admitting any verb whatsoever.”

On 2025-06-25, Jacob Siehler tooted that there are exactly 100 bilaterally symmetric regions you can build out of a complete set of the five free tetrominoes.

Over the past few years, I’ve noticed a pattern in several LWG issues: In library clauses, CTAD and list-initialization are never helpful and are sometimes harmful, in the sense that they create LWG issues to triage and fix. I’d noticed for several years “this happens a lot,” but I’d never collected all my anecdotes into one list. I’m starting that list now. As Wikipedia says, “This list is incomplete”; please let me know if you see any I’ve missed.

Around New Year’s, while our book club was reading Dante’s Divine Comedy, I serendipitously happened across a reference in Douglas Hofstadter’s Le ton beau de Marot (page 125) to a book of poetry by Giuseppe Varaldo titled All’alba Shahrazad andrà ammazzata (“Shahrazad Shall Hang at Dawn”). Hofstadter writes: “In his astonishing tour de force of a book, Varaldo takes roughly fifty classics of Western literature and synopsizes each one in a perfectly constructed classical Italian-style sonnet, in which just one vowel appears.”

From Alessandro Torri’s preface to the first volume of L’Ottimo Commento as edited by himself and others of the Accademia della Crusca (1827):

In C++, there’s often multiple ways to refer to the same entity: aliases, inherited names, injected names, names that differ in qualification… Usually, if an entity has multiple names, which one you use won’t matter: you can use any of those synonymous names and the compiler won’t care.

But each entity always has a uniquely “truest” name, privileged above all the other ways to refer to it. In some situations, in order to do a thing with an entity, you do actually need to call it by its “true name.” Here is a (non-exhaustive) list of such situations.