lament | Check out the new one

[gcc] was getting hung up on the try, that normally wouldn't be allowed in a constexpr function.

This is correct for a C++17 program. (C++20 relaxed this, so a try block can now be used in a constexpr function. However, it is only the try that is allowed; it is not allowed for execution to hit something that throws an exception.)

That's why I had to use an immediately invoked lambda expression.

The implication here is that your approach made your code valid. This is incorrect. Using an an immediately invoked lambda did not work around the problem; it swept the problem under the rug. The try is still a problem, but now compilers do not have to tell you it is a problem.

Using a lambda switches the constexpr criterion from the straight-forward "the function body must not contain a try-block" to the indirect "there exists at least one set of argument values such that an invocation of the function could be an evaluated subexpression of a core constant expression". The tricky part here is that a violation of the latter criterion is "no diagnostic required", meaning that all the compilers are correct, whether or not they complain about this code. Hence my characterization of this as sweeping the problem under the rug.

So why is... that criterion is a long thing to repeat... what's the issue involving "core constant expressions"? C++17 removed the prohibition against lambdas in core constant expressions, so that much looks good. However, there is still a requirement that all function calls within the constexpr function also be themselves constexpr. Lambdas can become constexpr in two ways. First, they can be explicitly marked constexpr (but if you do that here, the complaint about the try block should come back). Second, they can simply satisfy the constexpr function requirements. However, your lambda contains a try, so it is not constexpr (in C++17).

Your lambda is not a valid constexpr function. Hence calling it is not allowed in a core constant expression. There is no execution path through can_represent() that avoids invoking your lambda. Therefore, can_represent is not a valid constexpr function, no diagnostic required.

One option could be:

Just book+" "+chapter+":"+verse should do it. It's elementary string concatenation.

You need to use double quotes here:

I will assume that your insert breaks because you're not having the same number of elements in all arrays.

So if you had 4 elements in the array1 but 7 in the array2, when you try to access array1[5], it would break.

You can try with the following:

It does not match as it expects 2 characters using (([ .)\n|])([^a-zA-Z])) where the second one can not be a char a-zA-Z due to the negated character class, so it can not match the s in Jude some.

What you might do is make the character class in the second part optional, if you intent to keep all the capture groups.

You could also add word boundaries \b to make the pattern a bit more performant as it is right now.

See a regex demo

(Note that Jude is listed twice in the alternation)

If you only want to use 3 groups, you can write the first part as:

Given:

You can make two separate plots, one for pre-2020 and another starting with 2021 and put them next to each other with a small margin using a facet. I think that achieves your goal without potentially confusing your audience with an arbitrary jump in x-axis labels.

Maybe something like this:

You can pre-calculate the percentages before plotting.