Example:

    (loop repeat 8
               ;; init x, then decide how to "prepare" next  iteration
               for x = 0 then (+ (* 2 x) 1)
               collect x)

    (0 1 3 7 15 31 63 127)

    (loop repeat 8
               for x = 0 then (+ (* 2 x) 1)
               ;; but stop if x gets too big
               while (< x 100)
               collect x)

    (0 1 3 7 15 31 63)

---

    (prog1 foo bar*)

Useful if `foo` is the condition and you need to perform some change to it immediately after, eg:

    (while (prog1 (< next prev) (setq prev next)) ...)

    (prog2 foo bar baz*)

Might be what GP wants. `foo` is the preparation, `bar` is the condition`, and `baz` can be some post-condition mutation on the compared value. Not too dissimilar to

    for (pre, cond, post) {}

    (while (prog2 pre cond post) ...)

    (progn foo*)

`progn` is similar to repeated uses of the comma operator in C, which GP has possibly overlooked as one solution.

    while (prepare, condition) { process }

    for ([]{
        /*prepare*/
    }(); /*condition*/;) {
        /*body*/
    }

Let's rewrite the loop this way, with 'break' expanded to 'goto':

  while (true) {
    prepare...
    if (!cond) goto exitpoint;
    process...
  }
  exitpoint:

  goto entrypoint;
  do {
    process...
  entrypoint:
    prepare...
  } while(cond);

If we want to add the same kind of syntactic sugar for the jump-in case, the landing point must be explicit (no way for the compiler to guess it), so the only one we can make implicit is the starting point, that is where the 'do' is.

So we need: a new statement, let's call it 'entry', that is the dual of 'break' and a new semantic of 'do' to not start the loop at the opening '{' but at 'entry'.

  do {
    process...
    entry;
    prepare...
  } while (cond);

  loop
    Get(Current_Character);
  exit when Current_Character = '*';
    Echo(Current_Character);
  end loop;

    do {
        Get(Current_Character);
        if (Current_Character == '*') break;
        print(Current_Character);
    } while (true);

    loop
        prepare;
        while check;
        process;
    end;

[0] https://pic.plover.com/knuth-GOTO.pdf

  do {
      let value = prepare();
  } while (value.is_valid) {
      process(value);
  }

Your are right about the word double braces, but I can't think of an alternate syntax other than just removing the braces around the while. But in that case it may seem odd to have a keyword that can only be used inside a specific block...wich is basically a macro for a if(.)break; Maybe I'm too used to the c/java syntax, maybe with a different way of defining blocks?

Hard to express without primitives to indicate that, maybe.

As long as it's documented and expected, it's not weird.

The scope then is the whole "do-while" statement, not the brace.

  do {
      let value = prepare();
      while (value.is_valid) {
         process(value);
  }

  values := []string{"hello", "world"}
  for v, value := range values {
    fmt.Printf("%s", value);
  }
  inter {
    fmt.Printf(",")
  }
  before {
    fmt.Printf("[")
  }
  after {
    fmt.Println("]")
  }
  empty {
    fmt.Println("(nothing found)")
  }

from <initialization statements> until <termination condition> loop <group of statements> end

https://docs.python.org/3/reference/compound_stmts.html

See sections 8.3, the for statement, and 8.2, the while statement.

Scala for example has a `breakable {}` block that lets you indicate where you should land after a `break`

    breakable {
      while condition {
        // loop body
        if otherCondition then break;
        // rest of the body
      }
      // body of pythonic else block
    } // you land here if you break

  repl_prompt="${repl_prompt-repl$ }"
  while
    printf "%s" "$repl_prompt"
    read -r line
  do
    eval "$line"
  done
  echo

This should also be doable in languages where statements are expressions, like Ruby, Lisp, etc.

Here's a similar Ruby repl:

  while (
    print "repl> "
    line = gets
  ) do
    result = eval line
    puts result.inspect
  end
  puts

Sidenote: I wasn't aware that shell allows for multiple lines, good to know!

I find this so incredibly useful, that I miss it from other languages.

Something related that I've noticed with OO languages such as Java is that it tends to result in "ceremony" getting repeated n-times for processing n objects. a well-designed begin-process-end syntax for function calls over iterables would be amazing. This could apply to DB connection creation, security access checks, logging, etc...

Though, you still need all that to be nested inside the loop (a closure, more generally.)

    while { prepare; condition } 
    do { process }

Scala has a lot of syntax goodies although some stuff is exotic. For example to have a 'break' you need to import it and indicate where from exactly you want to break out of.

Something like

  do{
    raw_data=produce.get()
    data=parse(raw_data)
  }while(data!=STOP){
    process(data)
  }

A do-while here also has the same issue, but in this case after you check the condition you can't do any processing afterwards (unless you move the check and process into a single check_and_process method...which you can totally do but again the idea is to not require it)

  do {
    offset = tell(filehandle)
  } while(line = readline(filehandle))
  {
    print "line starts at offset: ", offset
  }

Look at C: it has 5 loop-related keywords (4.5; 'break' is two-timing in 'switch') yet it is still not enough.