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.

My grandmother’s grandfather was David Celyddon Phillips (1848–1915), Welsh-born minister and poet, known by the bardic name “Celyddon.” Recently I learned that my second cousin David M. Phillips Jr. has in his possession a leatherbound, hand-written copy of D. C. Phillips’ long narrative poem The Promised One, or, Jesus of Nazareth — previously unpublished as far as either of us know, despite that one of Celyddon’s lengthy obituaries mentions:

Via Hacker News: “Making Explainable Minesweeper” (July 2025). By “explainable Minesweeper,” the blogger means that we generate a Minesweeper level that is guaranteed solvable by perfect play — that is, for which the solution never requires “guessing” at an unknown cell (and possibly losing the game at that point). The blogger describes a procedure for creating partially explainable levels: simply generate a random level, then simulate solving it with a computer player that knows only certain heuristics. If the computer player completes the level without guessing, then it’s good; otherwise, generate a new random level and repeat.

About 15 years ago I was active with the Santa Barbara Jugglers Association (which still exists and still meets up by UCSB in Isla Vista). They’re particularly known for club-passing in moving patterns. We’re talking things like Havana and Shooting Star. (I don’t think either of those patterns came out of Isla Vista, mind you. I don’t know where either of them did come from. The Madison Area Jugglers’ Pattern Book credits Shooting Star to “Bryan Olson in 1993.”)

4x4x4 Tic-Tac-Toe is played on a 4x4x4 cube, containing 64 cells. The first player to get 4 of their own symbols in a row (in any orthogonal or diagonal direction, including the cube’s space diagonals) wins.

The other day I ran across some code like this:

template<class T>
struct Holder {
  T t_;
  explicit Holder() : t_() {}
  Holder(const Holder& rhs) : t_(rhs.t_) {}
  ~~~~
};

This was in an old codebase, which until recently had still been using GCC’s -Weffc++ to enforce C++98 idioms such as the explicitly non-defaulted copy constructor depicted above.

If you’re still using -Weffc++, please, stop using it!

Suppose you’re implementing a “Wordle-like” game such as Juho Snellman’s Huewords or Alan Bellows’ Omiword. The defining principle of such games (as I’m defining them here, anyway!) is that the solution to the puzzle is an arrangement of English words which satisfies some criterion, and the player arrives at that solution by guessing various English words, such that the game must differentiate “that’s a valid word, but not the answer” from “that sequence of letters isn’t even a word.”

In Book 4 of Virgil’s Aeneid, I find two noteworthy phrases. First, in Virgil’s description of the monstrous goddess Rumor (lines 173–183; tr. Goold) —

Here’s a simple non-constexpr-friendly Optional type. (Godbolt.)

template<class T>
class [[trivially_relocatable(std::is_trivially_relocatable_v<T>)]] Optional {
~~~~
  alignas(T) char data_[sizeof(T)];
  bool engaged_ = false;
};

Here’s a simple C++20 constexpr-friendly Optional type. (Godbolt.)

template<class T>
class [[trivially_relocatable(std::is_trivially_relocatable_v<T>)]] Optional {
~~~~
  union {
    char pad_;
    T t_;
  };
  bool engaged_ = false;
};

Here’s a simple and trivially relocatable MoveOnlyCallable type. This is like std::move_only_function<int(int) const>, except that the “take int and return int” part is hard-coded, for simplicity. (Godbolt.)