Hi,
Naming is hard, for sure. Here is my review. I find the names mostly reasonable, except
Round::PositiveInfinity and Round::NegativeInfinity. I will discuss Round::PositiveInfinity.
First:
> I've discussed this with Saki. In that case the HalfEven and
> HalfOdd modes would also need to be renamed to HalfTowardsEven and
> HalfTowardsOdd
For me, the implied preposition in HalfEven is “to”, not “towards”. In other
words, in the HalfEven mode, a half-number is replaced with the nearest even integer; it is not
replaced with a integer *in the direction of* (or: *towards*) an even integer. So,
Round::HalfEven is fine; but Round::PositiveInfinity does not make much
sense to me, as the number is not rounded to +∞, but towards +∞.
-------
Second, “TowardsPositiveInfinity” is just a mouthful synonym for “Up”. You could just name
it:
Round::Up
At this point, you may invoke either Hamming or Levenshtein and compare it negatively with
Round::HalfUp. Yes there is a risk a confusion (and I do think that such a name is
suboptimal for this reason), but the confusion is not just caused by the short Levenshtein distance.
That brings to the most important part of my review.
-------
In my opinion, the most important criterion for a good name is:
The name must be clear for itself, not just when comparing it with other ones.
The problem with Round::Up (or Round::[Towards]PositiveInfinity), when you
first encounter it, is that it is relatively easy to mistakingly assume that it is a “half-*”
mode, and to erroneously interpret it as Round::HalfUp (or, its synonym
Round::HalfTowardsPositiveInfinity).
But that the converse is false: it is impossible to interpret Round::HalfUp as if it
were Round::Up (or Round::TowardsPositiveInfinity), because of the
distinctive “Half” token that immediately indicate the right interpretation.
So, the best way to disambiguate Round::Up from Round::HalfUp, is not to
replace “Up” with some creative synonym, but to add a distinctive token that plays the role of
— and contrasts with — “Half”. I don’t know if the following suggestion makes sense for
you, but it is the one I have found:
Round::FullUp
---------
That said, I think that there is an even better option. I know you will not like it, but bear with
me. I sincerely think that the best name is just:
Round::Ceiling
It is short, distinctive, and standard across the computing industry.
Yes, this name is idiosyncratic to English and not used in several other (natural) languages, and if
you don’t know English, you will not grasp the metaphor and have to just learn it. However,
whatever other name you invent, you *have* to learn “ceil” anyway, because you *will* encounter
it sooner or later. Many common (programming) languages, including JavaScript, C++, Java, Python,
have a ceil function. Even if you manage not to learn any of those and to code in PHP
only, you are at risk to stumble on its built-in ceil(...) function, or its
newly-introduced bcceil(...) variant.
Therefore, unless we find a name that is *really* good, I suggest to not fall into the NIH syndrome,
and not to force users to learn another name *in addition to* “ceiling”.
---------
For the same reason, Round::TowardsZero (suboptimal, because confusable with
Round::HalfTowardsZero) could be replaced with: Round::Truncate.
—Claude