Comment by TrianguloY

I suspect you'll love Common Lisp's LOOP: https://gigamonkeys.com/book/loop-for-black-belts

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)

You can insert a condition check in the middle, of course:

    (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)

And much, much more. It's the ultimate loop construct.

C-style for-loop is kinda sorta this. Although the "prepare" part has to be an expression rather than a statement, given that you have the comma operator and ?: you can do a lot there even in C. In C++, you can always stick a statement in expression context by using a lambda. So:

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

However, the most interesting take on loops that I've seen is in Sather, where they are implemented on top of what are, essentially, coroutines, with some special facilities that make it possible to exactly replicate the semantics of the usual `while`, `break` etc in this way: https://www.gnu.org/software/sather/docs-1.2/tutorial/iterat...

In some way it's the dual of break, in that you want to jump into the middle of the loop, while break is to jump out of it.

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

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

The dual would be:

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

Both constructs need two points: where the jump begins and where it lands. The 'break' is syntactic sugar that removes the need to specify the label 'exitpoint'. In fact with 'break' the starting point is explicit, it's where the 'break' is, and the landing point is implicit, after the closing '}'.

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);

Is it more readable than today's syntax? I don't know...

Ada has had something similar and very flexible since from the 80s ... like:

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

There's not that much new under the prog lang sun :(

Well, I am in a process of making a language where general loops will look like

    loop
        prepare;
        while check;
        process;
    end;

I also think you'd enjoy Knuth's article "Structured Programming with go to Statements" [0]. It's the article that gave us the "premature optimization is the root of all evil" quote but it's probably the least interesting part of it. Go read it, it has a several sections that discuss looping constructs and possible ways to express it.

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

Interesting idea, but once you add scoping:

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

Can the second block of the do-while see `value` in its lexical scope? If yes, you have this weird double brace scope thing. And if no, most non-trivial uses will be forced to fall back to `if (...) break;` anyway, and that's already clear enough imo.

I think we have a similar way of thinking. I once wrote a blog post about a for loop extension (based on Golang for illustration) [0].

  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)")
  }

[0] https://lukas-prokop.at/articles/2024-04-24-for-loop-extensi...

Eiffel has the loop structure.

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

When we are on subject of loops... I'd love to have 'else' block for loops that runs when the loop had zero iterations.

You mean like a shell's while-do-done? It's just about allowing statements as the conditions, rather than just a single expression. Here's an example from a repl I wrote:

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

The `printf` is your `prepare`.

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

PowerShell can process 0..n input objects from the pipeline using BEGIN {...} PROCESS {...} END {...} blocks.

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...

Raku can do this with Phasers: https://docs.raku.org/language/phasers and last/next/redo: https://docs.raku.org/language/phasers

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

In Scala you can do:

    while { prepare; condition } 
    do { process }

This runs all 3 in order every iteration but quits if condition evaluates to false. It just uses the fact that value of a block is the value of the last expression in the block.

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.

Not quite the same but almost feels like the BEGIN block in awk.

I don't write a lot of while loops so this is just a bit unfamiliar to me, but I'm not really understanding how this isn't the same as `do{block}while(condition);`? Could you give a simple example of what kind of work `prepare` is doing?

The C language construct for that is 'goto'.

At what point are you just doing async and coroutines?