Loops/Do-while

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.

Related tasks

Reference

Do while loop Wikipedia.

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

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
         BR    14                  return to caller
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
		ADC #6
		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
    ldr x0,qAdrszMessResult
    ldr x1,qAdrsZoneConv       // display conversion
    bl strInsertAtCharInc      // insert result at @ character
    bl affichageMess           // display message
    add x20,x20,1              // increment counter
    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
 
qAdrsZoneConv:          .quad sZoneConv
qAdrszMessResult:       .quad szMessResult
/********************************************************/
/*        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);

Ada

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

A "goto-less" approach

Works with: A60

While a judicious "goto" may sometimes be clearer than the alternative, it is possible to avoid it in this case by using the for-while statement and a boolean flag to implement a test-at-the-bottom loop.

begin

integer i;
boolean another;
i := 0;
another := true;
for i := i while another do
  begin
    i := i + 1;
    outinteger(1,i);
    comment - stop once 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

    ldr r1,iAdrsMessValeur     @ display value
    bl conversion10             @ call function with 2 parameter (r0,r1)
    ldr r0,iAdrszMessResult
    bl affichageMess            @ display message
    add r4,#1                   @ increment counter
    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

iAdrsMessValeur:          .int sMessValeur
iAdrszMessResult:         .int szMessResult
/******************************************************************/
/*     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 
    addne r2,r2,#1            @ else add 1 in the length 
    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
    add r1,#48        @ digit	
    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:

Arturo

value: 0
until [
	value: value + 1
	print value
] [ 0 = value%6 ]

Output:

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:

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:

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

Gambas

Click this link to run this code

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:

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
               ADD 1 TO i
               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:

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

DuckDB

Works with: DuckDB version V1.0

DuckDB's iterative control structure is the recursive CTE (Common Table Expression), which checks the initial condition before iterating, so in the following, the first increment is performed unconditionally.

create or replace function do_while(init) as table (
  with recursive cte as (
    select init+1 as value     -- Increment unconditionally
    union all                  -- Loop
    select value+1 as value    -- Each time through the loop, add 1 to the value then print it.
    from cte
    where value % 6 != 0       -- "while value mod 6 is not equal to 0"
  )
  from cte order by value
);

# The task
from do_while(0);

# Also check that the loop executes at least once.
from do_while(-1);

Output:

┌───────┐
│ value │
│ int32 │
├───────┤
│     1 │
│     2 │
│     3 │
│     4 │
│     5 │
│     6 │
└───────┘
┌───────┐
│ value │
│ int32 │
├───────┤
│     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:

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:

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:

Frink

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

FutureBasic

window 1

dim as long i

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

HandleEvents

Output:

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:

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:

Harbour

LOCAL n := 0

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

Haskell

import Data.List
import Control.Monad
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:

With mutable references

Using iterateWhile from monad-loops package

import Data.IORef
import Control.Monad.Loops

main = do
  x <- newIORef 0;
  iterateWhile (\val -> val `mod` 6 /= 0 ) $ do
    modifyIORef x (+1)
    val <- readIORef x
    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.

An initial value,
a Do function which transforms that value repetitively, corresponding to the body of the loop,
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:

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;
 
  return varHead ? (
    fnTest(varHead) ? [varHead].concat(
      takeWhile(lst.slice(1), fnTest)
    ) : []
  ) : []
}
 
console.log(
  takeWhile(
    range(1, 100),
    function (x) {
      return x % 6;
    }
  ).join('\n')
);

Output:

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

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;

The task:

0 | do_while( .+1; . % 6 != 0 )

Output:

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:

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
    add 1 to n
    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 
loop:	addi	$s0, $s0, 1	# add 1 to $s0
	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

Works with: Caché ObjectScript

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

Or we can use the statement evaluation to execute code before the check:

var val = 0
while (inc val; echo val; val mod 6 != 0):
  discard

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.
   MESSAGE ii VIEW-AS ALERT-BOX.
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:

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:

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:

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])
  (let ([n (add1 n)])
    (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 ()
  (set! n (add1 n))
  (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:

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:

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 1^st 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;

S-BASIC

S-BASIC's REPEAT..UNTIL control structure is the equivalent of a DO..WHILE statement with the terminating test inverted.

rem - return n mod m
function mod(n, m = integer) = integer
end = n - (n / m) * m

var i = integer
i = 0
repeat
  begin
    i = i + 1
    print i;
  end
until mod(i, 6) = 0

end

Output:

 1 2 3 4 5 6

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

SPL

n = 0
>
  n += 1
  #.output(n)
< n%6

Output:

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:

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

v0.5 (also replacing the print with an emit)

doWhile source
  0 -> # !
  otherwise val is $ + 1;
    $val !
    $val -> if <|?($ mod 6 matches <~|=0>)> -> # !
end doWhile

$doWhile !

TAV

The language intentionally has no 'do-while', because it is seldomly useful; only a loop with optional while condition. For the effect of a 'while-do', an endless loop is terminated conditionally.

  x =: 0
  ?*                \ loop forever                    
    x =+ 1          \ increment x
    print x
    ? x %% 6 = 0    \ until
      ?>            \ break

Output:

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:

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:

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:

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
        add esp, 4
        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});
    }
}