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.

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>

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>

Aime

<lang aime>integer a;

a = 0; do {

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

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

ALGOL 68

<lang algol68>FOR value WHILE

 print(value);

WHILE # value MOD 6 /= 0 DO

 SKIP

OD</lang>

AmigaE

<lang amigae>PROC main()

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

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

BASIC

Works with: QuickBasic version 4.5

<lang qbasic>a = 0 do

 a = a + 1
 print a

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

BBC BASIC

<lang bbcbasic>a = 0 REPEAT

 a = a + 1
 PRINT a

UNTIL a MOD 6 = 0</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>

ChucK

<lang> 0 => int value; do {

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

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

C++

<lang cpp>int val = 0; do{

  val++;
  cout << val << endl;

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

C#

<lang csharp>int a = 0;

do {

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

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

Chapel

<lang chapel>var val = 0; do {

       val += 1;
       writeln(val);

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

Clipper

<lang clipper> Local n := 0

  DO WHILE .T.
     ? ++n
     IF n % 6 == 0
        EXIT
     ENDIF
  ENDDO</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>(setq 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>

Clojure

<lang Clojure>(loop [i 0]

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

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>

DWScript

<lang Delphi> var i := 0;

repeat

  Inc(i);
  PrintLn(i);

until i mod 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 console

loop n | n % 6 == 0 = out ()

      | else = out `seq` loop (n+1)
       where out = & writen n</lang>

This implementation uses a thunk to represent a console output. Output is not done in the initialization of 'out' variable, it is done when 'out' calculation is forced by a 'seq' operator (sequencing operator).

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>

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>

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>

GAP

<lang gap>n := 0; repeat

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

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

Go

No do-while in Go. <lang go>package main

import "fmt"

func main() {

   for value := 0;; {
       value++
       fmt.Println(value)
       if value % 6 == 0 {
           break
       }
   }

}</lang>

Output:

GML

<lang GML>i = 0 do

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

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

Groovy

Groovy does not have a bottom-checking loop construct! So 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:

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>

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

<lang javascript>var val = 0; do {

 print(++val);

} while (val % 6);</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> i = 0 while true

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

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

Liberty BASIC

<lang lb> a = 0 do

 a =a +1
 print a

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

Lisaac

<lang Lisaac>+ val : INTEGER; {

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

}.while_do { };</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>

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>

Maple

<lang Maple>val := 0: do

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

end do:</lang>

Mathematica

<lang Mathematica>value = 5; NestWhile[

 # + 1 &
 ,
 value
 , (Print[#]; Mod[#, 6] != 0) &
 ];</lang>

gives back: <lang Mathematica>5 6</lang> If the starting value is 6, only 6 is returned.

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>

МК-61/52

Modula-2

<lang modula2>MODULE DoWhile;

 IMPORT InOut;

 VAR
   i: INTEGER;

BEGIN

 i := 0
 REPEAT
   InOut.WriteInt(i, 1);
   InOut.WriteLn;
   INC(i)
 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>

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, but it's easy to write your own: <lang nim>template doWhile(a: expr, b: stmt): stmt =

 b
 while a:
   b

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

 val += 1
 echo val</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>

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>

Objeck

<lang objeck> i := 0; do {

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

} while (i % 6 <> 0); </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 println 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>

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>

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>

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:

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>

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>

REBOL

<lang REBOL>REBOL [ Title: "Loop/While" Author: oofoe Date: 2009-12-19 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:

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.

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.

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=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>

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; { say ++value; } do while {value % 6};</lang>

Slate

<lang slate>[| val |

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

] do.</lang>

Smalltalk

Works with: Smalltalk/X

Works with: VisualWorks 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>

Works with: GNU Smalltalk

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>

Sparkling

<lang sparkling>var i = 0; do {

   print(++i);

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

Suneido

<lang Suneido>val = 0 do

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

Output:

Swift

<lang swift>var val = 0 do {

  val++
  println(val)

} while val % 6 != 0</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>

Vedit macro language

<lang vedit>#1 = 0 do {

   #1++
   Num_Type(#1)

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

Visual Basic .NET

<lang vbnet>Dim i = 0 Do

   i += 1
   Console.WriteLine(i)

Loop Until i Mod 6 = 0</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