The Mismatch of Arity-1 UNTIL and Arity-2 WHILE

[hostilefork]

Long ago, there was a fervent debate about whether UNTIL was a word that was "naturally paired" with WHILE. So it was wondered if UNTIL should be an arity-2 function which was effectively WHILE-NOT, instead of its arity-1 form.

The altered arity-2 UNTIL was introduced in Ren-C to try it, with LOOP-UNTIL taking over the old arity-1 behavior. For good measure, LOOP-WHILE was added as an arity-1 native as well.

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 U be UNTIL is an appealing option.)

When you look at forever [...] and until [...], they seem to go together sensibly. You might even 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.

I didn't wind up using loop-while and loop-until as much as I thought I would. 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 people who fought for the status quo--DocKimbel/Rebolek/Oldes/etc.--get to win on this one, I guess.

[hostilefork]

7 Years Later, I Asked AI

The Rebol language has two looping constructs that have always seemed a little jarring because WHILE is arity-2, and UNTIL is arity-1.

The concept of WHILE is like any other language's while loop: it takes a block which is conditional code, and keeps running a second block, that acts as a loop body, until that condition evaluates to be falsey. The last result generated by the body is returned, or nothing ("unset") if the body never ran.

But then UNTIL is arity-1 ... it just keeps running the body until the body evaluation itself synthesizes a truthy product.

Both are useful, but I feel like most people would expect UNTIL to be arity-2 and take the meaning of WHILE-NOT, running the body block so long as the condition evaluated to false.

The problem is that (while [not ...] [...]) is easy enough to write (especially because there's no precedence that would bind the NOT strangely to its subsequent expression--it really means "negate everything that comes after). And it isn't easy to think of a name for the arity-1 looping construct if UNTIL is taken away.

Is there any good, non-hyphenated, clear name that could take over UNTIL's job if UNTIL were to be repurposed as WHILE-NOT?

ChatGPT Says: "Most promising: AGAIN"

• Works well with arity-1 semantics: keep doing the body until it says not to.

• Has a connotation of a control signal, which fits the current UNTIL model.

• Could become idiomatic quickly:

  again [
      print "Trying..."
      attempt-connect
  ]
  

Perplexity Agrees: "AGAIN stands out"

(Note: I didn't tell Perplexity what ChatGPT said, it picked AGAIN as its top choice on its own.)

Most established non-hyphenated names are either too generic or already overloaded. AGAIN stands out as:

• Non-hyphenated
• Short and clear
• Suggests "keep doing this again until it returns true"

AGAIN is the clearest, most intuitive, and non-hyphenated candidate to take over the arity-1 looping construct if UNTIL is repurposed as an arity-2 WHILE-NOT. It captures the semantics of "keep running this block again until it says to stop" without overloading existing meanings or requiring a hyphen.

Claude.ai Didn't Suggest AGAIN, But Agrees It's Best

AGAIN is an excellent suggestion that I overlooked. I can see why both ChatGPT and Perplexity recommended it as their top pick.

AGAIN has several clear advantages:

1. It's concise and intuitive - "AGAIN [block]" reads naturally as "execute this block again and again until it returns a truthy value"
2. It avoids the potential confusion with counted iterations that LOOP might introduce
3. It directly implies repetition without specifying a termination condition, which perfectly matches the arity-1 nature of the construct
4. It feels more like a control structure word than some of my suggestions like SEEK or PURSUE

The word has a comfortable familiarity that would fit well within Rebol's typically straightforward naming conventions. The mental model of "do this AGAIN until it works" is very clear and distinct from both WHILE and the repurposed UNTIL.

Yes, I do like AGAIN as a replacement. It's arguably better than any of my suggestions and would make for a very natural transition:

[hostilefork]

But I Don't Give In That Easily...

I think it's important to think about how this would actually be used.

The status quo suggests iteration, but not necessarily how one wants to suggest it... it sounds postfix:

append data until [request-server-token else [wait 5]]

That sounds like "keep appending data until the following thing is true".

But AGAIN doesn't necessarily make any sense either:

append data again [request-server-token else [wait 5]]

What we want is something in the vein of DON'T-GIVE-UP or DON'T-TAKE-NO-FOR-AN-ANSWER or KEEP-AT-IT.

How about INSIST ?

append data insist [request-server-token else [wait 5]]

ChatGPT Says...

Yes, that example captures the nuance perfectly—and INSIST really shines in that context. It tells a tiny story: we are appending data obtained by insisting that the server give us a token, otherwise we wait. It's more than just looping—it's demanding a result.

By contrast:

append data until [request-server-token else [wait 5]]

This works mechanically, but it’s semantically blurred: the block itself is acting as both the action and the condition, which is unconventional and jarring for those expecting UNTIL to mean WHILE-NOT.

And while:

append data again [request-server-token else [wait 5]]

...isn't bad, it lacks the assertive voice that INSIST provides. It feels neutral, whereas INSIST feels purposeful. That pushy tenacity is exactly what this arity-1 loop needs to communicate.

Why INSIST Works So Well Here

• It's a verb that sounds like a looping directive.

• It implies trying until a condition is met—without requiring a separate condition.

• It avoids confusion with control flow keywords like RETRY or CONTINUE.

• It fits idiomatically as a modifier to an action like append.

Testing Other Examples

upload-file insist [connect-to-network and send or [wait 10]]
get-token insist [try-auth or [rotate-keys wait 5]]

These read naturally—as if you're reading imperative, persistent intentions.

Perplexity AI Says...

That’s a fantastic insight-and a great example of how surface syntax and natural language feel matter in language design, especially for a language like Rebol that prizes readable, intention-revealing code.

You’re right:

• append data until [...] reads as “keep appending data until…”-which implies the append is being repeated, not just the block.
• append data again [...] is ambiguous and doesn’t clarify the relationship between append and the block.

You want a word that:

• Clearly signals persistence/retrying until success.
• Feels imperative, like a command to the interpreter.
• Reads well postfix (after the main action).

INSIST is:

• Imperative: “Insist” is a verb, which fits well with Rebol’s style.
• Conveys intent: It suggests “keep trying until you succeed.”

It's slightly unusual as a programming keyword, but that’s not necessarily bad (Rebol is all about breaking conventions for clarity).

Claude.ai Says ...

INSIST is a brilliant suggestion! It captures the semantic meaning perfectly and reads naturally in context.

The word conveys persistence and determination, which exactly matches the behavior of continuing execution until a truthy result is achieved.

The implied meaning of INSIST aligns perfectly with the semantics:

• It suggests continuing until successful
• It carries a sense of not accepting failure as a final answer
• It naturally implies repetition without needing to specify a condition
• It works well as a prefix operator

Other benefits of INSIST:

1. It's concise but descriptive
2. It's not commonly used as a keyword in other languages, reducing confusion
3. It has a clear, intuitive meaning even to newcomers
4. It suggests the block will be evaluated repeatedly until it "gets its way" (returns true)

Your analysis showing why UNTIL and AGAIN don't read naturally in context is spot on. INSIST solves that problem elegantly, making the code both more readable and self-documenting.

I think INSIST is superior to my previous suggestions and to AGAIN. It reads naturally in code, clearly communicates intent, and fits well with Rebol's design philosophy of readable, expressive code.

[gchiu]

in my experience AI will always congratulate you on a suggestion!

[hostilefork]

If I just went with whatever AI praised, I would have stopped at AGAIN.

The reason I gather these opinions is more as brainstorming, to see what points are brought up. It adds to the discourse. And what's great about it is just how fast the turnaround is in these discussions--they're almost as prolific as I am.

As this case demonstrates, ultimately I make the calls--based on real examples and what works in practice.

INSIST is a winner here

And I think we can see why if there's an arity-1 variant that uses the word UNTIL and is intended to be used in this way, it would need to be LOOP-UNTIL to make sense.

append data until [any [request-server-token, wait 5]]

Even a religious Rebol2/Red zealot would have a hard time not reading that as postfix (if they speak English). It's as if the APPEND itself is looping.

@hostilefork

So people who fought for the status quo--DocKimbel/Rebolek/Oldes/etc.--get to win on this one, I guess.

Or not! Oh well, better luck next time...

But of course, someone could say until: insist/ in their standard utility include file, and define other things however they want. Freedom of choice!

[hostilefork]

@hostilefork

append data until [any [request-server-token, wait 5]]

Even a religious Rebol2/Red zealot would have a hard time not reading that as postfix (if they speak English). It's as if the APPEND itself is looping.

So the question of UNTIL being prefix vs. postfix makes me wonder, if UNTIL would be better as postfix.

let x: 0
(
    x: x + 1
    print ["X is" x]
) until x = 5

or on a new line:

let x: 0
(
    x: x + 1
    print ["X is" x]
)
until x = 5

Compare to:

let x: 0
insist [
    x: x + 1
    print ["X is" x]
    x = 5
]

The bargain here of weird infix isn't quite the same as with the infix UNLESS, because your left hand side is almost always going to be multiple lines of code, vs. a single value or tiny expression. You have to be doing something that can alter state and have side-effects, to change things enough that the until terminates.

Personally I think CYCLE works better here:

let x: 0
cycle [
    x: x + 1
    print ["X is" x]
    if x = 5 [stop]
]

You can put your STOPs anywhere you want. And you can use STOP:WITH if you want to evaluate to a value.

As an interesting variation... my ATTEMPT looping construct that runs a loop body exactly once, could have RETRY in it:

let x: 0
result: attempt [
    x: x + 1
    print ["X is" x]
    if x != 5 [again]  ; this is where I think AGAIN should be used
    x * 10  ; you could separate the retry triggers from loop result
]
assert [result = 50]

ATTEMPT would give you BREAK (drop NULL out the bottom), CONTINUE and CONTINUE:WITH (drop VOID or a value out the bottom), and then this additional AGAIN to just take it from the top.

(Perl calls this REDO. I thought maybe RETRY but we have trouble in that TRY and RETRY sound related, and DO and REDO sound related... but... only so many words. Seems the right use for AGAIN.)

So I can't endorse postfix UNTIL

Even though UNLESS has shown cool usages, those just don't add up for a postfix UNTIL.

UNTIL as a synonym for WHILE-NOT is the better idea. And an ATTEMPT construct that's able to run AGAIN from the top is much clearer than INSIST in most cases... but INSIST will still be available.