# Loops/Do-while

Loops/Do-while
You are encouraged to solve this task according to the task description, using any language you may know.

Start with a value at 0. Loop while value mod 6 is not equal to 0. Each time through the loop, add 1 to the value then print it. The loop must execute at least once.

Reference

## 11l

11l doesn't have a do-while loop.

Translation of: Python
```V val = 0
L
val++
print(val)
I val % 6 == 0
L.break```

## 360 Assembly

Basic

The WTO macro is in SYS1.MACLIB, which needs to be in the SYSLIB concatenation at assembly.

```*        Do-While
DOWHILE CSECT  ,                  This program's control section
BAKR  14,0               Caller's registers to linkage stack
USING  DOWHILE,12         tell assembler we use Reg 12 as base
XR    9,9                clear Reg 9 - divident value
LA    6,6                load divisor value 6 in Reg 6
LA    8,WTOLEN           address of WTO area in Reg 8
LOOP     DS    0H
LA    9,1(,9)            add 1 to divident Reg 9
ST    9,FW2              store it
LM    4,5,FDOUBLE        load into even/odd register pair
STH   9,WTOTXT           store divident in text area
MVI   WTOTXT,X'F0'       first of two bytes zero
OI    WTOTXT+1,X'F0'     make second byte printable
WTO    TEXT=(8)           print it (Write To Operator macro)
DR    4,6                divide Reg pair 4,5 by Reg 6
LTR   5,5                test quotient (remainder in Reg 4)
BNZ   RETURN             if one: 6 iterations, exit loop.
B     LOOP               if zero: loop again.
FDOUBLE  DC    0FD
DC    F'0'
FW2      DC    F'0'
WTOLEN   DC    H'2'               fixed WTO length of two
WTOTXT   DC    CL2' '
END   DOWHILE```
Structured Macros

Although specified at the beginning (DO UNTIL), the test is done at the end of the loop (ENDDO). Structured macros (DO ENDDO) weren't in the 1963 standard of Assembler 360, but there are part of it since since 1998.

```*        Do-While                  27/06/2016
DOWHILE  CSECT
USING DOWHILE,12          set base register
LR    12,15               init base register
SR    6,6                 v=0
LA    4,1                 init reg 4
DO UNTIL=(LTR,4,Z,4)      do until v mod 6=0
LA    6,1(6)                v=v+1
STC   6,WTOTXT              v
OI    WTOTXT,X'F0'          make editable
WTO   MF=(E,WTOMSG)         display v
LR    4,6                   v
SRDA  4,32                  shift dividend to reg 5
D     4,=F'6'               v/6  so r4=remain & r5=quotient
ENDDO ,                   end do
WTOMSG   DS    0F                  full word alignment for wto
WTOLEN   DC    AL2(L'WTOTXT+4)     length of WTO buffer
DC    H'0'                must be zero
WTOTXT   DS    C                   one char
END   DOWHILE```

## 6502 Assembly

Code is called as a subroutine (i.e. JSR DoWhileSub). Specific OS/hardware routines for printing are left unimplemented.

```DoWhileSub:	PHA
TYA
PHA			;push accumulator and Y register onto stack

LDY #0
DoWhileLoop:	INY
JSR DisplayValue	;routine not implemented
TYA
SEC
Modulus:	SBC #6
BCS Modulus
BNE DoWhileLoop

PLA
TAY
PLA			;restore Y register and accumulator from stack
RTS			;return from subroutine```

## AArch64 Assembly

Works with: as version Raspberry Pi 3B version Buster 64 bits
```/* ARM assembly AARCH64 Raspberry PI 3B */
/*  program loopdowhile64.s   */

/*******************************************/
/* Constantes file                         */
/*******************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeConstantesARM64.inc"

/*********************************/
/* Initialized data              */
/*********************************/
.data
szMessResult:  .asciz "Counter =  @ \n"      // message result

/*********************************/
/* UnInitialized data            */
/*********************************/
.bss
sZoneConv:          .skip 24
/*********************************/
/*  code section                 */
/*********************************/
.text
.global main
main:                          // entry of program
mov x20,0                  // indice
mov x21,6
1:                             // begin loop
mov x0,x20
ldr x1,qAdrsZoneConv       // conversion value value
bl conversion10            // decimal
bl strInsertAtCharInc      // insert result at @ character
bl affichageMess           // display message
udiv x0,x20,x21            // divide by 6
msub x1,x0,x21,x20         // compute remainder
cbnz x1,1b                 // loop if remainder <> zéro

100:                           // standard end of the program
mov x0,0                   // return code
mov x8,EXIT                // request to exit program
svc 0                      // perform the system call

/********************************************************/
/*        File Include fonctions                        */
/********************************************************/
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"```

## Action!

```Proc Main()
byte A

A=0
Do
A==+1
PrintBE(A)
Until A Mod 6=0
Od
Return```

## ActionScript

```var val:int = 0;
do
{
trace(++val);
} while (val % 6);
```

```loop
Value := Value + 1;
Put (Value);
exit when Value mod 6 = 0;
end loop;
```

Here is an alternative version:

```for Value in 0..Integer'Last loop
Put (Value);
exit when Value mod 6 = 0;
end loop;
```

## Agena

Tested with Agena 2.9.5 Win32

```scope
local i := 0;
do
inc i, 1;
print( i )
as ( i % 6 ) <> 0
epocs```

## Aime

```integer a;

a = 0;
do {
a += 1;
o_integer(a);
o_byte('\n');
} while (a % 6 != 0);```

## ALGOL 60

Works with: ALGOL 60 version OS/360

No structured control instructions in Algol 60 to perform this task. Use of 2 harmful GOTOs. I agree Edsger Dijkstra communication "Go To Statement Considered Harmful", ACM 1968.

```'BEGIN' 'COMMENT' Loops DoWhile  - Algol60 - 22/06/2018;
'INTEGER' I;
I:=0;
LOOP:
I:=I+1;
OUTINTEGER(1,I);
'IF' I=I'/'6*6 'THEN' 'GOTO' ENDLOOP;
'GOTO' LOOP;
ENDLOOP:
'END'```
Output:
```         +1           +2           +3           +4           +5           +6
```

### An alternate ("Goto-less") approach

Works with: A60

While "goto" may (oddly enough) actually be clearer in this particular context, it is possible to avoid it by using the for-while statement and a boolean flag to implement a test-at-the-bottom loop. (Note that though the A60 interpreter permits, it thankfully does not require, the ugly tick marks around reserved words which mar many (but not the Burroughs) ALGOL 60 translators.)

```begin

integer i;
boolean another;
i := 0;
another := true;
for i := i + 1 while another do
begin
outinteger(1,i);
comment - repeat until i mod 6 = 0;
if i = (i div 6) * 6 then another := false;
end;

end```
Output:
``` 1  2  3  4  5  6
```

## ALGOL 68

```FOR value WHILE
print(value);
# WHILE # value MOD 6 /= 0 DO
SKIP
OD```

## ALGOL W

```begin
integer i;
i := 0;
while
begin
i := i + 1;
write( i );
( i rem 6 ) not = 0
end
do begin end
end.```

## AmigaE

```PROC main()
DEF i = 0
REPEAT
i := i + 1
WriteF('\d\n', i)
UNTIL Mod(i, 6) = 0
ENDPROC```

## ARM Assembly

Works with: as version Raspberry Pi
```/* ARM assembly Raspberry PI  */
/*  program loopdowhile.s   */

/* Constantes    */
.equ STDOUT, 1     @ Linux output console
.equ EXIT,   1     @ Linux syscall
.equ WRITE,  4     @ Linux syscall

/*********************************/
/* Initialized data              */
/*********************************/
.data
szMessResult:  .ascii "Counter = "      @ message result
sMessValeur:   .fill 12, 1, ' '
.asciz "\n"
/*********************************/
/* UnInitialized data            */
/*********************************/
.bss
/*********************************/
/*  code section                 */
/*********************************/
.text
.global main
main:                @ entry of program
push {fp,lr}      @ saves 2 registers
mov r4,#0
1:    @ begin loop
mov r0,r4

bl conversion10             @ call function with 2 parameter (r0,r1)
bl affichageMess            @ display message
mov r0,r4
mov r1,#6              @ division conuter by 6
bl division
cmp r3,#0              @ remainder = zéro ?
bne 1b                @ no ->begin loop one

100:   @ standard end of the program
mov r0, #0                  @ return code
pop {fp,lr}                 @restaur 2 registers
mov r7, #EXIT              @ request to exit program
svc #0                       @ perform the system call

/******************************************************************/
/*     display text with size calculation                         */
/******************************************************************/
/* r0 contains the address of the message */
affichageMess:
push {r0,r1,r2,r7,lr}      @ save  registres
mov r2,#0                  @ counter length
1:      @ loop length calculation
ldrb r1,[r0,r2]           @ read octet start position + index
cmp r1,#0                  @ if 0 its over
bne 1b                    @ and loop
@ so here r2 contains the length of the message
mov r1,r0        			@ address message in r1
mov r0,#STDOUT      		@ code to write to the standard output Linux
mov r7, #WRITE             @ code call system "write"
svc #0                      @ call systeme
pop {r0,r1,r2,r7,lr}        @ restaur des  2 registres */
bx lr                       @ return
/******************************************************************/
/*     Converting a register to a decimal                                 */
/******************************************************************/
/* r0 contains value and r1 address area   */
conversion10:
push {r1-r4,lr}    @ save registers
mov r3,r1
mov r2,#10

1:	   @ start loop
bl divisionpar10 @ r0 <- dividende. quotient ->r0 reste -> r1
strb r1,[r3,r2]  @ store digit on area
sub r2,#1         @ previous position
cmp r0,#0         @ stop if quotient = 0 */
bne 1b	          @ else loop
@ and move spaces in first on area
mov r1,#' '   @ space
2:
strb r1,[r3,r2]  @ store space in area
subs r2,#1       @ @ previous position
bge 2b           @ loop if r2 >= zéro

100:
pop {r1-r4,lr}    @ restaur registres
bx lr	          @return
/***************************************************/
/*   division par 10   signé                       */
/* Thanks to http://thinkingeek.com/arm-assembler-raspberry-pi/*
/* and   http://www.hackersdelight.org/            */
/***************************************************/
/* r0 dividende   */
/* r0 quotient */
/* r1 remainder  */
divisionpar10:
/* r0 contains the argument to be divided by 10 */
push {r2-r4}   /* save registers  */
mov r4,r0
mov r3,#0x6667   @ r3 <- magic_number  lower
movt r3,#0x6666  @ r3 <- magic_number  upper
smull r1, r2, r3, r0   @ r1 <- Lower32Bits(r1*r0). r2 <- Upper32Bits(r1*r0)
mov r2, r2, ASR #2     /* r2 <- r2 >> 2 */
mov r1, r0, LSR #31    /* r1 <- r0 >> 31 */
add r0, r2, r1         /* r0 <- r2 + r1 */
add r2,r0,r0, lsl #2   /* r2 <- r0 * 5 */
sub r1,r4,r2, lsl #1   /* r1 <- r4 - (r2 * 2)  = r4 - (r0 * 10) */
pop {r2-r4}
bx lr                  /* leave function */
/***************************************************/
/* integer division unsigned                       */
/***************************************************/
division:
/* r0 contains dividend */
/* r1 contains divisor */
/* r2 returns quotient */
/* r3 returns remainder */
push {r4, lr}
mov r2, #0                @ init quotient
mov r3, #0                @ init remainder
mov r4, #32               @ init counter bits
b 2f
1:          @ loop
movs r0, r0, LSL #1     @ r0 <- r0 << 1 updating cpsr (sets C if 31st bit of r0 was 1)
adc r3, r3, r3           @ r3 <- r3 + r3 + C. This is equivalent to r3 ? (r3 << 1) + C
cmp r3, r1               @ compute r3 - r1 and update cpsr
subhs r3, r3, r1        @ if r3 >= r1 (C=1) then r3 ? r3 - r1
adc r2, r2, r2           @ r2 <- r2 + r2 + C. This is equivalent to r2 <- (r2 << 1) + C
2:
subs r4, r4, #1          @ r4 <- r4 - 1
bpl 1b                  @ if r4 >= 0 (N=0) then loop
pop {r4, lr}
bx lr```

## AppleScript

```on printConsole(x)
return x as string
end printConsole

set {i, table} to {0, {return}}
repeat while (i mod 6 is not 0 or i is not 6)
set i to i + 1
set end of table to i & return
printConsole(table)
end repeat
```
Output:
```"
1
2
3
4
5
6
"
```

## Arturo

```value: 0
until [
value: value + 1
print value
] [ 0 = value%6 ]
```
Output:
```1
2
3
4
5
6```

## Asymptote

Asymptote's control structures are similar to those in C, C++, or Java

```int i = 0;
do {
++i;
write(" ", i, suffix=none);
} while (i % 6 != 0);
```

## AutoHotkey

```While mod(A_Index, 6) ;comment:everything but 0 is considered true
output = %output%`n%A_Index%
MsgBox % output
```

## AWK

```BEGIN {
val = 0
do {
val++
print val
} while( val % 6 != 0)
}
```

## Axe

While Axe does not have explicit do-while loops, they can be easily emulated using an infinite loop with a conditional terminator:

```0→A
While 1
A++
Disp A▶Dec,i
End!If A^6```

## BASIC

### Applesoft BASIC

Works with: Commodore BASIC
``` 0  REMADE FOR DO WHILE
1  DEF  FN MOD6(N) = N -  INT (N / 6) * 6
2  LET V4LUE = 0
3  FOR DO = 0 TO 1
10  LET V4LUE = V4LUE + 1
20  PRINT V4LUE" ";
30 WHILE =  FN MOD6(V4LUE) <  > 0:DO =  NOT WHILE: NEXT```

### ASIC

ASIC does not have a `do .. while` construct. Equivalent using `WHILE`:

```REM Loops/Do-while

I = 0
REM first iteration - before the While
I = I + 1
PRINT I
IMod6 = I MOD 6
WHILE IMod6 <> 0
I = I + 1
PRINT I
IMod6 = I MOD 6
WEND

END
```
Output:
```     1
2
3
4
5
6
```

Equivalent using conditional jump:

```REM Loops/Do-while

I = 0
LoopStart:
I = I + 1
PRINT I
IMod6 = I MOD 6
IF IMod6 <> 0 THEN LoopStart:

END
```
Output:

As above

### BaCon

```a=0
REPEAT
INCR a
PRINT a
UNTIL  MOD(a,6)  == 0```

### BASIC256

```i = 0

do
i += 1
print i; " ";
until i mod 6 = 0
print
end```

### BBC BASIC

```a = 0
REPEAT
a = a + 1
PRINT a
UNTIL a MOD 6 = 0
```

### Chipmunk Basic

In Chipmunk Basic Man Page, the words `do`, `loop`, and `until` are mentioned as reserved, but the `do .. loop until` statement is not described, probably because of uncorrected abnormal behavior of the interpreter. In case of such behavior you may use equivalents (e.g. with `while .. wend`).

```100 rem Loops/Do-while
110 i = 0
120 do
130   i = i+1
140   print i
150 loop until i mod 6 = 0
160 end
```
Output:
```     1
2
3
4
5
6
```

### Commodore BASIC

```50 rem does not have do-while simultate using for-next
100 x=0
120 for b=-1 to 0 step 0
130 x=x+1
140 print x
150 b=x/6<>int(x/6)
160 next x
```

### FreeBASIC

```' FB 1.05. 0 Win64

Dim i As Integer = 0
Do
i += 1
Print i; " ";
Loop While i Mod 6 <> 0
Print
Sleep```
Output:
``` 1  2  3  4  5  6
```

### FutureBasic

```window 1

dim as long i

do
i++
print i
until ( i mod 6 == 0 )

HandleEvents```
Output:
``` 1
2
3
4
5
6
```

### Gambas

```Public Sub Main()
Dim siCount As Short

Repeat
Inc siCount
Print siCount;;
Until siCount Mod 6 = 0

End```
Output:
```1 2 3 4 5 6
```

### GW-BASIC

GW-BASIC does not have a `do .. while` construct. Equivalent using `WHILE`:

Works with: BASICA
Works with: PC-BASIC version any
```10 LET I% = 0
20 ' first iteration - before the WHILE
30 LET I% = I% + 1
40 PRINT I%
50 WHILE I% MOD 6 <> 0
60  LET I% = I% + 1
70  PRINT I%
80 WEND```

Equivalent using `GOTO`:

Works with: BASICA
Works with: PC-BASIC version any
```10 LET I% = 0
20  LET I% = I% + 1
30  PRINT I%
40  IF I% MOD 6 <> 0 THEN GOTO 20```

### IS-BASIC

```100 LET I=0
110 DO
120   LET I=I+1
130   PRINT I
140 LOOP UNTIL MOD(I,6)=0```

### Liberty BASIC

Works with: Just BASIC
```a = 0
do
a  = a + 1
print a
loop until (a mod 6) = 0```

### Microsoft Small Basic

Microsoft Small Basic does not have a `do .. while` construct. Equivalent using `While`:

```i = 0
' first iteration - before the While
i = i + 1
TextWindow.WriteLine(i)
While Math.Remainder(i, 6) <> 0
i = i + 1
TextWindow.WriteLine(i)
EndWhile```

Equivalent using `Goto`:

```i = 0
loopStart:
i = i + 1
TextWindow.WriteLine(i)
If Math.Remainder(i, 6) <> 0 Then
Goto loopStart
EndIf```

### Minimal BASIC

Minimal BASIC does not have a `do .. while` construct. Equivalent using conditional jump:

```10 REM Loops/Do-while
20 LET I=0
30 LET I=I+1
40 PRINT I
50 IF INT(I/6)*6 <> I THEN 30
60 END```

### MSX Basic

The Minimal BASIC solution works without any changes.

### NS-HUBASIC

```10 PRINT "NO,"A" ISN'T A MULTIPLE OF 6."
20 A=A+1
30 IF A-(A/6)*6<>0 THEN GOTO 10
40 PRINT "YES, 6 IS A MULTIPLE OF 6."```

### PureBasic

Works with: PureBasic version 4.41
```x=0
Repeat
x+1
Debug x
Until x%6=0```

### QB64

CBTJD: 2020/03/14

```DO
PRINT n
n = n + 1
LOOP WHILE n MOD 6 <> 0
```
```'Another demo of DO loops
Dim As Integer Counter
Print "First loop DO..LOOP UNTIL"
Counter = 0
Do
Print Counter
Counter = Counter + 1
Loop Until Counter Mod 6 = 0
Print "Counter Mod 6 = "; Counter Mod 6
Print "First loop DO WHILE..LOOP"
Counter = 1
Do While Counter Mod 6 <> 0
Print Counter
Counter = Counter + 1
Loop
Print "Counter Mod 6 = "; Counter Mod 6
End```

### QBasic

Works with: QBasic version 1.1
Works with: QuickBasic version 4.5
Works with: Just BASIC
```a = 0
DO
a = a + 1
PRINT a;
LOOP WHILE a MOD 6 <> 0
```

### Quite BASIC

The Minimal BASIC solution works without any changes.

### Run BASIC

Run Basic does not have a `do .. while` construct. Equivalent using conditional jump:

```i = 0
[start]
i = i +1
print i; " ";
if i mod 6 <> 0 then [start]```

### Sinclair ZX81 BASIC

```10 LET X=0
20 LET X=X+1
30 PRINT X
40 IF X/6<>INT (X/6) THEN GOTO 20
```

### SmallBASIC

```repeat
v++
print v
until(v mod 6 == 0)
```

### Tiny BASIC

Tiny Basic does not have a `do .. while` construct. Equivalent using conditional jump:

Works with: TinyBasic
```10 REM Loops/Do-while
20 LET I = 0
30 LET I = I + 1
40 PRINT I
50 IF (I / 6) * 6 <> I THEN GOTO 30
60 END
```
Output:
```1
2
3
4
5
6
```

### True BASIC

```LET i = 0

DO
LET i = i + 1
PRINT i; " ";
LOOP WHILE REMAINDER(i, 6) <> 0
PRINT
END
```

### VBA

```Public Sub LoopDoWhile()
Dim value As Integer
value = 0
Do
value = value + 1
Debug.Print value;
Loop While value Mod 6 <> 0
End Sub```
Output:
` 1  2  3  4  5  6 `

### Visual Basic .NET

```Dim i = 0
Do
i += 1
Console.WriteLine(i)
Loop Until i Mod 6 = 0
```

### XBasic

Works with: Windows XBasic
```PROGRAM "dowhile"

DECLARE FUNCTION Entry()

FUNCTION Entry()
val% = 0
DO
INC val%
PRINT val%
LOOP WHILE val% MOD 6 <> 0 ' or LOOP UNTIL val% MOD 6 = 0
END FUNCTION
END PROGRAM```

### Yabasic

```i = 0

repeat
i = i + 1
print i, " ";
until mod(i, 6) = 0
print```

## bc

```i = 0
for (;;) {
++i	/* increments then prints i */
if (i % 6 == 0) break
}
quit
```

## Befunge

```0>1+:.v
|%6: <
@
```

## C

```int val = 0;
do{
val++;
printf("%d\n",val);
}while(val % 6 != 0);
```

## C#

```int a = 0;

do
{
a += 1;
Console.WriteLine(a);
} while (a % 6 != 0);
```

## C++

```int val = 0;
do{
val++;
std::cout << val << std::endl;
}while(val % 6 != 0);
```

## C3

In this example we use default zero initialization of locals in C3.

```int val;
do
{
io::printn(++val);
}
while (val % 6 != 0);```

## Chapel

```var val = 0;
do {
val += 1;
writeln(val);
} while val % 6 > 0;
```

## ChucK

```0 => int value;
do
{
value++;
<<<value>>>;
}
while(value % 6 != 0);
```

## Clipper

```   Local n := 0
DO WHILE .T.
? ++n
IF n % 6 == 0
EXIT
ENDIF
ENDDO
```

## Clojure

```(loop [i 0]
(let [i* (inc i)]
(println i*)
(when-not (zero? (mod i* 6))
(recur i*))))
```

## COBOL

The COBOL equivalent of a do-while loop is `PERFORM WITH TEST AFTER UNTIL some-condition`.

```       IDENTIFICATION DIVISION.
PROGRAM-ID. loop-do-while.

DATA DIVISION.
WORKING-STORAGE SECTION.
01  i PIC 99 VALUE 0.

PROCEDURE DIVISION.
PERFORM WITH TEST AFTER UNTIL FUNCTION MOD(i, 6) = 0
DISPLAY i
END-PERFORM

GOBACK
.
```

## Coco

Do-while loops are a JavaScript feature removed in CoffeeScript but re-added in Coco.

```v = 0
do
console.log ++v
while v % 6```

## CoffeeScript

CoffeeScript doesn't have `do {} while ()` loop, but it can be emulated using `loop` statement and `break unless` statement.

```val = 0
loop
console.log ++val
break unless val % 6
```

## ColdFusion

```<cfscript>
value = 0;
do
{
value += 1;
writeOutput( value );
} while( value % 6 != 0 );
</cfscript>
```

## Common Lisp

```(let ((val 0))
(loop do
(incf val)
(print val)
while (/= 0 (mod val 6))))
```

loop can set up temporary values, and incf returns a value, so it's also possible to do

```(loop with val = 0
do (print (incf val))
until (= 0 (mod val 6)))
```

### Using DO

```(do* ((a 0)		     ; Initialize to 0
(b (incf a) (incf b))) ; Set first increment and increment on every loop
((zerop (mod b 6)) (print b)) ; Break condition and print last value `6' (right?)
(print b))			   ; On every loop print value
```
Output:
```1
2
3
4
5
6
```

## D

```import std.stdio;

void main() {
int val;
do {
val++;
write(val, " ");
} while (val % 6 != 0);
}
```
Output:
`1 2 3 4 5 6 `

## Dart

```void main() {
int val = 0;
do {
val++;
print(val);
} while (val % 6 != 0);
}
```

## dc

Translation of: bc
```0 si		[i = 0]sz
[2Q]sA		[A = code to break loop]sz
[
li 1 + p	[print it = i + 1]sz
d si		[i = it, leave it on stack]sz
6 % 0 =A	[call A if 0 == it % 6]sz
0 0 =B		[continue loop]sz
]sB 0 0 =B```

## Delphi

```program Loop;

{\$APPTYPE CONSOLE}

var
I: Integer;

begin
I:= 0;
repeat
Inc(I);
Write(I:2);
until I mod 6 = 0;
Writeln;
end.
```

## Draco

```proc nonrec main() void:
byte i;
i := 0;
while
i := i + 1;
write(i:2);
i % 6 ~= 0
do od
corp```
Output:
` 1 2 3 4 5 6`

## Dragon

```val = 0
do{
val++
showln val
}while(val % 6 != 0)```

## DUP

DUP only provides a while loop in the form of `[condition][block]#`, where the block is executed in a loop as long as the condition is nonzero/true. A do-while loop is technically nothing more than executing the block once before running an ordinary while loop, so we simply define an operator or function that contains the block (comments in curly braces):

```[1+\$.' ,]⇒A   {operator definition: PUSH 1, ADD, DUP, print top of stack to SDTOUT, print whitespace}
[1+\$.' ,]a:    {function definition}```

and put the defined block in front of the while loop, and inside the while loop itself:

If the block was defined as an operator, the whole program would look like this (comments in curly braces):

```[1+\$.' ,]⇒A
0 A[\$6/%][A]#    {PUSH 0, execute operator A, [DUP, PUSH 6, MOD/DIV, POP][execute operator A]#}```

And if the block is defined as a named function:

```[1+\$.' ,]a:
0 a;![\$6/%][a;!]#```

Result:

`1 2 3 4 5 6`

## DWScript

```var i := 0;

repeat
Inc(i);
PrintLn(i);
until i mod 6 = 0;
```

Bold text

## Dyalect

```var x = 0

do
{
x += 1
print(x)
} while x % 6 != 0```

## E

E does not have an official do-while construct, but the primitive which loops are built out of (which calls a function which returns a boolean indicating whether it should be called again) can be used to construct a do-while.

```var x := 0
__loop(fn {
x += 1
println(x)
x % 6 != 0   # this is the return value of the function
})```

## EasyLang

```value = 0
repeat
value += 1
print value
until value mod 6 = 0
.```

## Ela

```open monad io

loop n | n % 6 == 0 = do return ()
| else = do
putStrLn (show n)
loop (n+1)

_ = loop 10 ::: IO```

## Elixir

```defmodule Loops do
def do_while(n) do
n1 = n + 1
IO.puts n1
if rem(n1, 6) == 0, do: :ok,
else: do_while(n1)
end
end

Loops.do_while(0)
```

## Emacs Lisp

The condition form for `while` can be a `progn` to evaluate arbitrary code before the loop condition. The body of a `while` can be empty.

```(let ((val 0))
(while (progn
(setq val (1+ val))
(message "%d" val)
(/= 0 (mod val 6)))))
```

Alternatively, the loop can be rewritten to check for the exit condition and fulfill it at the end of the loop body.

```(let ((val 0) done)
(while (not done)
(setq val (1+ val))
(message "%d" val)
(setq done (zerop (mod val 6)))))
```

## Erlang

```do() ->
do(0).

do(0) ->
io:fwrite( "0 " ),
do( 1 );
do(N) when N rem 6 =:= 0 ->
io:format("~w~n", [N]);
do(N) ->
io:fwrite( "~p ", [N] ),
do(N+1).
```

## ERRE

```A=0
REPEAT
A=A+1
PRINT(A)
UNTIL A MOD 6=0  !UNTIL A-6*INT(A/6)=0 for C-64```

## Euphoria

Works with: Open Euphoria
```include std/console.e
include std/math.e

atom x = 0

loop do
x += 1
?x
until(mod(x,6)) = 0
end loop

if getc(0) then end if```

## F#

If you must have a loop then this is acceptable F#

```let rec loop n =
printfn "%d " n
if (n+1)%6 > 0 then loop (n+1)
loop 0
```

But I prefer this way:

```Seq.initInfinite id |> Seq.takeWhile(fun n->n=0 || n%6>0) |> Seq.iter (fun n-> printfn "%d" n)
```

Either produces:

Output:
```0
1
2
3
4
5
```

Many of the solutions to this task show no output in spite of it being required in the task dexcription, so who knows what they do? Of some that have output they think it should be 1 to 6, who can tell from the task description? The following produces 1..6.

```// Loops/Do-while. Nigel Galloway: February 14th., 2022
Seq.unfold(fun n->match n with Some n->let n=n+1 in Some(n,if n%6=0 then None else Some(n)) |_->None)(Some 0)|>Seq.iter(printfn "%d")
```
Output:
```
1
2
3
4
5
6
```

## Factor

```0 [ dup 6 mod 0 = not ] [ [ . ] [ 1 + ] bi ] do while drop
```

## Fantom

There is no do-while statement in Fantom, so instead use an infinite while loop with a break statement:

```class Main
{
public static Void main ()
{
i := 0
while (true)
{
i += 1
echo (i)
if (i % 6 == 0) break // end loop on condition
}
}
}```

## Forth

```: do-until
0
begin 1+
dup .
dup 6 mod 0=
until
drop ;
```

## Fortran

Works with: Fortran version 90 and later
```INTEGER :: i = 0
DO
i = i + 1
WRITE(*, *) i
IF (MOD(i, 6) == 0) EXIT
END DO
```
Works with: Fortran version 77 and later
```      PROGRAM DOWHILE
C Initialize modulus and value.
INTEGER MODLUS, IVALUE
PARAMETER (MODLUS = 6)
IVALUE = 0

C FORTRAN 77 has no do-while structure -- not semantically. It is not
C difficult to simulate it using GOTO, however:
10   CONTINUE
IVALUE = IVALUE + 1
WRITE (*,*) IVALUE
IF (.NOT. (MOD(IVALUE, MODLUS) .EQ. 0)) GOTO 10

STOP
END
```
Works with: Fortran version IV and later
```      IVALUE = 0
10 CONTINUE
IVALUE=IVALUE+1
WRITE(6,301) IVALUE
301   FORMAT(I5)
IF(MOD(IVALUE,6).NE.0) GOTO 10
END
```
Works with: Fortran version I and later
```      IVALUE = 0
10 IVALUE=IVALUE+1
WRITE 301,IVALUE
301 FORMAT(I5)
IF(IVALUE-IVALUE/6*6) 10,20,10
20 STOP
END
```

## Fortress

Due to the way that Fortress works, you have to use a label to escape a loop upon a specified condition being met. There is no traditional `break` equivalent.

```component loops_do_while
export Executable

var x:ZZ32 = 0
run() = label loop
while true do
x += 1
println(x)

if (x MOD 6) = 0
then exit loop
end
end
end loop
end```
Output:
```1
2
3
4
5
6
```

## Frink

```n = 0
do
{
n = n + 1
println[n]
} while n mod 6 != 0```

## GAP

```n := 0;
repeat
n := n + 1;
Print(n, "\n");
until RemInt(n, 6) = 0;
```

## GML

```i = 0
do
{
i += 1
show_message(string(i))
}
until (i mod 6 = 0)```

## Go

There is no explicit do-while in Go, but it can be simulated with a range-based for loop and the break statement.

```package main

import "fmt"

func main() {
var value int
for {
value++
fmt.Println(value)
if value%6 != 0 {
break
}
}
}
```
Output:
```1
2
3
4
5
6```

It can also be simulated without using a break statement as follows:

```package main

import "fmt"

func main() {
var value int
for ok := true; ok; ok = value%6 != 0 {
value++
fmt.Println(value)
}
}
```
Output:
```Same as before.
```
```package main

import "fmt"

func main() {
// do-while loop 1
n1 := 2
for n1 < 6 {
n1 *= 2
}
fmt.Println(n1) // prt 8
// do-while loop 2
n2 := 2
for ok := true; ok; ok = n2%8 != 0 {
n2 *= 2
}
fmt.Println(n2) // prt 8
// do-while loop 3
n3 := 2
for {
n3 *= 2
if n3 >= 6 {
break
}
}
fmt.Println(n3) // prt 8
}
```

## Groovy

For Groovy 3.0.0 and later.

```def i = 0
do {
i++
println i
} while (i % 6 != 0)
```

Previous versions of Groovy did not have a bottom-checking loop construct. Workaround is to use an "infinite" while loop with a conditional break as the last statement.

```def i = 0
while (true) {
i++
println i
if (i % 6 == 0) break
}
```
Output:
```1
2
3
4
5
6```

## Harbour

```LOCAL n := 0

DO WHILE .T.
? ++n
IF n % 6 == 0
EXIT
ENDIF
ENDDO```

```import Data.List
import Control.Arrow

doWhile p f n = (n:) \$ takeWhile p \$ unfoldr (Just.(id &&& f)) \$ succ n
```

Example executed in GHCi:

```*Main> mapM_ print \$ doWhile ((/=0).(`mod`6)) succ 0
0
1
2
3
4
5
```

The standard Prelude also includes, without further import or definition, an until function, which takes three arguments – a predicate function, a transformation function, and an initial value.

```main :: IO ()
main =
mapM_ print . reverse \$
until
(\(x:_) -> (x > 0) && (mod x 6 == 0))
(\xs@(x:_) -> succ x : xs)
[0]
```
Output:
```0
1
2
3
4
5
6
```

### With mutable references

```import Data.IORef

main = do
x <- newIORef 0;
iterateWhile (\val -> val `mod` 6 /= 0 ) \$ do
modifyIORef x (+1)
print val
return val
```

## Haxe

```var val = 0;

do {
val++;
Sys.println(val);
} while( val % 6 != 0);
```

## HolyC

```U8 i = 0;
do {
i++;
Print("%d\n", i);
} while (i % 6 != 0);```

## Icon and Unicon

Icon and Unicon do not have a do-while looping control with end of loop checking. There are four looping controls 'every', 'repeat', 'until', and 'while' (see Introduction to Icon and Unicon/Looping Controls for more information.)

```procedure main()

i := 0
repeat {
write(i +:= 1)
if i % 6 = 0 then break
}
end
```

## J

J is array-oriented, so there is very little need for loops. For example, one could satisfy this task this way:

```   ,.([^:(0=6|])>:)^:a: 0
0
1
2
3
4
5
```

This could also be accomplished using Z: to provide early termination from a fold:

```   0#]F.(>: [ echo [ _2 Z: * * 0=6|]) 0
0
1
2
3
4
5
```

J does support loops for those times they can't be avoided (just like many languages support gotos for those time they can't be avoided).

```3 : 0 ] 0

NB.  The 'st' in 'whilst' stands for 'skip test'

whilst. 0 ~: 6 | y do.
y 1!:2 ]2
y =. y+1
end.

i.0 0
)
```

Though it's rare to see J code like this.

## Java

```int val = 0;
do{
val++;
System.out.println(val);
}while(val % 6 != 0);
```

## JavaScript

### Javascript: Imperative

```var val = 0;
do {
print(++val);
} while (val % 6);
```

### Javascript: Functional

#### ES5

In a functional idiom of JavaScript we cannot use a Do While statement, as it returns no value and is not a composable expression. We can, however achieve the same effect with a composable doWhile function, which takes three arguments, and returns the output series as a value.

1. An initial value,
2. a Do function which transforms that value repetitively, corresponding to the body of the loop,
3. and a conditional While function.
```function doWhile(varValue, fnBody, fnTest) {
'use strict';
var d = fnBody(varValue); // a transformed value

return fnTest(d) ? [d].concat(
doWhile(d, fnBody, fnTest)
) : [d];
}

console.log(
doWhile(0,           // initial value
function (x) {     // Do body, returning transformed value
return x + 1;
},
function (x) {     // While condition
return x % 6;
}
).join('\n')
);
```

Output:

```1
2
3
4
5
6
```

Alternatively, if we assume instead that the unstated problem was not to produce repetitive computation, but to derive the membership of a set we could interpret the task as a request for a JavaScript implementation of the takeWhile function – a familiar staple of functional list processing.

So, for example, something like:

```function range(m, n) {
'use strict';
return Array.apply(null, Array(n - m + 1)).map(
function (x, i) {
return m + i;
}
);
}

function takeWhile(lst, fnTest) {
'use strict';
var varHead = lst.length ? lst[0] : null;

takeWhile(lst.slice(1), fnTest)
) : []
) : []
}

console.log(
takeWhile(
range(1, 100),
function (x) {
return x % 6;
}
).join('\n')
);
```

Output:

```1
2
3
4
5
```

#### ES6

A process or value of this kind might be better expressed (in functionally composed JavaScript) with an unfold or until function, returning a list.

```(() => {
'use strict';

// unfoldr :: (b -> Maybe (a, b)) -> b -> [a]
function unfoldr(mf, v) {
for (var lst = [], a = v, m;
(m = mf(a)) && m.valid;) {
lst.push(m.value), a = m.new;
}
return lst;
}

// until :: (a -> Bool) -> (a -> a) -> a -> a
function until(p, f, x) {
let v = x;
while(!p(v)) v = f(v);
return v;
}

let result1 = unfoldr(
x => {
return {
value: x,
valid: (x % 6) !== 0,
new: x + 1
}
},
1
);

let result2 = until(
m => (m.n % 6) === 0,
m => {
return {
n : m.n + 1,
xs : m.xs.concat(m.n)
};
},
{
n: 1,
xs: []
}
).xs;

return [result1, result2];
})();
```
```[[1, 2, 3, 4, 5], [1, 2, 3, 4, 5]]
```

ES6 is a superset of Javascript so the Javascript and ES5 solution is valid. An example of a do-while loop in a generator follows that produces correct output:

```// generator with the do while loop
function* getValue(stop) {
var i = 0;
do {
yield ++i;
} while (i % stop != 0);
}

// function to print the value and invoke next
function printVal(g, v) {
if (!v.done) {
console.log(v.value);
setImmediate(printVal, g, g.next());
}
}

(() => {
var gen = getValue(6);
printVal(gen, gen.next());
})();
```
```1
2
3
4
5
6
```

## jq

Works with: jq version 1.4

In jq 1.4, the "recurse" built-in always emits the input value, and so to accomplish the task specified here, we shall define a control structure: "do_while(action; condition)" as follows:

```# Perform the action, then check the condition, etc
def do_while( action; condition ):
def w: action | if (condition | not) then empty else ., w end;
w;```

`0 | do_while( .+1; . % 6 != 0 )`
Output:
```1
2
3
4
5
```

## Julia

Julia has no do-while construct. Here is one of several ways to implement do-while behavior.

```julia> i = 0
0

julia> while true
println(i)
i += 1
i % 6 == 0 && break
end
0
1
2
3
4
5
```

Using a macro that mimics the classic C style do-while.

Notice that the symbol `while` cannot be used as it is a keyword, which is why `when` is used instead, also the macro definition is wrapped in a `@eval` macro invocation since `do` is also a keyword, but in Julia macro calls are prefixed by `@` so this is only an issue during the macro definition, not when invoked, ie. `@do block when condition`).

```julia> @eval macro \$(:do)(block, when::Symbol, condition)
when ≠ :when && error("@do expected `when` got `\$s`")
quote
let
\$block
while \$condition
\$block
end
end
end |> esc
end
@do (macro with 1 method)

julia> i = 0
0

julia> @do begin
@show i
i += 1
end when i % 6 ≠ 0
i = 0
i = 1
i = 2
i = 3
i = 4
i = 5
```

Here is mostly the same macro, but with the conditional clause used first, which is arguably more readable.

```julia> macro do_while(condition, block)
quote
let
\$block
while \$condition
\$block
end
end
end |> esc
end
@do_while (macro with 1 method)

julia> i = 0
0

julia> @do_while i % 6 ≠ 0 begin
@show i
i += 1
end
i = 0
i = 1
i = 2
i = 3
i = 4
i = 5
```

## Kotlin

```// version 1.0.6

fun main(args: Array<String>) {
var value = 0
do {
println(++value)
}
while (value % 6 != 0)
}
```
Output:
```1
2
3
4
5
6
```

## LabVIEW

This image is a VI Snippet, an executable image of LabVIEW code. The LabVIEW version is shown on the top-right hand corner. You can download it, then drag-and-drop it onto the LabVIEW block diagram from a file browser, and it will appear as runnable, editable code.

## Lasso

```local(x = 0)
while(#x % 6 > 0 || #x == 0) => {^
++#x
'\r' // for formatting
^}
```

## Lambdatalk

```{def do_while
{def do_while.r
{lambda {:i}
{if {= {% :i 6} 0}
then :i (end of loop)
else :i {do_while.r {+ :i 1}}}}}
{lambda {:i}
:i {do_while.r {+ :i 1}}}}
-> do_while

{do_while 0}
-> 0 1 2 3 4 5 6 (end of loop)
```

## Lang

Lang does not have a do-while loop. A simple loop like the example below can be used.

```\$i = 0
loop {
\$i += 1

fn.println(\$i)

if(!(\$i % 6)) {
con.break
}
}```

## Lingo

Lingo has no do..while, but here how this behavior can be implemented:

```i = 0
repeat while TRUE
i = i+1
put i
if i mod 6 = 0 then exit repeat
end```

## Lisaac

```+ val : INTEGER;
{
val := val + 1;
val.print;
'\n'.print;
val % 6 != 0
}.while_do { };```

## LiveCode

```repeat while n mod 6 is not 0 or n is 0
put n
end repeat```

## Logo

```make "val 0
do.while [make "val :val + 1  print :val] [notequal? 0 modulo :val 6]
do.until [make "val :val + 1  print :val] [equal? 0 modulo :val 6]

to my.loop :n
make "n :n + 1
print :n
if notequal? 0 modulo :n 6 [my.loop :n]
end
my.loop 0```

## Lua

Lua doesn't have a `do .. while` construct.

```i=0
repeat
i=i+1
print(i)
until i%6 == 0
```

## M2000 Interpreter

```Module checkit {
x=0
\\ Do or Repeat
Do
x++
print x,
when x mod 6>0
print
// or we can use Until x mod 6 = 0
// and we can use block if we like it
x=0
Do {
x++
print x,
} when x mod 6>0
print
x=0
{
\\ when enter to block the loop flag change to false
x++
if x mod 6<>0 Then loop   ' set loop flag of current block to true
\\ when block end check Loop flag and if true execute block again
print x,
}
print
}
Checkit
module Old_Style {
10 REM Loops/Do-while
20 LET I=0
30 LET I=I+1
40 PRINT I
50 IF INT(I/6)*6 <> I THEN 30
60 END
}
Old_Style
// modern style, using high order functions
module generic_iterator {
do_while = lambda (f, p)->{
{
if p(f()) then loop
}
}
funcA=lambda (start_from, do_what) -> {
=lambda i=start_from, do_what ->{
call do_what(i)
=i
i++
}
}
funcPrint=lambda ->{
print number
}
call do_while(funcA(1, funcPrint), lambda->number mod 6 <>0)
}
generic_iterator```
Output:
```1 2 3 4 5 6
1 2 3 4 5 6
1 2 3 4 5 6
1
2
3
4
5
6
1
2
3
4
5
6
```

## Maple

```val := 0:
do
val := 1 + val;
print( val );
if irem( val, 6 ) = 0 then
break
end if;
end do:```

## Mathematica/Wolfram Language

Because everything is an expression in Mathematica, `While[body;condition]` tests `condition` after `body` has been executed at least once.

```value = 0;
While[
value++;
Print[value];
Mod[value,6]!=0
]
```

## MATLAB / Octave

```   a=0;
while (1)
a = a+1;
disp(a);
if (~mod(a,6)) break; end;
end;
```

## Maxima

```block([n: 0], do (ldisp(n: n + 1), if mod(n, 6) = 0 then return('done)))\$
```

## MAXScript

```a = 0
do
(
print a
a += 1
)
while mod a 6 != 0```

## Metafont

Metafont has no a do-while construct; the same thing can be done using a forever loop and exitif.

```a := 0;
forever: show a; a := a + 1; exitif a mod 6 = 0; endfor
end```

## min

Works with: min version 0.19.6
`0 (dup 6 mod 0 == over 0 != and) 'pop (puts succ) () linrec`

## MIPS Assembly

```	.text
main:	li 	\$s0, 0		# start at 0.
li	\$s1, 6
div	\$s0, \$s1	# divide \$s0 by \$s1. Result is in the multiplication/division registers
mfhi	\$s3		# copy the remainder from the higher multiplication register to \$s3
move	\$a0, \$s0	# variable must be in \$a0 to print
li	\$v0, 1		# 1 must be in \$v0 to tell the assembler to print an integer
syscall			# print the integer in \$a0
bnez	\$s3, loop	# if \$s3 is not 0, jump to loop

li	\$v0, 10
syscall			# syscall to end the program
```

## МК-61/52

```0	П4	КИП4	ИП4	6	/	{x}	x=0	02	С/П
```

## Modula-2

```MODULE DoWhile;
IMPORT InOut;

VAR
i: INTEGER;

BEGIN
i := 0;
REPEAT
INC(i);
InOut.WriteInt(i, 1);
InOut.WriteLn;
UNTIL i MOD 6 = 0;
END DoWhile.
```

## Modula-3

This is very similar to the Modula-2 code above.

```REPEAT
i := i + 1;
IO.Put(Fmt.Int(i));
UNTIL i MOD 6 = 0;```

## Monicelli

The do-while loop is the only kind of loop available in Monicelli

```stuzzica
...     # loop body
e brematura anche, se <expr> # exit if <expr> is false```

## MUMPS

```DOWHILELOOP
set val = 0
do {
set val = val + 1
write val,!
} while ((val # 6) '= 0)

quit```
Output:
```
SAMPLES>do ^DOWHILELOOP
1
2
3
4
5
6

```

## Neko

```/**
Loops/Do-while in Neko
Tectonics:
nekoc loops-do-while.neko
neko loops-do-while
*/

var index = 0;
do {
index += 1;
\$print(index, "\n");
} while (index % 6) != 0
```
Output:
```prompt\$ nekoc loops-do-while.neko
prompt\$ neko loops-do-while
1
2
3
4
5
6```

## Nemerle

```mutable x = 0;
do
{
x++;
WriteLine(\$"\$x");
} while (x % 6 != 0)
```

## NetRexx

In NetRexx the do–while construct is implemented via the `until expru` conditional clause of the `loop` instruction. The expression expru in the `until expru` clause is evaluated at the end of the loop, guaranteeing that the loop will be executed at least once.

```/* NetRexx */
options replace format comments java crossref savelog symbols nobinary

say
say 'Loops/Do-while'

i_ = 0
loop until i_ // 6 = 0
i_ = i_ + 1
say i_
end```

## NewLISP

```(let ((i 0))
(do-until (= 0 (% i 6))
(println (++ i))))
```

## Nim

Nim does not have a do-while loop. The standard way to simulate it consists in an infinite loop with a break statement:

```var val = 0
while true:
inc val
echo val
if val mod 6 == 0: break
```

It's also easy to write your own doWhile construction (but be aware that the instructions will be duplicated):

```template doWhile(a, b: untyped): untyped =
b
while a:
b

var val = 0
doWhile val mod 6 != 0:
inc val
echo val
```

## Nu

```mut n = 0
while true {
\$n += 1
print \$n
if \$n mod 6 == 0 {break}
}```

## Oberon-2

Works with oo2c Version 2

```MODULE LoopDoWhile;
IMPORT
Out;

PROCEDURE Do();
VAR
i: INTEGER;
BEGIN
i := 0;
REPEAT
Out.LongInt(i,0);Out.Ln;
INC(i)
UNTIL (i MOD 6 = 0);
END Do;

BEGIN
Do
END LoopDoWhile.```

## Objeck

```i := 0;
do {
i += 1;
i->PrintLine();
}
while (i % 6 <> 0);```

## OCaml

OCaml doesn't have a do-while loop, so we can just make a local loop:

```let rec loop i =
let i = succ i in
Printf.printf "%d\n" i;
if i mod 6 <> 0 then
loop i
in
loop 0
```

or implementing a generic do-while iterator with higher order function:

```let do_while f p =
let rec loop() =
f();
if p() then loop()
in
loop()
(** val do_while : (unit -> 'a) -> (unit -> bool) -> unit *)
```
```let v = ref 0 in
do_while (fun () -> incr v; Printf.printf "%d\n" !v)
(fun () -> !v mod 6 <> 0)
```

The example above is the an imperative form, below is its functional counterpart:

```let do_while f p ~init =
let rec loop v =
let v = f v in
if p v then loop v
in
loop init

do_while (fun v ->
let v = succ v in
Printf.printf "%d\n" v;
(v))
(fun v -> v mod 6 <> 0)
~init:0
```

Or in a very poor OCaml style, we can use an exception to exit a while loop:

```let v = ref 0
exception Exit_loop
try while true do
incr v;
Printf.printf "%d\n" !v;
if not(!v mod 6 <> 0) then
raise Exit_loop;
done
with Exit_loop -> ()```

## Octave

The do-while can be changed into a do-until, just negating the condition of the while.

```val = 0;
do
val++;
disp(val)
until( mod(val, 6) == 0 )```

## Oforth

`0 doWhile: [ 1+ dup . dup 6 rem 0 <> ] drop`

## OpenEdge/Progress

```DEFINE VARIABLE ii AS INTEGER.

DO WHILE ii MODULO 6 <> 0 OR ii = 0:
ii = ii + 1.
END.```

## Oz

Normal Oz variables are single-assignment only. So we use a "cell", which is a one-element mutable container.

```declare
I = {NewCell 0}
in
for until:@I mod 6 == 0 do
I := @I + 1
{Show @I}
end```

## PARI/GP

The generic Pari loops (`while`, `until`) test at the beginning, so just use an infinite loop with a break.

```x = 0;
while(1,
print(x++);
if(x % 6 == 0, break)
)```

If the loop body is something simple then it might be worked into the loop condition. This is obscure but compact.

```x = 0;
while (print(x++) || x % 6, )```

The condition in `while` and `until` is an expression, not a sequence, so `;` for multiple statements cannot be used there.

## Pascal

```program countto6(output);

var
i: integer;

begin
i := 0;
repeat
i := i + 1;
writeln(i)
until i mod 6 = 0
end.```

## PascalABC.NET

```begin
var a := 0;
repeat
a += 1;
Print(a);
until a mod 6 = 0;
end.```

## Perl

```my \$val = 0;
do {
\$val++;
print "\$val\n";
} while (\$val % 6);```

`do ... until (condition)` is equivalent to `do ... while (not condition)`.

```my \$val = 0;
do {
\$val++;
print "\$val\n";
} until (\$val % 6 == 0);```

## Phix

```integer x = 0
while 1 do
x += 1
?x
if mod(x,6)=0 then exit end if
end while
```

## Phixmonti

```/# Rosetta Code problem: https://rosettacode.org/wiki/Loops/Do-while
by Galileo, 11/2022 #/

include ..\Utilitys.pmt

0
true while
1 +
dup ?
dup 6 mod
endwhile```

## PHL

```var i = 0;
do {
i = i::inc;
printf("%i\n", i);
} while (i%6 != 0);```

## PHP

```\$val = 0;
do {
\$val++;
print "\$val\n";
} while (\$val % 6 != 0);```

## Picat

### do while loop

```go =>
N = 0,
do
N := N+1,
println(N)
while (N mod 6 != 0).```

### Recursion

```go2 =>
do_while(0).

do_while(N) :-
N1 = N + 1,
println(N1),
N1 mod 6 != 0,
do_while(N1).```

Both outputs the same.

Output:
```1
2
3
4
5
6```

## PicoLisp

Literally:

```(let Val 0
(loop
(println (inc 'Val))
(T (=0 (% Val 6))) ) )```

Shorter:

```(let Val 0
(until (=0 (% (println (inc 'Val)) 6))) )```

or:

`(for (Val 0  (n0 (% (println (inc 'Val)) 6))))`

## Pike

```int main(){
int value = 0;
do {
value++;
write(value + "\n");
} while (value % 6);
}```

## PL/0

PL/0 does not have a `do .. while` construct. Equivalent using `while`:

```var i;
begin
i := 0;
i := i + 1;
! i;
while (i / 6) * 6 <> i do
begin
i := i + 1;
! i
end;
end.```
Output:
```       1
2
3
4
5
6
```

## PL/I

```dcl value fixed bin (31) init (0);
do forever;
value = value + 1;

if mod(value, 6) = 0 then
leave;

put list (value);
end;```

or shorter:

``` dcl value fixed bin(31) init(0);
do Until(value=6);
value+=1;
put Skip list(value);
end;```
Output:
```             1
2
3
4
5
6
```

## Plain English

Plain English has one kind of loop: an infinite loop with (hopefully) a conditional break/exit. So if you want a do-while, put the conditional break/exit at the end of the loop.

```To run:
Start up.
Demonstrate do-while.
Wait for the escape key.
Shut down.

To demonstrate do-while:
Bump a counter.
Convert the counter to a string.
Write the string on the console.
If the counter is evenly divisible by 6, exit.
Repeat.```

## Pop11

```lvars val = 0;
while true do
val + 1 -> val;
printf(val, '%p\n');
quitif(val rem 6 = 0);
endwhile;```

## PowerShell

```\$n = 0
do {
\$n++
\$n
} while (\$n % 6 -ne 0)```

## Prolog

```% initial condition
do(0):- write(0),nl,do(1).

% control condition
do(V):- 0 is mod(V,6), !, fail.

% loop
do(V) :-
write(V),nl,
Y is V + 1,
do(Y).

wloop :-
do(0).```

## Python

Python doesn't have a do-while loop.

```val = 0
while True:
val +=1
print val
if val % 6 == 0: break```

or repeat the body of the loop before a standard while.

```val = 1
print val
while val % 6 != 0:
val += 1
print val```

## Quackery

Quackery's control flow words are mix-and-match. To satisfy this task, we can check for the exit condition at the end of the loop. `until` means jump to `[` if ToS is false.

```0 [ 1+ dup echo cr
dup 6 mod 0 = until ] drop```

## R

```i <- 0
repeat
{
i <- i + 1
print(i)
if(i %% 6 == 0) break
}```

## Racket

Idiomatic Racket code is functional:

```#lang racket
(let loop ([n 0])
(displayln n)
(unless (zero? (modulo n 6)) (loop n))))```

But an imperative version is easy to do too:

```#lang racket
(define n 0)
(let loop ()
(displayln n)
(unless (zero? (modulo n 6)) (loop)))```

## Raku

(formerly Perl 6)

Works with: Rakudo Star version 2010.08
```my \$val = 0;
repeat {
say ++\$val;
} while \$val % 6;```

`repeat ... until condition` is equivalent to `do ... while not condition`.

```my \$val = 0;
repeat {
say ++\$val;
} until \$val %% 6;```

(Here we've used `%%`, the "divisible-by" operator.)

You can also put the condition before the block, without changing the order of evaluation.

```my \$val = 0;
repeat while \$val % 6 {
say ++\$val;
}```

## REBOL

```REBOL [
Title: "Loop/While"
URL: http://rosettacode.org/wiki/Loop/Do_While
]

; REBOL doesn't have a specific 'do/while' construct, but 'until' can
; be used to provide the same effect.

value: 0
until [
value: value + 1
print value

0 = mod value 6
]```
Output:
```1
2
3
4
5
6```

## Red

```Red []
i: 0
until [
?? i
i: i + 1
i % 6 = 0 ;; loop , until this is true...
]```
Output:
```i: 0
i: 1
i: 2
i: 3
i: 4
i: 5
```

## REXX

In the DO UNTIL construct, the expression is evaluated at the end of the DO loop,
even though it is written at the beginning.
This insures that the DO UNTIL loop will execute at least once (as coded below).

In contrast, a DO WHILE construct, the expression would be evaluated at the beginning of the DO loop, and
may cause the DO WHILE loop to not execute at all.
This necessitates the use of DO UNTIL instead of DO WHILE.

### version 1

```/*REXX program demonstrates a     DO  UNTIL     construction.           */
v=0
do  until  v//6==0           /*REXX   //   is the ÷ remainder.*/
v=v+1
say v
end
/*stick a fork in it, we're done.*/```
Output:
```1
2
3
4
5
6
```

### version 2

```/*REXX program demonstrates a     DO  UNTIL     construction.           */

do v=1  until  v//6==0       /*REXX   //   is the ÷ remainder.*/
say v
end
/*stick a fork in it, we're done.*/```

output is the same as the 1st version.

## Ring

```   n = 0
While True
n++  See n + nl
if n % 6 = 0  exit ok
end```

## RPL

To ensure at least one loop, `DO`..`UNTIL`..`END` must be used rather than `WHILE`..`REPEAT`..`END`. To actually print (on paper) instead of pushing in the stack successive results, the `DUP` instruction inside the loop shall be replaced by `PR1`

```≪ 0
DO
1 + DUP
UNTIL DUP 6 MOD 0 == END
DROP
≫
```

## Ruby

The while statement modifier normally checks the condition before entering the loop. But if the while statement modifier is on a begin ... end statement, then it loops at least once. Same with the until statement modifier.

while until
```val = 0
begin
val += 1
puts val
end while val % 6 != 0```
```val = 0
begin
val += 1
puts val
end until val % 6 == 0```

During November 2005, Yukihiro Matsumoto, the creator of Ruby, regretted this loop feature and suggested using Kernel#loop.

break unless break if
```val = 0
loop do
val += 1
puts val
break unless val %6 != 0
end```
```val = 0
loop do
val += 1
puts val
break if val %6 == 0
end```

All four of these examples print the numbers 1, 2, 3, 4, 5, 6.

## Rust

Rust does not have a do...while loop. Instead, the keyword loop is used with a termination condition.

```let mut x = 0;

loop {
x += 1;
println!("{}", x);

if x % 6 == 0 { break; }
}```

## Salmon

```variable x := 0;
do
{
++x;
x!
}
while (x % 6 != 0);```

## SAS

```/* using DO UNTIL so that the loop executes at least once */
data _null_;
n=0;
do until(mod(n,6)=0);
n+1;
put n;
end;
run;```

## Sather

Translation of: C
```class MAIN is
main is
val ::= 0;
loop
val := val + 1;
#OUT + val + "\n";
while!(val % 6 /= 0)
end;
end;
end;```

## Scala

Library: Scala

### Imperative

```  {
var (x, l) = (0, List[Int]())
do {
x += 1
l :+= x // A new copy of this list with List(x) appended.
} while (x % 6 != 0)
l
}.foreach(println(_))```

### Tail recursive

```	def loop(iter: Int, cond: (Int) => Boolean, accu: List[Int]): List[Int] = {
val succ = iter + 1
val temp = accu :+ succ
if (cond(succ)) loop(succ, cond, temp) else temp
}
println(loop(0, (_ % 6 != 0), Nil))```

### Stream

```  def loop(i: Int, cond: (Int) => Boolean): Stream[Int] = {
val succ = i + 1;
succ #:: (if (cond(succ)) loop(succ, cond) else Stream.empty)
}
loop(0, (_ % 6 != 0)).foreach(println(_))```

## Scheme

```(let loop ((i 1))
(display i)
(if (positive? (modulo i 6))
(loop (+ i 1))))```

## Scilab

Works with: Scilab version 5.5.1
```v=0
while %T
v=v+1
printf("%2d ",v)
if modulo(v,6)==0 then break; end
end
printf("\n")```
Output:
` 1  2  3  4  5  6 `

## Seed7

```\$ include "seed7_05.s7i";

const proc: main is func
local
var integer: number is 0;
begin
repeat
incr(number);
writeln(number)
until number rem 6 = 0
end func;```

## Sidef

```var value = 0;
do {
say ++value;
} while (value % 6);```

## Slate

```[| val |
val: 0.
[val: val + 1.
print: val.
val \\ 6 ~= 0] whileTrue
] do.```

## Smalltalk

```|val|
val := 0.
[
val := val + 1.
val displayNl.
] doWhile: [ (val rem: 6) ~= 0 ]```
```|val|
val := 0.
[
val := val + 1.
val displayNl.
] doUntil: [ (val rem: 6) == 0 ]```

To simulate the do-while construct, we can use the whileTrue: method of a block with a void while block.

```|val|
val := 0.
[
val := val + 1.
val displayNl.
(val rem: 6) ~= 0
] whileTrue: [ ]```

Or send the loop block a whileTrue message (without argument).

```|val|
val := 0.
[
val := val + 1.
val displayNl.
(val rem: 6) ~= 0
] whileTrue```

Corresponding false-checking messages are whileFalse: and whileFalse (without argument)

## Sparkling

```var i = 0;
do {
print(++i);
} while (i % 6 != 0);```

## Spin

Works with: BST/BSTC
Works with: FastSpin/FlexSpin
Works with: HomeSpun
Works with: OpenSpin
```con
_clkmode = xtal1 + pll16x
_clkfreq = 80_000_000

obj
ser : "FullDuplexSerial.spin"

pub main | n
ser.start(31, 30, 0, 115200)

n := 0
repeat
n += 1
ser.dec(n)
ser.tx(32)
while n // 6

waitcnt(_clkfreq + cnt)
ser.stop
cogstop(0)```
Output:
`1 2 3 4 5 6 `

```n = 0
>
n += 1
#.output(n)
< n%6```
Output:
```1
2
3
4
5
6
```

## Stata

Stata macro language has no do/while loop, but it's possible to achieve this with a while loop.

Use a flag to force the first loop. It's changed in the loop so that it will have no effect after the first loop.

```local n 0
local q 1
while `q' | mod(`n',6) {
local q 0
di `++n'
}```

Use an infinite while loop and do the test with an if' at the end of the loop.

```local n 0
while 1 {
di `++n'
if mod(`n',6)==0 continue, break
}```

### Mata

Mata has a do/while loop:

```mata
n=0
do {
printf("%f\n",++n)
} while (mod(n,6))
end```

## Suneido

```val = 0
do
{
Print(++val)
} while (val % 6 isnt 0)```
Output:
```1
2
3
4
5
6```

## Swift

Works with: Swift version 3.x+
```var val = 0
repeat {
val += 1
print(val)
} while val % 6 != 0```
Works with: Swift version 2.x
```var val = 0
repeat {
val++
print(val)
} while val % 6 != 0```
Works with: Swift version 1.x
```var val = 0
do {
val++
println(val)
} while val % 6 != 0```

## Tailspin

In Tailspin you can loop by sending a value back to the matchers (by "-> #"). Depending on how you set that up, you create different loops.

```templates doWhile
0 -> #
<> def val: \$ + 1;
\$val -> !OUT::write
\$val -> \(<?(\$ mod 6 <~=0>)> \$!\) -> #
end doWhile```

## Tcl

Tcl does not have a built-in `do...while` construct. This example demonstrates the ease of creating new looping contructs in plain Tcl. `do` procedure taken from Tcler's wiki

```proc do {body keyword expression} {
if {\$keyword eq "while"} {
set expression "!(\$expression)"
} elseif {\$keyword ne "until"} {
return -code error "unknown keyword \"\$keyword\": must be until or while"
}
set condition [list expr \$expression]
while 1 {
uplevel 1 \$body
if {[uplevel 1 \$condition]} {
break
}
}
return
}

set i 0
do {puts [incr i]} while {\$i % 6 != 0}```
Library: Tcllib (Package: control)
```package require control
set i 0; control::do {puts [incr i]} while {\$i % 6 != 0}
set i 0; control::do {puts [incr i]} until {\$i % 6 == 0}```

Mind you, it is also normal to write this task using a normal `while` as:

```set i 0
while true {
puts [incr i]
if {\$i % 6 == 0} break
}```

## TUSCRIPT

```\$\$ MODE TUSCRIPT
var=0
LOOP
var=var+1, rest=var%6
PRINT var
IF (rest==0) EXIT
ENDLOOP```
Output:
```1
2
3
4
5
6
```

## UNIX Shell

Works with: bash
Works with: pdksh
Works with: zsh
```val=0
while true; do
echo \$((++val))
[ \$((val%6)) -eq 0 ] && break
done```
Works with: Bourne Shell
```val=0
while true; do
val=`expr \$val + 1`
echo \$val
expr \$val % 6 = 0 >/dev/null && break
done```
Works with: zsh
```for ((val=1;;val++)) {
print \$val
(( val % 6 )) || break
}```

## Vala

```  int a = 0;

do {
a++;
print(a.to_string() + "\n");
}
while ( a % 6 != 0);```

## Vedit macro language

```#1 = 0
do {
#1++
Num_Type(#1)
} while (#1 % 6 != 0);```

## Verbexx

```//  Basic @LOOP until: verb

@LOOP init:{@VAR n = 0} until:(n % 6 == 0)
{
n++;
@SAY n;
};```

## Verilog

```module main;
integer  i;

initial begin
i = 1;

\$write(i);
while(i % 6 != 0) begin
i = i + 1;
\$write(i);
end
\$finish ;
end
endmodule```

## V (Vlang)

Translation of: go

There is no explicit do-while in Vlang, but it can be simulated with a range-based for loop and the break statement.

```fn main() {
mut value := 0
for {
value++
println(value)
if value%6 != 0 {
break
}
}
}```
Output:
```1
2
3
4
5
6```

It can also be simulated without using a break statement as follows:

```fn main() {
mut value := 0
for ok := true; ok; ok = value%6 != 0 {
value++
println(value)
}
}```
Output:
```Same as before.
```
```fn main() {
// do-while loop 1
mut n1 := 2
for n1 < 6 {
n1 *= 2
}
println(n1) // prt 8
// do-while loop 2
mut n2 := 2
for ok := true; ok; ok = n2%8 != 0 {
n2 *= 2
}
println(n2) // prt 8
// do-while loop 3
mut n3 := 2
for {
n3 *= 2
if n3 >= 6 {
break
}
}
println(n3) // prt 8
}```

## Wren

Wren doesn't have a do/while loop as such but we can simulate it using an infinite loop with a final conditional break.

```var v = 0
while (true) {
v = v + 1
System.print(v)
if (v%6 == 0) break
}```
Output:
```1
2
3
4
5
6
```

It can also be simulated without using a break statement as follows:

```var value = 0
var ok = true
while (ok) {
value = value + 1
System.print(value)
ok = value%6 != 0
}```
Output:
```Same as before.
```

## X86 Assembly

Works with: nasm
Works with: windows
```extern _printf

section .data
output db 0,0

section .text
global _main
_main:
mov bl, 0
looping:
add bl, 0x31 ;0x30 to 0x39 is 0 to 9 in ASCII
mov [output], bl
sub bl, 0x30
push output
call _printf
xor eax, eax
xor edx, edx
mov al, bl
mov ecx, 6
div ecx ; remainder is saved in edx
cmp edx, 0
jne looping ; if n & 6 != 0 do looping again
xor eax, eax
ret```

## XPL0

```code CrLf=9, IntOut=11;
int V;
[V:= 0;
repeat  V:= V+1;
IntOut(0, V);  CrLf(0);
until   rem(V/6) = 0;
]```

## Yorick

```val = 0;
do {
val++;
write, val;
} while(val % 6 != 0);```

## zkl

Translation of: Yorick
```val := 0;
do {
val+=1;
val.print(" ");
} while(val % 6 != 0);```
Output:
```1 2 3 4 5 6
```

## Zig

```const std = @import("std");

pub fn main() !void {
var a: u8 = 0;
// no do-while in syntax, trust the optimizer to do
// correct Loop inversion https://en.wikipedia.org/wiki/Loop_inversion
// If the variable `alive` is independent to other variables and not in
// diverging control flow, then the optimization is possible in general.
var alive = true;
while (alive == true or a % 6 != 0) {
alive = false;
a += 1;
try std.io.getStdOut().writer().print("{d}\n", .{a});
}
}```