Loops/Do-while: Difference between revisions

 

=={{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|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|Aime}}==

 

a = 0;

o_integer(a);

o_byte('\n');

 

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

print(value);

# WHILE # value MOD 6 /= 0 DO

SKIP

 

=={{header|AmigaE}}==

DEF i = 0

REPEAT

WriteF('\d\n', i)

UNTIL Mod(i, 6) = 0

=={{header|AutoHotkey}}==

output = %output%`n%A_Index%

 

=={{header|AWK}}==

val = 0

do {

print val

} while( val % 6 != 0)

 

=={{header|BASIC}}==

do

 

REPEAT

a = a + 1

PRINT a

 

=={{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++}}==

do{

val++;

 

 

 

do

{

 

=={{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 can set up temporary values, and incf returns a value, so it's also possible to do

 

do (print (incf val))

 

 

=={{header|D}}==

 

void main() {

write(val, " ");

} while (val % 6 != 0);

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

var i := 0;

 

PrintLn(i);

until i mod 6 = 0;

 

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

 

 

 

 

=={{header|Erlang}}==

 

do() ->

do(N) when N rem 6 =:= 0 ->

io:format("~w~n", [N]);

do(N) ->

do(N+1).

 

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

 

 

 

2

3

4

5

 

=={{header|GML}}==

do

{

show_message(string(i))

}

 

=={{header|Groovy}}==

while (true) {

i++

println i

 

<pre>1

2

6</pre>

 

 

import Control.Monad

import Control.Arrow

 

Example executed in GHCi:

0

1

3

4

 

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

do {

print(++val);

 

 

=={{header|LabVIEW}}==

{{VI snippet}}<br/>[[File:LabVIEW_Loops_Do-while.png]]

 

=={{header|Lisaac}}==

{

val := val + 1;

'\n'.print;

val % 6 != 0

 

=={{header|Lua}}==

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

 

i=0

repeat

print(i)

until i%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|Modula-2}}==

IMPORT InOut;

 

 

BEGIN

REPEAT

InOut.WriteInt(i, 1);

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

 

 

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

 

=={{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|PHP}}==

do {

$val++;

print "$val\n";

 

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

 

=={{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|R}}==

repeat

{

print(i)

if(i %% 6 == 0) break

 

=={{header|REBOL}}==

Title: "Loop/While"

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

]

 

0 = mod value 6

 

<pre>1

2

5

6</pre>

 

=={{header|REXX}}==

<br><br>

 

 

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

|}

 

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

 

=={{header|Salmon}}==

do

{

x!

}

 

=={{header|SAS}}==

data _null_;

n=0;

do until(mod(n,6)=0);

end;

 

=={{header|Sather}}==

{{trans|C}}

main is

val ::= 0;

end;

end;

 

=={{header|Scala}}==

 

=={{header|Scheme}}==

(display i)

(if (positive? (modulo i 6))

 

=={{header|Seed7}}==

 

const proc: main is func

writeln(number)

until number rem 6 = 0

 

=={{header|Slate}}==

val: 0.

[val: val + 1.

print: val.

val \\ 6 ~= 0] whileTrue

 

=={{header|Smalltalk}}==

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

 

=={{header|Suneido}}==

do

{

Print(++val)

 

2

3

4

5

 

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

<pre>

1

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

 

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

do {

#1++

Num_Type(#1)

 

 

=={{header|XPL0}}==

int V;

[V:= 0;

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

until rem(V/6) = 0;

 

=={{header|Yorick}}==

do {

val++;

write, val;

 

{{omit from|GUISS}}