Loops/Do-while: Difference between revisions

{{trans|Python}}

 

L

val++

print(val)

I val % 6 == 0

 

=={{header|360 Assembly}}==

;Basic

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

DOWHILE CSECT , This program's control section

BAKR 14,0 Caller's registers to linkage stack

WTOLEN DC H'2' fixed WTO length of two

WTOTXT DC CL2' '

;Structured Macros

Although specified at the beginning (DO UNTIL), the test is done at the end of the loop (ENDDO).

Structured macros (DO ENDDO) weren't in the 1963 standard of Assembler 360, but there are part of it since since 1998.

DOWHILE CSECT

USING DOWHILE,12 set base register

DC H'0' must be zero

WTOTXT DS C one char

 

=={{header|6502 Assembly}}==

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

TYA

PHA ;push accumulator and Y register onto stack

TAY

PLA ;restore Y register and accumulator from stack

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program loopdowhile64.s */

.include "../includeARM64.inc"

 

 

 

=={{header|Action!}}==

byte A

 

Until A Mod 6=0

Od

 

=={{header|ActionScript}}==

do

{

trace(++val);

 

=={{header|Ada}}==

Value := Value + 1;

Put (Value);

exit when Value mod 6 = 0;

Here is an alternative version:

Put (Value);

exit when Value mod 6 = 0;

 

=={{header|Agena}}==

Tested with Agena 2.9.5 Win32

local i := 0;

do

print( i )

as ( i % 6 ) <> 0

 

=={{header|Aime}}==

 

a = 0;

o_integer(a);

o_byte('\n');

 

=={{header|ALGOL 60}}==

{{works with|ALGOL 60|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.

'INTEGER' I;

I:=0;

'GOTO' LOOP;

ENDLOOP:

{{out}}

<pre>

{{works with|A60}}

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

begin

 

 

end

{{out}}

<pre>

 

=={{header|ALGOL 68}}==

print(value);

# WHILE # value MOD 6 /= 0 DO

SKIP

 

=={{header|ALGOL W}}==

integer i;

i := 0;

end

do begin end

 

=={{header|AmigaE}}==

DEF i = 0

REPEAT

WriteF('\d\n', i)

UNTIL Mod(i, 6) = 0

 

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

 

/* ARM assembly Raspberry PI */

pop {r4, lr}

bx lr

 

=={{header|AppleScript}}==

on printConsole(x)

return x as string

printConsole(table)

end repeat

{{out}}

<pre>

=={{header|Arturo}}==

 

until [

value: value + 1

print value

 

{{out}}

5

6</pre>

 

=={{header|AutoHotkey}}==

output = %output%`n%A_Index%

 

=={{header|AWK}}==

val = 0

do {

print val

} while( val % 6 != 0)

 

=={{header|Axe}}==

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

While 1

A++

Disp A▶Dec,i

 

=={{header|BASIC}}==

 

==={{header|ASIC}}===

ASIC does not have a <code>do .. while</code> construct. Equivalent using <code>WHILE</code>:

REM Loops/Do-while

 

 

END

{{out}}

<pre>

</pre>

Equivalent using conditional jump:

REM Loops/Do-while

 

 

END

{{out}}

As above

 

==={{header|BaCon}}===

a=0

REPEAT

PRINT a

UNTIL MOD(a,6) == 0

 

==={{header|BASIC256}}===

 

do

until i mod 6 = 0

print

 

==={{header|BBC BASIC}}===

REPEAT

a = a + 1

PRINT a

 

==={{header|IS-BASIC}}===

110 DO

120 LET I=I+1

130 PRINT I

 

==={{header|Minimal BASIC}}===

Minimal BASIC does not have a <code>do .. while</code> construct. Equivalent using conditional jump:

10 REM Loops/Do-while

20 LET I=0

50 IF INT(I/6)*6 <> I THEN 30

60 END

 

==={{header|Sinclair ZX81 BASIC}}===

20 LET X=X+1

30 PRINT X

 

==={{header|True BASIC}}===

 

DO

LOOP WHILE REMAINDER(i, 6) <> 0

PRINT

 

==={{header|Yabasic}}===

repeat

print i, " ";

until mod(i, 6) = 0

 

=={{header|bc}}==

for (;;) {

++i /* increments then prints i */

if (i % 6 == 0) break

}

 

=={{header|Befunge}}==

|%6: <

 

=={{header|C}}==

do{

val++;

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

 

=={{header|C sharp|C#}}==

 

 

do

a += 1;

Console.WriteLine(a);

 

=={{header|C++}}==

do{

val++;

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

 

=={{header|Chapel}}==

do {

val += 1;

writeln(val);

 

=={{header|ChucK}}==

0 => int value;

do

}

while(value % 6 != 0);

 

=={{header|Clipper}}==

DO WHILE .T.

? ++n

EXIT

ENDIF

 

=={{header|Clojure}}==

(let [i* (inc i)]

(println i*)

(when-not (zero? (mod i* 6))

 

=={{header|COBOL}}==

The COBOL equivalent of a do-while loop is <code>PERFORM WITH TEST AFTER UNTIL some-condition</code>.

PROGRAM-ID. loop-do-while.

 

 

GOBACK

 

=={{header|Coco}}==

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

 

do

console.log ++v

 

=={{header|CoffeeScript}}==

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

loop

console.log ++val

 

=={{header|ColdFusion}}==

value = 0;

do

writeOutput( value );

} while( value % 6 != 0 );

 

=={{header|Common Lisp}}==

(loop do

(incf val)

(print val)

 

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

 

do (print (incf val))

 

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

 

{{out}}

 

=={{header|D}}==

 

void main() {

write(val, " ");

} while (val % 6 != 0);

{{out}}

<pre>1 2 3 4 5 6 </pre>

 

=={{header|dc}}==

{{trans|bc}}

[2Q]sA [A = code to break loop]sz

[

6 % 0 =A [call A if 0 == it % 6]sz

0 0 =B [continue loop]sz

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

Writeln;

Readln;

 

=={{header|Draco}}==

byte i;

i := 0;

i % 6 ~= 0

do od

{{out}}

<pre> 1 2 3 4 5 6</pre>

=={{header|Dragon}}==

 

do{

val++

showln val

 

=={{header|DUP}}==

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

 

 

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

 

 

And if the block is defined as a named function:

 

 

Result:

 

 

=={{header|DWScript}}==

var i := 0;

 

PrintLn(i);

until i mod 6 = 0;

'''Bold text'''

 

=={{header|Dyalect}}==

 

 

do

x += 1

print(x)

 

=={{header|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.

__loop(fn {

x += 1

println(x)

x % 6 != 0 # this is the return value of the function

 

<!-- XXX we should have an example of lambda-args sugar here -->

 

=={{header|Ela}}==

 

 

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

loop (n+1)

 

 

=={{header|Elixir}}==

def do_while(n) do

n1 = n + 1

end

 

 

=={{header|Emacs Lisp}}==

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

 

(while (progn

(setq val (1+ val))

(message "%d" val)

 

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

 

(while (not done)

(setq val (1+ val))

(message "%d" val)

 

=={{header|Erlang}}==

 

do() ->

do(0).

io:fwrite( "~p ", [N] ),

do(N+1).

 

=={{header|ERRE}}==

A=0

REPEAT

PRINT(A)

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

 

=={{header|Euphoria}}==

{{works with|Open Euphoria}}

include std/console.e

include std/math.e

 

if getc(0) then end if

 

=={{header|F_Sharp|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:

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

{{out}}

<pre>

 

=={{header|Factor}}==

 

=={{header|Fantom}}==

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

 

class Main

{

}

}

 

=={{header|Forth}}==

0

begin 1+

dup 6 mod 0=

until

 

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

DO

i = i + 1

WRITE(*, *) i

IF (MOD(i, 6) == 0) EXIT

 

{{works with|Fortran|77 and later}}

C Initialize modulus and value.

INTEGER MODLUS, IVALUE

 

STOP

 

{{works with|Fortran|IV and later}}

10 CONTINUE

IVALUE=IVALUE+1

301 FORMAT(I5)

IF(MOD(IVALUE,6).NE.0) GOTO 10

 

{{works with|Fortran|I and later}}

10 IVALUE=IVALUE+1

WRITE 301,IVALUE

IF(IVALUE-IVALUE/6*6) 10,20,10

20 STOP

 

=={{header|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 <code>break</code> equivalent.

 

component loops_do_while

export Executable

end loop

end

 

{{out}}

5

6

</pre>

 

=={{header|Frink}}==

do

{

n = n + 1

println[n]

 

=={{header|GAP}}==

repeat

n := n + 1;

Print(n, "\n");

 

=={{header|GML}}==

do

{

show_message(string(i))

}

 

=={{header|Go}}==

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

 

import "fmt"

}

}

{{out}}

<pre>1

6</pre>

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

 

import "fmt"

fmt.Println(value)

}

 

{{out}}

Same as before.

</pre>

 

import "fmt"

}

fmt.Println(n3) // prt 8

 

=={{header|Groovy}}==

For Groovy 3.0.0 and later.

do {

i++

println i

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.

while (true) {

i++

println i

if (i % 6 == 0) break

 

{{out}}

5

6</pre>

 

=={{header|Harbour}}==

 

DO WHILE .T.

EXIT

ENDIF

 

=={{header|Haskell}}==

import Control.Monad

import Control.Arrow

 

Example executed in GHCi:

0

1

3

4

 

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 =

mapM_ print . reverse $

(\(x:_) -> (x > 0) && (mod x 6 == 0))

(\xs@(x:_) -> succ x : xs)

 

{{Out}}

=== With mutable references ===

Using iterateWhile from monad-loops package

import Control.Monad.Loops

 

val <- readIORef x

print val

 

=={{header|Haxe}}==

 

do {

val++;

Sys.println(val);

 

=={{header|HolyC}}==

do {

i++;

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

 

=={{header|Icon}} and {{header|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 [[Icon%2BUnicon/Intro#Looping_Controls|Introduction to Icon and Unicon/Looping Controls]] for more information.)

 

i := 0

if i % 6 = 0 then break

}

 

=={{header|J}}==

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

 

 

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

 

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

 

i.0 0

 

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

=={{header|Java}}==

 

do{

val++;

System.out.println(val);

 

=={{header|JavaScript}}==

 

===Javascript: Imperative===

do {

print(++val);

 

===Javascript: Functional===

:#and a conditional While function.

 

'use strict';

var d = fnBody(varValue); // a transformed value

}

).join('\n')

 

Output:

2

3

4

5

 

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:

 

'use strict';

return Array.apply(null, Array(n - m + 1)).map(

}

).join('\n')

 

Output:

2

3

4

 

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

 

return [result1, result2];

})();

 

 

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

printVal(gen, gen.next());

})();

 

1

2

5

6

 

=={{header|jq}}==

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:

def do_while( action; condition ):

def w: action | if (condition | not) then empty else ., w end;

'''The task:'''

{{out}}

1

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

 

julia> i = 0

0

4

5

 

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

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

 

julia> @eval macro $(:do)(block, when::Symbol, condition)

when ≠ :when && error("@do expected `when` got `$s`")

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

i = 4

i = 5

 

=={{header|Kotlin}}==

 

fun main(args: Array<String>) {

}

while (value % 6 != 0)

 

{{out}}

 

=={{header|Lasso}}==

while(#x % 6 > 0 || #x == 0) => {^

++#x

'\r' // for formatting

 

=={{header|Lambdatalk}}==

{def do_while

{def do_while.r

{do_while 0}

-> 0 1 2 3 4 5 6 (end of loop)

 

 

=={{header|Lingo}}==

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

repeat while TRUE

i = i+1

put i

if i mod 6 = 0 then exit repeat

 

=={{header|Lisaac}}==

{

val := val + 1;

'\n'.print;

val % 6 != 0

 

=={{header|LiveCode}}==

add 1 to n

put n

 

=={{header|Logo}}==

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]

if notequal? 0 modulo :n 6 [my.loop :n]

end

 

=={{header|Lua}}==

Lua doesn't have a <code>do .. while</code> construct.

 

i=0

repeat

print(i)

until i%6 == 0

 

=={{header|M2000 Interpreter}}==

Module checkit {

x=0

\\ Do or Repeat

Do {

x++

x=0

{

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

}

}

Checkit

 

{{out}}

<pre>

1

2

 

=={{header|Maple}}==

do

val := 1 + val;

break

end if;

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

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

While[

value++;

Print[value];

Mod[value,6]!=0

 

=={{header|MATLAB}} / {{header|Octave}}==

 

while (1)

a = a+1;

disp(a);

if (~mod(a,6)) break; end;

 

=={{header|Maxima}}==

 

=={{header|MAXScript}}==

do

(

a += 1

)

 

=={{header|Metafont}}==

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

 

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

 

=={{header|min}}==

{{works with|min|0.19.6}}

 

=={{header|MIPS Assembly}}==

.text

main: li $s0, 0 # start at 0.

li $v0, 10

syscall # syscall to end the program

 

=={{header|МК-61/52}}==

 

=={{header|Modula-2}}==

IMPORT InOut;

 

InOut.WriteLn;

UNTIL i MOD 6 = 0;

 

=={{header|Modula-3}}==

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

i := i + 1;

IO.Put(Fmt.Int(i));

 

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

 

=={{header|MUMPS}}==

{{works with|Caché ObjectScript}}

set val = 0

do {

} while ((val # 6) '= 0)

{{out}}<pre>

 

=={{header|Neko}}==

Loops/Do-while in Neko

Tectonics:

index += 1;

$print(index, "\n");

 

{{out}}

 

=={{header|Nemerle}}==

do

{

x++;

WriteLine($"$x");

 

=={{header|NetRexx}}==

In NetRexx the '''do&ndash;while''' construct is implemented via the <code>until ''expru''</code> conditional clause of the <code>loop</code> instruction. The expression ''expru'' in the <code>until ''expru''</code> clause is evaluated at the end of the loop, guaranteeing that the loop will be executed at least once.

options replace format comments java crossref savelog symbols nobinary

 

say i_

end

 

=={{header|NewLISP}}==

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

 

=={{header|Nim}}==

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

 

while true:

inc val

echo val

 

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

b

while a:

doWhile val mod 6 != 0:

inc val

 

 

=={{header|Oberon-2}}==

Works with oo2c Version 2

MODULE LoopDoWhile;

IMPORT

Do

END LoopDoWhile.

 

=={{header|Objeck}}==

i := 0;

do {

}

while (i % 6 <> 0);

 

=={{header|OCaml}}==

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

let i = succ i in

Printf.printf "%d\n" i;

loop i

in

 

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

 

let rec loop() =

f();

in

loop()

 

do_while (fun () -> incr v; Printf.printf "%d\n" !v)

 

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

let rec loop v =

let v = f v in

(v))

(fun v -> v mod 6 <> 0)

 

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

exception Exit_loop

try while true do

raise Exit_loop;

done

 

=={{header|Octave}}==

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

do

val++;

disp(val)

 

=={{header|Oforth}}==

 

 

=={{header|OpenEdge/Progress}}==

 

DO WHILE ii MODULO 6 <> 0 OR ii = 0:

ii = ii + 1.

MESSAGE ii VIEW-AS ALERT-BOX.

 

=={{header|Oz}}==

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

I = {NewCell 0}

in

I := @I + 1

{Show @I}

 

=={{header|PARI/GP}}==

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

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.

 

 

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

 

=={{header|Pascal}}==

 

var

writeln(i)

until i mod 6 = 0

 

=={{header|Perl}}==

do {

$val++;

print "$val\n";

<code>do ... until (''condition'')</code> is equivalent to <code>do ... while (not ''condition'')</code>.

do {

$val++;

print "$val\n";

 

=={{header|Phix}}==

<span style="color: #004080;">integer</span> <span style="color: #000000;">x</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>

<span style="color: #008080;">while</span> <span style="color: #000000;">1</span> <span style="color: #008080;">do</span>

<span style="color: #008080;">if</span> <span style="color: #7060A8;">mod</span><span style="color: #0000FF;">(</span><span style="color: #000000;">x</span><span style="color: #0000FF;">,</span><span style="color: #000000;">6</span><span style="color: #0000FF;">)=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span> <span style="color: #008080;">exit</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>

 

=={{header|PHL}}==

 

do {

i = i::inc;

printf("%i\n", i);

 

=={{header|PHP}}==

do {

$val++;

print "$val\n";

 

=={{header|Picat}}==

===do while loop===

N = 0,

do

N := N+1,

println(N)

 

===Recursion===

do_while(0).

 

println(N1),

N1 mod 6 != 0,

 

Both outputs the same.

=={{header|PicoLisp}}==

Literally:

(loop

(println (inc 'Val))

Shorter:

or:

 

=={{header|Pike}}==

int value = 0;

do {

write(value + "\n");

} while (value % 6);

 

=={{header|PL/I}}==

dcl value fixed bin (31) init (0);

do forever;

put list (value);

end;

or shorter:

dcl value fixed bin(31) init(0);

do Until(value=6);

value+=1;

put Skip list(value);

{{out}}

<pre>

=={{header|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.

Start up.

Demonstrate do-while.

Write the string on the console.

If the counter is evenly divisible by 6, exit.

 

=={{header|Pop11}}==

while true do

val + 1 -> val;

printf(val, '%p\n');

quitif(val rem 6 = 0);

 

=={{header|PowerShell}}==

do {

$n++

$n

 

=={{header|Prolog}}==

% initial condition

do(0):- write(0),nl,do(1).

do(0).

 

 

=={{header|Python}}==

Python doesn't have a do-while loop.

while True:

val +=1

print val

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

print val

while val % 6 != 0:

val += 1

 

=={{header|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. <code>until</code> means <tt>jump to <code>[</code> if ToS is false</tt>.

 

=={{header|R}}==

repeat

{

print(i)

if(i %% 6 == 0) break

 

=={{header|Racket}}==

Idiomatic Racket code is functional:

#lang racket

(let loop ([n 0])

(displayln n)

(unless (zero? (modulo n 6)) (loop n))))

 

But an imperative version is easy to do too:

#lang racket

(define n 0)

(displayln n)

(unless (zero? (modulo n 6)) (loop)))

 

=={{header|Raku}}==

{{works with|Rakudo Star|2010.08}}

 

repeat {

say ++$val;

 

<code>repeat ... until ''condition''</code> is equivalent to <code>do ... while not ''condition''</code>.

 

repeat {

say ++$val;

(Here we've used <code>%%</code>, the "divisible-by" operator.)

<p>

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

 

repeat while $val % 6 {

say ++$val;

 

=={{header|REBOL}}==

Title: "Loop/While"

URL: http://rosettacode.org/wiki/Loop/Do_While

 

0 = mod value 6

 

{{out}}

 

=={{header|Red}}==

i: 0

until [

i % 6 = 0 ;; loop , until this is true...

]

<pre>i: 0

i: 1

<br>This necessitates the use of '''DO UNTIL''' instead of '''DO WHILE'''.

===version 1===

v=0

do until v//6==0 /*REXX // is the ÷ remainder.*/

say v

end

{{out}}

<pre>

 

===version 2===

 

do v=1 until v//6==0 /*REXX // is the ÷ remainder.*/

say v

end

'''output''' is the same as the 1^st version.<br>

 

=={{header|Ring}}==

n = 0

While True

if n % 6 = 0 exit ok

end

 

=={{header|Ruby}}==

! until

|-

begin

val += 1

puts val

begin

val += 1

puts val

|}

 

 

{| class="wikitable"

! break if

|-

loop do

val += 1

puts val

break unless val %6 != 0

loop do

val += 1

puts val

break if val %6 == 0

|}

 

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

 

 

loop {

 

if x % 6 == 0 { break; }

 

=={{header|Salmon}}==

do

{

x!

}

 

=={{header|SAS}}==

data _null_;

n=0;

put n;

end;

 

=={{header|Sather}}==

{{trans|C}}

main is

val ::= 0;

end;

end;

 

=={{header|Scala}}==

 

===Imperative===

var (x, l) = (0, List[Int]())

do {

l

}.foreach(println(_))

 

===Tail recursive===

val succ = iter + 1

val temp = accu :+ succ

if (cond(succ)) loop(succ, cond, temp) else temp

}

 

===Stream===

val succ = i + 1;

succ #:: (if (cond(succ)) loop(succ, cond) else Stream.empty)

}

 

=={{header|Scheme}}==

(display i)

(if (positive? (modulo i 6))

 

=={{header|Scilab}}==

{{works with|Scilab|5.5.1}}

while %T

v=v+1

if modulo(v,6)==0 then break; end

end

{{out}}

<pre> 1 2 3 4 5 6 </pre>

 

=={{header|Seed7}}==

 

const proc: main is func

writeln(number)

until number rem 6 = 0

 

=={{header|Sidef}}==

do {

say ++value;

 

=={{header|Slate}}==

val: 0.

[val: val + 1.

print: val.

val \\ 6 ~= 0] whileTrue

 

=={{header|Smalltalk}}==

 

val := 0.

[

val := val + 1.

val displayNl.

 

val := 0.

[

val := val + 1.

val displayNl.

 

To simulate the do-while construct, we can use the

<tt>whileTrue:</tt> method of a block with a void while block.

val := 0.

[

val displayNl.

(val rem: 6) ~= 0

 

Or send the loop block a <tt>whileTrue</tt> message (without argument).

val := 0.

[

val displayNl.

(val rem: 6) ~= 0

 

Corresponding false-checking messages are <tt>whileFalse:</tt> and <tt>whileFalse</tt> (without argument)

 

=={{header|Sparkling}}==

do {

print(++i);

 

=={{header|Spin}}==

{{works with|HomeSpun}}

{{works with|OpenSpin}}

_clkmode = xtal1 + pll16x

_clkfreq = 80_000_000

waitcnt(_clkfreq + cnt)

ser.stop

{{out}}

<pre>1 2 3 4 5 6 </pre>

 

=={{header|SPL}}==

>

n += 1

#.output(n)

{{out}}

<pre>

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 q 1

while `q' | mod(`n',6) {

local q 0

di `++n'

 

Use an infinite while loop and do the test with an ''[https://www.stata.com/help.cgi?if if]''' at the end of the loop.

 

while 1 {

di `++n'

if mod(`n',6)==0 continue, break

 

=== Mata ===

Mata has a '''[https://www.stata.com/help.cgi?m2_do do/while]''' loop:

 

n=0

do {

printf("%f\n",++n)

} while (mod(n,6))

 

=={{header|Suneido}}==

do

{

Print(++val)

 

{{out}}

=={{header|Swift}}==

{{works with|Swift|3.x+}}

repeat {

val += 1

print(val)

{{works with|Swift|2.x}}

repeat {

val++

print(val)

{{works with|Swift|1.x}}

do {

val++

println(val)

 

=={{header|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 -> #

$val -> \(<?($ mod 6 <~=0>)> $!\) -> #

end doWhile

 

=={{header|Tcl}}==

Tcl does not have a built-in <code>do...while</code> construct. This example demonstrates the ease of creating new looping contructs in plain Tcl. <code>do</code> procedure taken from [http://wiki.tcl.tk/3603 Tcler's wiki]

if {$keyword eq "while"} {

set expression "!($expression)"

 

set i 0

{{tcllib|control}}

set i 0; control::do {puts [incr i]} while {$i % 6 != 0}

 

Mind you, it is also normal to write this task using a normal <code>while</code> as:

while true {

puts [incr i]

if {$i % 6 == 0} break

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

var=0

IF (rest==0) EXIT

ENDLOOP

{{out}}

<pre>

{{works with|pdksh}}

{{works with|zsh}}

while true; do

echo $((++val))

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

 

{{works with|Bourne Shell}}

while true; do

val=`expr $val + 1`

echo $val

expr $val % 6 = 0 >/dev/null && break

 

{{works with|zsh}}

print $val

(( val % 6 )) || break

 

=={{header|Vala}}==

 

do {

}

while ( a % 6 != 0);

 

=={{header|Vedit macro language}}==

do {

#1++

Num_Type(#1)

 

=={{header|Verbexx}}==

 

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

n++;

@SAY n;

 

=={{header|Verilog}}==

module main;

integer i;

end

endmodule

 

{{trans|go}}

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

mut value := 0

for {

}

}

{{out}}

<pre>1

6</pre>

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

mut value := 0

for ok := true; ok; ok = value%6 != 0 {

println(value)

}

 

{{out}}

Same as before.

</pre>

// do-while loop 1

mut n1 := 2

}

println(n3) // prt 8

 

=={{header|X86 Assembly}}==

{{works with|nasm}}

{{works with|windows}}

extern _printf

 

xor eax, eax

ret

 

=={{header|XPL0}}==

int V;

[V:= 0;

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

until rem(V/6) = 0;

 

=={{header|Yorick}}==

do {

val++;

write, val;

 

=={{header|zkl}}==

{{trans|Yorick}}

do {

val+=1;

val.print(" ");

{{out}}

<pre>

 

=={{header|Zig}}==

 

pub fn main() !void {

try std.io.getStdOut().writer().print("{d}\n", .{a});

}

 

{{omit from|GUISS}}