I hack C++ at work. In addition to the usual difficulties of writing in a low-level language with a buggy compiler, this means I have to write in a style other C++ speakers will understand. Occasionally I forget, and write as I would in a functional language. The other day I wrote some code like this:
if (constraint == (frobnicated ? MUST_NOT_FROBNICATE : MUST_FROBNICATE)) die("illicit frobnication");
Someone found it hard to read, so I changed it to make the logic very explicit:
if (frobnicated && constraint == MUST_NOT_FROBNICATE || !frobnicated && constraint == MUST_FROBNICATE) die("illicit frobnication");
On reflection I agreed it was easier to read, even though it was longer. Why?
Maybe it's because the ternary operator is so awkward in C++. It's often hard to parse, so it's not used much, so readers of C++ don't expect to see it, especially not as an argument to
==, and especially not in the control expression of another conditional. And since they don't expect to see it, it's harder to read. Is this easier in a different language?
(when (eq constraint (if frobnicated 'must-not-frobnicate 'must-frobnicate)) (error "illicit frobnication"))
In my opinion that's a small improvement in syntax, but none in semantics. It's still confusing. So my initial impression was wrong. This isn't about C++ after all; it's the logic that's confusing.
What if the test is something other than equality? ISTM this variation is a little less confusing, despite being more general:
(when (member (if frobnicated 'must-not-frobnicate 'must-frobnicate) constraints) (error "illicit frobnication"))
I think the real problem is the pseudo-Boolean nature of the constraints. It's hard to read
MUST_NOT_FROBNICATE in a Boolean expression without thinking the
NOT is the negation operator and it's involved in the expression somehow. (Of course it is, but not directly enough that it helps to think of it.) That's only a minor problem, but when it's combined with a conditional expression and a comparison of Booleans, the total confusion is enough to slow the reader down, or to overwhelm the less logic-minded.
We can get rid of the whole thing easily enough. What if the constraint were a function instead of an enumeration?
(unless (funcall allow-frobnication frobnicated) (error "illicit frobnication"))
That's much simpler, and IMO easier to read too. Another victory for functional style! Unfortunately it moves some complexity (especially in C++) to the three
allow-frobnication functions. And to many C++ speakers it's odd enough to be much more confusing than the original version. In this case expressiveness is limited by what the readers understand, not by what the language does.