Re: Loops (was Re: do { quit; } else { })

On 21/04/2025 12:34, James Kuyper wrote:

bart <bc@freeuk.com> wrote:

On 19/04/2025 20:22, James Kuyper wrote:

...

I wasn't talking about him finding the tools problematic. I was talking
aobut him find it difficult to ensure that the expressions are not
arbitrary unrelated expressions, but are in fact correctly related
expressions. If you cannot ensure that A, B, and C have the correct
relationship to make for(A; B; C) work as needed, then you also lack to
ability to make sure that the expressions in {A; B; C:} work together as
needed, and that ability is fundamental to computer programming.

>
In other words, the feature is dumb.

 The feature allows you to pack all of the loop management stuff together
where it's easy to check and think about. It can be misused, by putting
together stuff that has nothing to do with loop management, just as an
assignment statement can be misused by writing, for instance
      annual_salary = current_income + age;
 

The compiler cannot do any checking: for (i=0; i<n; ++n) is fine.

 The compiler cannot tell you what's wrong with that assignment
statement, either.

You don't understand the issue. OK, that's fine. Because it is possible to make typos at any point in the source code, then it doesn't matter if the language provides unnecessary extra opportunities for those errors.
All those languages with strict type systems to allow more compile-time error-checking are pointless, since nothing stops you writing 'a = 0' instead of 'a = 1'.
But there is also the human aspect; which of these for-loops have typos (assume that 'i' and 'n' are the right spellings):
    for (i=0; i<n; ++n)
    for (i=0; i<n; --i)
    for (i=0; i<=n; ++i)
    for (i=0; i<n; ++i)
That fact is, you can't tell. It depends on intention, which is unclear /because/ of the flexibility of the construct. That second example looks dodgy, but the compiler can't pick that up either.
In that case, I have to ask, why even bother with such a construct. Just have:
      i = 0;
  L1:
      if (i<n) goto L2;
      ...
      ++i;
      goto L1
  L2:
This is even more flexible.