Feature suggestion - repeat while.. until

[egsuh]

How about this structure?

Code: Pascal  [Select][+][-]

1. dataset.first;
2. repeat while (not DataSet.eof)
3.      // do something with the record..
4.      dataset.next;
5.      id := dataSet.Fields[0].AsInteger;
6.  
7. until id >= 10000;

The loop stops when the dataset reach end of dataset or a specific condition is met. Of course in this simple case the two conditions are easily combined, but sometimes there are very tricky situations.

[cdbc]

Hi
<long #¤%¤ sentence here> NOT!
Regards Benny

[paweld]

why not:

Code: Pascal  [Select][+][-]

1.   dataset.first;
2.   while not DataSet.eof do
3.   begin
4.     if dataSet.Fields[0].AsInteger >= 10000 then
5.       break;
6.     // do something with the record..
7.     dataset.next;
8.   end;

In my opinion, it's much simpler and clearer

[cdbc]

Hi
+1 to Pawel
@paweld: Exactly my thoughts; If one needs egsuh's proposal, one is clearly doing it wrong...!
Regards Benny

[egsuh]

<long #¤%¤ sentence here> NOT!

What do you mean with this? If I'm bothering you in any way, I'll avoid it.

 

Code: Pascal  [Select][+][-]

1.  dataset.first;
2.   while not DataSet.eof do
3.   begin
4.     if dataSet.Fields[0].AsInteger >= 10000 then
5.       break;
6.     // do something with the record..
7.     dataset.next;
8.   end;

Yes, this is possible of course.  The key is not using break --- as if goto degrade readability.
I'll post more proper cases when I meet.

[paweld]

I don't agree that break reduces readability - it's important to remember that it simply breaks the current loop. Unlike goto, which jumps to a specific location (label).
And if you don't want to use break, you can also extend the condition for while:

Code: Pascal  [Select][+][-]

1.   dataset.first;
2.   while not DataSet.eof and (dataSet.Fields[0].AsInteger < 10000) {or: `not (dataSet.Fields[0].AsInteger >= 10000)` } do
3.   begin
4.     // do something with the record..
5.     dataset.next;
6.   end;

[Khrys]

The key is not using break --- as if goto degrade readability.

Splitting the loop condition in half does more to degrade readability than a single goto ever would, IMHO.

Of course in this simple case the two conditions are easily combined, but sometimes there are very tricky situations.

What would such a situation be? I've never felt the need for such a construct,  while  with boolean short-circuiting (as @paweld demonstrated) is already powerful enough.

[Zvoni]

why not:

Code: Pascal  [Select][+][-]

1.   dataset.first;
2.   while not DataSet.eof do
3.   begin
4.     if dataSet.Fields[0].AsInteger >= 10000 then
5.       break;
6.     // do something with the record..
7.     dataset.next;
8.   end;

In my opinion, it's much simpler and clearer

A bit of nitpicking: pawel's code (and all other following it) is NOT equivalent to OP's sample

Correct:

Code: Pascal  [Select][+][-]

1.   dataset.first;
2.   while not DataSet.eof do
3.   begin
4. // do something with the record..
5.     dataset.next;
6.     if dataSet.Fields[0].AsInteger >= 10000 then break; //Condition-Check is the last Statement in a repeat-loop
7.   end;

[Warfley]

The difference between a head condition vs a tail condition in a loop is only the very first check. So if the goal is to have both withouth a break, the easiest solution would be:

Code: Pascal  [Select][+][-]

1. dataset.first;
2. if not DataSet.eof then
3.   repeat
4.     ...
5.   until DataSet.eof or (dataSet.Fields[0].AsInteger >= 10000);

[ASerge]

A bit of nitpicking: pawel's code (and all other following it) is NOT equivalent to OP's sample

I think the OP code contains an error, but the suggested code is more correct.
Error: skipping the first record and doing something after eof.

[DavidL]

The difference between a head condition vs a tail condition in a loop is only the very first check. So if the goal is to have both withouth a break, the easiest solution would be:

Code: Pascal  [Select][+][-]

1. dataset.first;
2. if not DataSet.eof then
3.   repeat
4.     ...
5.   until DataSet.eof or (dataSet.Fields[0].AsInteger >= 10000);

This is correct only with short-circuit evaluation of the OR, yes?

[Thaddy]

@DavidL
No. Shortcut stops when the first is true. It won't and does not need to evaluate the second condition.
Because you asked for OR.
The second condition is only evaluated if the first is false.
Without shortcut evaluation both are evaluated, but the result is always the same.

Leaving shortcut evaluation OFF is only relevant if you want to evaluate OR booleans in constant time.
Because constant time is the only side effect, except from some rare, contrived, conditions that change variables during evaluation and rely on that: bad code.
Constant time is only necessary to counter timing attacks.

What does matter is having the most common condition evaluate first: faster code.
In this case: if you know the dataset is - or can be - larger than 10000, reverse the conditions.

[rvk]

How about this structure?

Code: Pascal  [Select][+][-]

1. dataset.first;
2. repeat while (not DataSet.eof)
3.      // do something with the record..
4.      dataset.next;
5.      id := dataSet.Fields[0].AsInteger;
6.  
7. until id >= 10000;

The loop stops when the dataset reach end of dataset or a specific condition is met. Of course in this simple case the two conditions are easily combined, but sometimes there are very tricky situations.

Maybe you should specify that "very tricky" situation then.

In your example you can end up with id < 10000 and no more records (dataset.eof). What then ???
(mixing while and repeat would only make code less readable)

The difference between a head condition vs a tail condition in a loop is only the very first check. So if the goal is to have both withouth a break, the easiest solution would be:

Code: Pascal  [Select][+][-]

1. dataset.first;
2. if not DataSet.eof then
3.   repeat
4.     ...
5.   until DataSet.eof or (dataSet.Fields[0].AsInteger >= 10000);

If you do this you (can) miss the processing of the last record (assuming you do dataset.next just before the until (because if you don't, you miss processing the first record).

[Zvoni]

The difference between a head condition vs a tail condition in a loop is only the very first check. So if the goal is to have both withouth a break, the easiest solution would be:

Code: Pascal  [Select][+][-]

1. dataset.first;
2. if not DataSet.eof then
3.   repeat
4.     ...
5.   until DataSet.eof or (dataSet.Fields[0].AsInteger >= 10000);

If you do this you miss the processing of the last record (assuming you do dataset.next just before the until (because if you don't, you miss processing the first record).

Correct. Spotted it, too, while looking at it again.
On (Re-)"Entrance" of the loop, let's say you're on ID=9999
You process your record
You reach the "dataset.next" which is last line before "until..."
dataset.eof is still false, because you actually have a dataset with exactly 10K records
Your ID is now 10.000 and satisfies the second exit-condition.

Record with ID=10000 will not be processed

https://www.freepascal.org/docs-html/fcl/db/tdataset.eof.html

Note: when the cursor is on the last-but-one record, and Next is called (moving the cursor to the last record), EOF will not yet be True. Only if both the cursor is on the last record and Next is called, will EOF become True.

[Khrys]

The difference between a head condition vs a tail condition in a loop is only the very first check. So if the goal is to have both withouth a break, the easiest solution would be:

Code: Pascal  [Select][+][-]

1. dataset.first;
2. if not DataSet.eof then
3.   repeat
4.     ...
5.   until DataSet.eof or (dataSet.Fields[0].AsInteger >= 10000);

This is correct only with short-circuit evaluation of the OR, yes?

Indeed. When  {$B+}  is on for some reason (full boolean evaluation), the field access will raise an exception once EOF is reached.

Edit: As @rvk pointed out,  TDataSet.Fields  still points to the last available record once EOF is reached, so no exception will be raised and the code just so happens to work.