Long ago, there was a fervent debate about whether UNTIL was a word that was "naturally paired" with WHILE...like IF and UNLESS. Hence, should UNTIL be an arity-2 function which was effectively WHILE-NOT, instead of its arity-1 form.
The change was introduced in Ren-C to try it. But as an interim solution before the name was truly reclaimed,
while-not was added. The intent was to go in and replace it with UNTIL later, after the change had settled. LOOP-WHILE and LOOP-UNTIL were the arity-1 natives.
I've come to believe the interim solution should be the final solution. Hence UNTIL is reverted to its previous meaning, with WHILE-NOT being an arity-2 native, and UNTIL-NOT being an arity-1 native.
UPDATE: October 2020: There is now an even more general solution with predicates. You can write until .not [...] or until .even? [...] or until .not.integer? [...]... the predicate will be applied for the purposes of the test, but you'll be returned the last loop result unmodified! It's not clear whether predicates will be added to WHILE...but they may play some role with it.
To make a long story short: I guess I don't think that it wound up making that big a difference in the scheme of things. The primary impact on me personally, was actually just making code golf programs longer. (Having
UNTIL is an appealing option.)
When you look at
forever [...] and
until [...], they seem to go together sensibly, and you might ask--as some have--if it's WHILE that's weird. If you think about WHILE and UNTIL as being two words offering entry points into loop space, it's like it's giving you two common ones with common words.
Plus I didn't wind up liking
loop-until as much as I thought I would...and I actually didn't end up minding
So here in the time of analyzing changes for goodness or badness and trying to pin things down, I think the status quo is the better answer. Plus, when there are so many other slam-dunk good changes, this one is more a distraction than anything else.
So DocKimbel/Rebolek/Oldes/etc. get to win on this one.
Note: The reason for having WHILE-NOT and UNTIL-NOT natives isn't just performance (though they are faster than having to run each condition through a Rebol NOT in the evaluator). They also avoid a precedence issue you get in the new workings of things like equality tests, where
while [not x = 10] [...] is read as
while [(not x) = 10] [...]. If you use them, you can take advantage of the fact that your condition is "already grouped" by its block, and not worry about parenthesizing it further.
(Note that interpretation of not and = is the common one in languages with precedence...
= is lower than
! in C for instance, and you're expected to use
!=. So it shouldn't surprise most people, but since it's not coming from precedence, see more about why it happens in: TO NOT B OR TO NOT (B)…is…no longer a question)