Loops/Do-while: Difference between revisions

Content added Content deleted

Inline

Revision as of 13:53, 13 June 2022

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

<lang 11l>V val = 0 L

  val++
  print(val)
  I val % 6 == 0
     L.break</lang>

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. <lang 360asm>* 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</lang>

6502 Assembly

Code is called as a subroutine (i.e. JSR DoWhileSub). Specific OS/hardware routines for printing are left unimplemented. <lang 6502asm>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</lang>

AArch64 Assembly

Works with: as version Raspberry Pi 3B version Buster 64 bits

<lang AArch64 Assembly> /* 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"

</lang>

Action!

<lang Action!>Proc Main()

byte A

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

Return</lang>

ActionScript

<lang actionscript>var val:int = 0; do {

   trace(++val);

} while (val % 6);</lang>

Ada

<lang ada>loop

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

end loop;</lang> Here is an alternative version: <lang ada>for Value in 0..Integer'Last loop

  Put (Value);
  exit when Value mod 6 = 0;

end loop;</lang>

Agena

Tested with Agena 2.9.5 Win32 <lang agena>scope

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

epocs</lang>

Aime

<lang aime>integer a;

a = 0; do {

  a += 1;
  o_integer(a);
  o_byte('\n');

} while (a % 6 != 0);</lang>

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. <lang algol60>'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'</lang>

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.) <lang algol60> 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 </lang>

Output:

 1  2  3  4  5  6

ALGOL 68

<lang algol68>FOR value WHILE

 print(value);

WHILE # value MOD 6 /= 0 DO

 SKIP

OD</lang>

ALGOL W

<lang algolw>begin

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

end.</lang>

AmigaE

<lang amigae>PROC main()

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

ENDPROC</lang>

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

</lang>

AppleScript

<lang 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 </lang>

Output:

Arturo

<lang rebol>value: 0 until [ value: value + 1 print value ] [ 0 = value%6 ]</lang>

Output:

Asymptote

Asymptote's control structures are similar to those in C, C++, or Java <lang Asymptote>int i = 0; do {

   ++i;
 write(" ", i, suffix=none);

} while (i % 6 != 0);</lang>

AutoHotkey

<lang AutoHotkey>While mod(A_Index, 6) ;comment:everything but 0 is considered true

 output = %output%`n%A_Index%

MsgBox % output</lang>

AWK

<lang awk>BEGIN {

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

}</lang>

Axe

While Axe does not have explicit do-while loops, they can be easily emulated using an infinite loop with a conditional terminator: <lang axe>0→A While 1

A++
Disp A▶Dec,i

End!If A^6</lang>

BASIC

Works with: QBasic version 1.1

Works with: QuickBasic version 4.5

Works with: Just BASIC

<lang qbasic>a = 0 do

 a = a + 1
 print a

loop while a mod 6 <> 0</lang>

ASIC

ASIC does not have a do .. while construct. Equivalent using WHILE: <lang basic> 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 </lang>

Output:

Equivalent using conditional jump: <lang basic> REM Loops/Do-while

I = 0 LoopStart:

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

END </lang>

Output:

As above

BaCon

<lang freebasic> a=0 REPEAT

   INCR a
   PRINT a

UNTIL MOD(a,6) == 0 </lang>

BASIC256

<lang BASIC256>i = 0

do i += 1 print i; " "; until i mod 6 = 0 print end</lang>

BBC BASIC

<lang bbcbasic>a = 0 REPEAT

 a = a + 1
 PRINT a

UNTIL a MOD 6 = 0</lang>

IS-BASIC

<lang IS-BASIC>100 LET I=0 110 DO 120 LET I=I+1 130 PRINT I 140 LOOP UNTIL MOD(I,6)=0</lang>

Minimal BASIC

Minimal BASIC does not have a do .. while construct. Equivalent using conditional jump: <lang gwbasic> 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 </lang>

QBasic

Works with: QBasic version 1.1

Works with: QuickBasic version 4.5

Works with: Just BASIC

<lang qbasic>a = 0 DO

 a = a + 1
 PRINT a;

LOOP WHILE a MOD 6 <> 0</lang>

Sinclair ZX81 BASIC

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

True BASIC

<lang basic>LET i = 0

DO

  LET i = i + 1
  PRINT i; " ";

LOOP WHILE REMAINDER(i, 6) <> 0 PRINT END</lang>

XBasic

Works with: Windows XBasic

<lang 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 </lang>

Tiny BASIC

<lang Tiny BASIC> REM TinyBasic does not have a do .. while construct. Equivalent using conditional jump:

   LET i = 0

10 LET i = i + 1

   PRINT i
   IF (i / 6) * 6 <> i THEN GOTO 10
   END</lang>

Yabasic

<lang yabasic>i = 0

repeat i = i + 1 print i, " "; until mod(i, 6) = 0 print</lang>

bc

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

Befunge

<lang befunge>0>1+:.v

|%6: <
@</lang>

C

<lang c>int val = 0; do{

  val++;
  printf("%d\n",val);

}while(val % 6 != 0);</lang>

C#

<lang csharp>int a = 0;

do {

   a += 1;
   Console.WriteLine(a);

} while (a % 6 != 0);</lang>

C++

<lang cpp>int val = 0; do{

  val++;
  std::cout << val << std::endl;

}while(val % 6 != 0);</lang>

Chapel

<lang chapel>var val = 0; do {

       val += 1;
       writeln(val);

} while val % 6 > 0;</lang>

ChucK

<lang> 0 => int value; do {

   value++;
   <<<value>>>;

} while(value % 6 != 0); </lang>

Clipper

<lang clipper> Local n := 0

  DO WHILE .T.
     ? ++n
     IF n % 6 == 0
        EXIT
     ENDIF
  ENDDO</lang>

Clojure

<lang Clojure>(loop [i 0]

 (let [i* (inc i)]
   (println i*)
   (when-not (zero? (mod i* 6))
     (recur i*))))</lang>

COBOL

The COBOL equivalent of a do-while loop is PERFORM WITH TEST AFTER UNTIL some-condition. <lang cobol> 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
          .</lang>

Coco

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

<lang coco>v = 0 do

  console.log ++v

while v % 6</lang>

CoffeeScript

CoffeeScript doesn't have do {} while () loop, but it can be emulated using loop statement and break unless statement. <lang coffeescript>val = 0 loop

 console.log ++val
 break unless val % 6</lang>

ColdFusion

 value = 0;
 do
 {
   value += 1;
   writeOutput( value );
 } while( value % 6 != 0 );

</cfscript></lang>

Common Lisp

<lang lisp>(let ((val 0))

 (loop do
       (incf val)
       (print val)
       while (/= 0 (mod val 6))))</lang>

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

<lang lisp>(loop with val = 0

     do (print (incf val))
     until (= 0 (mod val 6)))</lang>

Using DO

<lang lisp> (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

</lang>

Output:

D

<lang d>import std.stdio;

void main() {

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

}</lang>

Output:

1 2 3 4 5 6

dc

Translation of: bc

<lang dc>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</lang>

Delphi

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

Draco

<lang draco>proc nonrec main() void:

   byte i;
   i := 0;
   while
       i := i + 1;
       write(i:2);
       i % 6 ~= 0
   do od

corp</lang>

Output:

 1 2 3 4 5 6

Dragon

<lang dragon>val = 0 do{

  val++
  showln val

}while(val % 6 != 0)</lang>

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

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

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

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

And if the block is defined as a named function:

Result:

DWScript

<lang Delphi> var i := 0;

repeat

  Inc(i);
  PrintLn(i);

until i mod 6 = 0; </lang> Bold text

Dyalect

<lang dyalect>var x = 0

do {

   x += 1
   print(x)

} while x % 6 != 0</lang>

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. <lang e>var x := 0 __loop(fn {

   x += 1
   println(x)
   x % 6 != 0   # this is the return value of the function

})</lang>

Ela

<lang ela>open monad io

loop n | n % 6 == 0 = do return ()

      | else = do 
         putStrLn (show n)
         loop (n+1)

_ = loop 10 ::: IO</lang>

Elixir

<lang 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)</lang>

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.

<lang Lisp>(let ((val 0))

 (while (progn
          (setq val (1+ val))
          (message "%d" val)
          (/= 0 (mod val 6)))))</lang>

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

<lang Lisp>(let ((val 0) done)

 (while (not done)
   (setq val (1+ val))
   (message "%d" val)
   (setq done (zerop (mod val 6)))))</lang>

Erlang

<lang 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). </lang>

ERRE

<lang ERRE> A=0 REPEAT

 A=A+1
 PRINT(A)

UNTIL A MOD 6=0 !UNTIL A-6*INT(A/6)=0 for C-64 </lang>

Euphoria

Works with: Open Euphoria

<lang 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 </lang>

F#

If you must have a loop then this is acceptable F# <lang fsharp> let rec loop n =

 printfn "%d " n
 if (n+1)%6 > 0 then loop (n+1)

loop 0 </lang>

But I prefer this way: <lang fsharp> Seq.initInfinite id |> Seq.takeWhile(fun n->n=0 || n%6>0) |> Seq.iter (fun n-> printfn "%d" n) </lang>

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.

<lang fsharp> // 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") </lang>

Output:

Factor

<lang factor>0 [ dup 6 mod 0 = not ] [ [ . ] [ 1 + ] bi ] do while drop</lang>

Fantom

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

<lang fantom> class Main {

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

} </lang>

Forth

<lang forth>: do-until

 0
 begin 1+
       dup .
       dup 6 mod 0=
 until
 drop ;</lang>

Fortran

Works with: Fortran version 90 and later

<lang fortran>INTEGER :: i = 0 DO

 i = i + 1
 WRITE(*, *) i
 IF (MOD(i, 6) == 0) EXIT

END DO</lang>

Works with: Fortran version 77 and later

<lang fortran> 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</lang>

Works with: Fortran version IV and later

<lang fortran> IVALUE = 0

  10 CONTINUE
       IVALUE=IVALUE+1
       WRITE(6,301) IVALUE
 301   FORMAT(I5)          
     IF(MOD(IVALUE,6).NE.0) GOTO 10
     END</lang>

Works with: Fortran version I and later

<lang fortran> IVALUE = 0

  10 IVALUE=IVALUE+1
     WRITE 301,IVALUE
 301 FORMAT(I5)          
     IF(IVALUE-IVALUE/6*6) 10,20,10
  20 STOP
     END</lang>

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.

<lang fortress> 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 </lang>

Output:

FreeBASIC

<lang freebasic>' FB 1.05. 0 Win64

Dim i As Integer = 0 Do

 i += 1
 Print i; " ";

Loop While i Mod 6 <> 0 Print Sleep</lang>

Output:

 1  2  3  4  5  6

Frink

<lang frink>n = 0 do {

  n = n + 1
  println[n]

} while n mod 6 != 0</lang>

FutureBasic

<lang futurebasic>window 1

dim as long i

do

 i++
 print i

until ( i mod 6 == 0 )

HandleEvents</lang> Output:

Gambas

Click this link to run this code <lang gambas>Public Sub Main() Dim siCount As Short

Repeat

 Inc siCount
 Print siCount;;

Until siCount Mod 6 = 0

End</lang> Output:

1 2 3 4 5 6

GAP

<lang gap>n := 0; repeat

   n := n + 1;
   Print(n, "\n");

until RemInt(n, 6) = 0;</lang>

GML

<lang GML>i = 0 do

   {
   i += 1
   show_message(string(i))
   }

until (i mod 6 = 0)</lang>

Go

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

import "fmt"

func main() { var value int for { value++ fmt.Println(value)

               if value%6 != 0 {
                       break
               }

} }</lang>

Output:

It can also be simulated without using a break statement as follows: <lang go>package main

import "fmt"

func main() { var value int for ok := true; ok; ok = value%6 != 0 { value++ fmt.Println(value) } }</lang>

Output:

Same as before.

<lang go>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 }</lang>

Groovy

For Groovy 3.0.0 and later. <lang groovy>def i = 0 do {

   i++
   println i

} while (i % 6 != 0)</lang> 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. <lang groovy>def i = 0 while (true) {

   i++
   println i
   if (i % 6 == 0) break

}</lang>

Output:

GW-BASIC

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

Works with: PC-BASIC version any

<lang gwbasic> 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 </lang> Equivalent using GOTO:

Works with: PC-BASIC version any

<lang gwbasic> 10 LET I% = 0 20 LET I% = I% + 1 30 PRINT I% 40 IF I% MOD 6 <> 0 THEN GOTO 20 </lang>

Harbour

<lang visualfoxpro>LOCAL n := 0

DO WHILE .T.

  ? ++n
  IF n % 6 == 0
     EXIT
  ENDIF

ENDDO</lang>

Haskell

<lang haskell>import Data.List import Control.Monad import Control.Arrow

doWhile p f n = (n:) $ takeWhile p $ unfoldr (Just.(id &&& f)) $ succ n</lang> Example executed in GHCi: <lang haskell>*Main> mapM_ print $ doWhile ((/=0).(`mod`6)) succ 0 0 1 2 3 4 5</lang>

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.

<lang haskell>main :: IO () main =

 mapM_ print . reverse $
 until
   (\(x:_) -> (x > 0) && (mod x 6 == 0)) 
   (\xs@(x:_) -> succ x : xs) 
   [0]</lang>

Output:

With mutable references

Using iterateWhile from monad-loops package <lang haskell>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</lang>

Haxe

<lang haxe>var val = 0;

do {

 val++;
 Sys.println(val);

} while( val % 6 != 0);</lang>

HolyC

<lang holyc>U8 i = 0; do {

  i++;
  Print("%d\n", i);

} while (i % 6 != 0);</lang>

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.) <lang Icon>procedure main()

i := 0 repeat {

  write(i +:= 1)
  if i % 6 = 0 then break
  }

end</lang>

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

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). <lang j>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
  )</lang>

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

Java

<lang java>int val = 0; do{

  val++;
  System.out.println(val);

}while(val % 6 != 0);</lang>

JavaScript

Javascript: Imperative

<lang javascript>var val = 0; do {

 print(++val);

} while (val % 6);</lang>

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.

<lang JavaScript>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')

);</lang>

Output: <lang JavaScript>1 2 3 4 5 6</lang>

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:

<lang JavaScript>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')

);</lang>

Output: <lang JavaScript>1 2 3 4 5</lang>

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.

<lang JavaScript>(() => {

   '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];

})(); </lang>

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:

<lang JavaScript> // 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());

})(); </lang>

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: <lang jq># 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;</lang>

The task: <lang jq>0 | do_while( .+1; . % 6 != 0 )</lang>

Output:

Julia

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

<lang Julia> julia> i = 0 0

julia> while true

          println(i)
          i += 1
          i % 6 == 0 && break
      end

0 1 2 3 4 5 </lang>

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

<lang Julia> 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 </lang>

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

<lang Julia> 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 </lang>

Kotlin

<lang scala>// version 1.0.6

fun main(args: Array<String>) {

   var value = 0
   do {
       println(++value)
   }
   while (value % 6 != 0)

}</lang>

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

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

Lambdatalk

<lang scheme> {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>

Liberty BASIC

<lang lb> a = 0 do

 a =a +1
 print a

loop until ( a mod 6) = 0 </lang>

Lingo

Lingo has no do..while, but here how this behavior can be implemented: <lang lingo>i = 0 repeat while TRUE

 i = i+1
 put i
 if i mod 6 = 0 then exit repeat

end</lang>

Lisaac

<lang Lisaac>+ val : INTEGER; {

 val := val + 1;
 val.print;
 '\n'.print;
 val % 6 != 0

}.while_do { };</lang>

LiveCode

<lang LiveCode>repeat while n mod 6 is not 0 or n is 0

   add 1 to n
   put n

end repeat</lang>

Logo

<lang 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</lang>

Lua

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

<lang lua> i=0 repeat

 i=i+1
 print(i)

until i%6 == 0 </lang>

M2000 Interpreter

<lang M2000 Interpreter> Module checkit {

     x=0
     \\ Do or Repeat
     Do {
           x++
           Print x
     } Until x mod 6=0 
    
     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
     }

} Checkit </lang>

Output:

Maple

<lang Maple>val := 0: do

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

end do:</lang>

Mathematica/Wolfram Language

Because everything is an expression in Mathematica, While[body;condition] tests condition after body has been executed at least once. <lang Mathematica>value = 0; While[

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

]</lang>

MATLAB / Octave

<lang Matlab> a=0;

  while (1) 
     a = a+1; 
     disp(a);
  if (~mod(a,6)) break; end; 	
  end; </lang>

Maxima

<lang maxima>block([n: 0], do (ldisp(n: n + 1), if mod(n, 6) = 0 then return('done)))$</lang>

MAXScript

<lang maxscript>a = 0 do (

   print a
   a += 1

) while mod a 6 != 0</lang>

Metafont

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

<lang metafont>a := 0; forever: show a; a := a + 1; exitif a mod 6 = 0; endfor end</lang>

Microsoft Small Basic

Microsoft Small Basic does not have a do .. while construct. Equivalent using While: <lang microsoftsmallbasic> 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 </lang> Equivalent using Goto: <lang microsoftsmallbasic> i = 0 loopStart: i = i + 1 TextWindow.WriteLine(i) If Math.Remainder(i, 6) <> 0 Then

 Goto loopStart

EndIf </lang>

min

Works with: min version 0.19.6

<lang min>0 (dup 6 mod 0 == over 0 != and) 'pop (puts succ) () linrec</lang>

MIPS Assembly

<lang mips> .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 </lang>

МК-61/52

Modula-2

<lang modula2>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.</lang>

Modula-3

This is very similar to the Modula-2 code above. <lang modula3>REPEAT

 i := i + 1;
 IO.Put(Fmt.Int(i));

UNTIL i MOD 6 = 0;</lang>

Monicelli

The do-while loop is the only kind of loop available in Monicelli <lang monicelli> stuzzica

   ...     # loop body

e brematura anche, se <expr> # exit if <expr> is false </lang>

MUMPS

Works with: Caché ObjectScript

<lang MUMPS>DOWHILELOOP

   set val = 0    
   do {
       set val = val + 1
       write val,!
   } while ((val # 6) '= 0)
   
   quit</lang>

Output:


SAMPLES>do ^DOWHILELOOP
1
2
3
4
5
6

Neko

<lang ActionScript>/**

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</lang>

Output:

prompt$ nekoc loops-do-while.neko
prompt$ neko loops-do-while
1
2
3
4
5
6

Nemerle

<lang Nemerle>mutable x = 0; do {

   x++;
   WriteLine($"$x");

} while (x % 6 != 0)</lang>

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. <lang NetRexx>/* 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

</lang>

NewLISP

<lang NewLISP>(let ((i 0))

 (do-until (= 0 (% i 6))

(println (++ i))))</lang>

Nim

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

<lang Nim>var val = 0 while true:

 inc val
 echo val
 if val mod 6 == 0: break</lang>

It's also easy to write your own doWhile construction (but be aware that the instructions will be duplicated): <lang Nim>template doWhile(a, b: untyped): untyped =

 b
 while a:
   b

var val = 0 doWhile val mod 6 != 0:

 inc val
 echo val</lang>

NS-HUBASIC

<lang 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."</lang>

Oberon-2

Works with oo2c Version 2 <lang oberon2> 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. </lang>

Objeck

<lang objeck> i := 0; do {

  i += 1;
  i->PrintLine();

} while (i % 6 <> 0); </lang>

OCaml

OCaml doesn't have a do-while loop, so we can just make a local loop: <lang ocaml>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</lang>

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

<lang ocaml>let do_while f p =

 let rec loop() =
   f();
   if p() then loop()
 in
 loop()

(** val do_while : (unit -> 'a) -> (unit -> bool) -> unit *)</lang>

<lang ocaml>let v = ref 0 in do_while (fun () -> incr v; Printf.printf "%d\n" !v)

        (fun () -> !v mod 6 <> 0)</lang>

The example above is the an imperative form, below is its functional counterpart: <lang ocaml>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</lang>

Or in a very poor OCaml style, we can use an exception to exit a while loop: <lang ocaml>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 -> ()</lang>

Octave

The do-while can be changed into a do-until, just negating the condition of the while. <lang octave>val = 0; do

 val++;
 disp(val)

until( mod(val, 6) == 0 )</lang>

Oforth

<lang Oforth>0 doWhile: [ 1+ dup . dup 6 rem 0 <> ] drop</lang>

OpenEdge/Progress

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

Oz

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

 I = {NewCell 0}

in

 for until:@I mod 6 == 0 do
    I := @I + 1
    {Show @I}
 end</lang>

PARI/GP

The generic Pari loops (while, until) test at the beginning, so just use an infinite loop with a break. <lang parigp>x = 0; while(1,

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

)</lang>

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

<lang parigp>x = 0; while (print(x++) || x % 6, )</lang>

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

Pascal

<lang pascal>program countto6(output);

var

 i: integer;

begin

 i := 0;
 repeat
   i := i + 1;
   writeln(i)
 until i mod 6 = 0

end.</lang>

Perl

<lang perl>my $val = 0; do {

  $val++;
  print "$val\n";

} while ($val % 6);</lang> do ... until (condition) is equivalent to do ... while (not condition). <lang perl>my $val = 0; do {

  $val++;
  print "$val\n";

} until ($val % 6 == 0);</lang>

Phix

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

PHL

<lang phl>var i = 0; do { i = i::inc; printf("%i\n", i); } while (i%6 != 0);</lang>

PHP

<lang php>$val = 0; do {

  $val++;
  print "$val\n";

} while ($val % 6 != 0);</lang>

Picat

do while loop

 N = 0,
 do
    N := N+1,
    println(N)
 while (N mod 6 != 0).</lang>

Recursion

 do_while(0).

do_while(N) :-

 N1 = N + 1,
 println(N1),
 N1 mod 6 != 0,
 do_while(N1).</lang>

Both outputs the same.

Output:

PicoLisp

Literally: <lang PicoLisp>(let Val 0

  (loop
     (println (inc 'Val))
     (T (=0 (% Val 6))) ) )</lang>

Shorter: <lang PicoLisp>(let Val 0

  (until (=0 (% (println (inc 'Val)) 6))) )</lang>

or: <lang PicoLisp>(for (Val 0 (n0 (% (println (inc 'Val)) 6))))</lang>

Pike

<lang pike>int main(){

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

}</lang>

PL/I

<lang pli> dcl value fixed bin (31) init (0); do forever;

 value = value + 1;                   
                                      
 if mod(value, 6) = 0 then            
   leave;                             
                                      
 put list (value);

end; </lang> or shorter: <lang pli>

dcl value fixed bin(31) init(0);
do Until(value=6);
  value+=1;
  put Skip list(value);
end;</lang>

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. <lang plainenglish>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.</lang>

Pop11

<lang pop11>lvars val = 0; while true do

  val + 1 -> val;
  printf(val, '%p\n');
  quitif(val rem 6 = 0);

endwhile;</lang>

PowerShell

<lang powershell>$n = 0 do {

   $n++
   $n

} while ($n % 6 -ne 0)</lang>

Prolog

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

</lang>

PureBasic

Works with: PureBasic version 4.41

<lang PureBasic>x=0 Repeat

 x+1
 Debug x

Until x%6=0</lang>

Python

Python doesn't have a do-while loop. <lang python>val = 0 while True:

  val +=1
  print val
  if val % 6 == 0: break</lang>

or repeat the body of the loop before a standard while. <lang python>val = 1 print val while val % 6 != 0:

  val += 1
  print val</lang>

QB64

CBTJD: 2020/03/14 <lang qbasic>DO

   PRINT n
   n = n + 1

LOOP WHILE n MOD 6 <> 0</lang>

<lang QB64> '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 </lang>

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. <lang quackery>0 [ 1+ dup echo cr

   dup 6 mod 0 = until ] drop</lang>

R

<lang R>i <- 0 repeat {

  i <- i + 1
  print(i)
  if(i %% 6 == 0) break

}</lang>

Racket

Idiomatic Racket code is functional: <lang racket>

lang racket

(let loop ([n 0])

 (let ([n (add1 n)])
   (displayln n)
   (unless (zero? (modulo n 6)) (loop n))))

</lang>

But an imperative version is easy to do too: <lang racket>

lang racket

(define n 0) (let loop ()

 (set! n (add1 n))
 (displayln n)
 (unless (zero? (modulo n 6)) (loop)))

</lang>

Raku

(formerly Perl 6)

Works with: Rakudo Star version 2010.08

<lang perl6>my $val = 0; repeat {

   say ++$val;

} while $val % 6;</lang>

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

<lang perl6>my $val = 0; repeat {

   say ++$val;

} until $val %% 6;</lang> (Here we've used %%, the "divisible-by" operator.)

You can also put the condition before the block, without changing the order of evaluation. <lang perl6>my $val = 0; repeat while $val % 6 { say ++$val; }</lang>

REBOL

<lang 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 ]</lang>

Output:

Red

<lang Red>Red [] i: 0 until [

 ?? i
 i: i + 1
 i % 6 = 0 ;; loop , until this is true...

]

</lang>

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

<lang rexx>/*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.*/</lang>

Output:

version 2

<lang rexx>/*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.*/</lang>

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

</lang>

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
<lang ruby>val = 0 begin val += 1 puts val end while val % 6 != 0</lang>	<lang ruby>val = 0 begin val += 1 puts val end until val % 6 == 0</lang>

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

break unless	break if
<lang ruby>val = 0 loop do val += 1 puts val break unless val %6 != 0 end</lang>	<lang ruby>val = 0 loop do val += 1 puts val break if val %6 == 0 end</lang>

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.

<lang rust>let mut x = 0;

loop {

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

   if x % 6 == 0 { break; }

}</lang>

Salmon

<lang Salmon>variable x := 0; do

 {
   ++x;
   x!
 }

while (x % 6 != 0);</lang>

SAS

<lang 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;</lang>

Sather

Translation of: C

<lang sather>class MAIN is

 main is
   val ::= 0;
   loop
     val := val + 1;
     #OUT + val + "\n";
     while!(val % 6 /= 0)
   end;
 end;

end;</lang>

Scala

Library: Scala

Imperative

<lang scala> {

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

</lang>

Tail recursive

<lang scala> 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))</lang>

Stream

<lang scala> 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(_))</lang>

Scheme

<lang scheme>(let loop ((i 1))

 (display i)
 (if (positive? (modulo i 6))
     (loop (+ i 1))))</lang>

Scilab

Works with: Scilab version 5.5.1

<lang>v=0 while %T

   v=v+1
   printf("%2d ",v)
   if modulo(v,6)==0 then break; end

end printf("\n")</lang>

Output:

 1  2  3  4  5  6

Seed7

<lang 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;</lang>

Sidef

<lang ruby>var value = 0; do {

   say ++value;

} while (value % 6);</lang>

Slate

<lang slate>[| val |

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

] do.</lang>

Smalltalk

<lang smalltalk>|val| val := 0. [

 val := val + 1.
 val displayNl.

] doWhile: [ (val rem: 6) ~= 0 ]</lang>

<lang smalltalk>|val| val := 0. [

 val := val + 1.
 val displayNl.

] doUntil: [ (val rem: 6) == 0 ]</lang>

To simulate the do-while construct, we can use the whileTrue: method of a block with a void while block. <lang smalltalk>|val| val := 0. [

 val := val + 1.
 val displayNl.
 (val rem: 6) ~= 0

] whileTrue: [ ]</lang>

Or send the loop block a whileTrue message (without argument). <lang smalltalk>|val| val := 0. [

 val := val + 1.
 val displayNl.
 (val rem: 6) ~= 0

] whileTrue</lang>

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

Sparkling

<lang sparkling>var i = 0; do {

   print(++i);

} while (i % 6 != 0);</lang>

Spin

Works with: BST/BSTC

Works with: FastSpin/FlexSpin

Works with: HomeSpun

Works with: OpenSpin

<lang spin>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)</lang>

Output:

1 2 3 4 5 6

SPL

 n += 1
 #.output(n)

< n%6</lang>

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.

<lang stata>local n 0 local q 1 while `q' | mod(`n',6) { local q 0 di `++n' }</lang>

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

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

Mata

Mata has a do/while loop:

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

Suneido

<lang Suneido>val = 0 do

   {
   Print(++val)
   } while (val % 6 isnt 0)</lang>

Output:

Swift

Works with: Swift version 3.x+

<lang swift>var val = 0 repeat {

 val += 1
 print(val)

} while val % 6 != 0</lang>

Works with: Swift version 2.x

<lang swift>var val = 0 repeat {

 val++
 print(val)

} while val % 6 != 0</lang>

Works with: Swift version 1.x

<lang swift>var val = 0 do {

  val++
  println(val)

} while val % 6 != 0</lang>

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. <lang tailspin> templates doWhile

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

end doWhile </lang>

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 <lang tcl>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}</lang>

Library: Tcllib (Package: control)

<lang tcl>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}</lang>

Mind you, it is also normal to write this task using a normal while as: <lang tcl>set i 0 while true {

   puts [incr i]
   if {$i % 6 == 0} break

}</lang>

TUSCRIPT

<lang tuscript> $$ MODE TUSCRIPT var=0 LOOP var=var+1, rest=var%6 PRINT var IF (rest==0) EXIT ENDLOOP </lang>

Output:

UNIX Shell

Works with: bash

Works with: pdksh

Works with: zsh

<lang bash>val=0 while true; do

 echo $((++val))
 [ $((val%6)) -eq 0 ] && break

done</lang>

Works with: Bourne Shell

<lang bash>val=0 while true; do

 val=`expr $val + 1`
 echo $val
 expr $val % 6 = 0 >/dev/null && break

done</lang>

Works with: zsh

<lang bash>for ((val=1;;val++)) {

 print $val
 (( val % 6 )) || break

}</lang>

Vala

<lang vala> int a = 0;

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

</lang>

VBA

<lang VB>Public Sub LoopDoWhile()

   Dim value As Integer
   value = 0
   Do
       value = value + 1
       Debug.Print value;
   Loop While value Mod 6 <> 0

End Sub</lang>

Output:

 1  2  3  4  5  6

Vedit macro language

<lang vedit>#1 = 0 do {

   #1++
   Num_Type(#1)

} while (#1 % 6 != 0);</lang>

Verbexx

<lang verbexx>// Basic @LOOP until: verb

@LOOP init:{@VAR n = 0} until:(n % 6 == 0) {

    n++;
    @SAY n;

};</lang>

Verilog

<lang 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 </lang>

Visual Basic .NET

<lang vbnet>Dim i = 0 Do

   i += 1
   Console.WriteLine(i)

Loop Until i Mod 6 = 0</lang>

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. <lang ecmascript>var v = 0 while (true) {

   v = v + 1
   System.print(v)
   if (v%6 == 0) break

}</lang>

Output:

It can also be simulated without using a break statement as follows: <lang ecmascript>var value = 0 var ok = true while (ok) {

   value = value + 1
   System.print(value)
   ok = value%6 != 0

}</lang>

Output:

Same as before.

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. <lang go>fn main() { mut value := 0 for { value++ println(value)

               if value%6 != 0 {
                       break
               }

} }</lang>

Output:

It can also be simulated without using a break statement as follows: <lang vlang>fn main() { mut value := 0 for ok := true; ok; ok = value%6 != 0 { value++ println(value) } }</lang>

Output:

Same as before.

<lang vlang>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 }</lang>

X86 Assembly

Works with: nasm

Works with: windows

<lang asm> 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

</lang>

XPL0

<lang XPL0>code CrLf=9, IntOut=11; int V; [V:= 0; repeat V:= V+1;

       IntOut(0, V);  CrLf(0);

until rem(V/6) = 0; ]</lang>

Yorick

<lang yorick>val = 0; do {

   val++;
   write, val;

} while(val % 6 != 0);</lang>

zkl

Translation of: Yorick

<lang zkl>val := 0; do {

   val+=1;
   val.print(" ");

} while(val % 6 != 0);</lang>

Output:

1 2 3 4 5 6

Zig

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

}</lang>

@@ Line 638: / Line 638: @@
 END</lang>
-=={{header|XBasic}}==
+==={{header|XBasic}}===
 {{works with|Windows XBasic}}
 <lang xbasic>