## C++


```cpp
int val = 0;
do{
   val++;
   std::cout << val << std::endl;
}while(val % 6 != 0);

C#

int a = 0;

do
{
    a += 1;
    Console.WriteLine(a);
} while (a % 6 != 0);

Chapel

var val = 0;
do {
        val += 1;
        writeln(val);
} while val % 6 > 0;

Clipper

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

COBOL

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

       IDENTIFICATION DIVISION.
       PROGRAM-ID. loop-do-while.

       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01  i PIC 99 VALUE 0.

       PROCEDURE DIVISION.
           PERFORM WITH TEST AFTER UNTIL FUNCTION MOD(i, 6) = 0
               ADD 1 TO i
               DISPLAY i
           END-PERFORM

           GOBACK
           .

Coco

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

v = 0
do
   console.log ++v
while v % 6

CoffeeScript

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

val = 0
loop
  console.log ++val
  break unless val % 6

ColdFusion

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

Common Lisp

(let ((val 0))
  (loop do
        (incf val)
        (print val)
        while (/= 0 (mod val 6))))

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

(loop with val = 0
      do (print (incf val))
      until (= 0 (mod val 6)))

Clojure

(loop [i 0]
  (let [i* (inc i)]
    (println i*)
    (when-not (zero? (mod i* 6))
      (recur i*))))

D

import std.stdio;

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

{{out}}

1 2 3 4 5 6

dc

{{trans|bc}}

0 si		[i = 0]sz
[2Q]sA		[A = code to break loop]sz
[
 li 1 + p	[print it = i + 1]sz
 d si		[i = it, leave it on stack]sz
 6 % 0 =A	[call A if 0 == it % 6]sz
 0 0 =B		[continue loop]sz
]sB 0 0 =B

Delphi

program Loop;

{$APPTYPE CONSOLE}

var
  I: Integer;

begin
  I:= 0;
  repeat
    Inc(I);
    Write(I:2);
  until I mod 6 = 0;
  Writeln;
  Readln;
end.

Dragon

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

DUP

DUP only provides a while loop in the form of [condition][block]#, where the block is executed in a loop as long as the condition is nonzero/true. A do-while loop is technically nothing more than executing the block once before running an ordinary while loop, so we simply define an operator or function that contains the block (comments in curly braces):

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

and put the defined block in front of the while loop, and inside the while loop itself:

If the block was defined as an operator, the whole program would look like this (comments in curly braces):

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

And if the block is defined as a named function:

[1+$.' ,]a:
0 a;![$6/%][a;!]#

Result:

## DWScript


```Delphi

var i := 0;

repeat
   Inc(i);
   PrintLn(i);
until i mod 6 = 0;

'''Bold text'''

E

E does not have an official do-while construct, but the primitive which loops are built out of (which calls a function which returns a boolean indicating whether it should be called again) can be used to construct a do-while.

var x := 0
__loop(fn {
    x += 1
    println(x)
    x % 6 != 0   # this is the return value of the function
})

Ela

open monad io

loop n | n % 6 == 0 = do return ()
       | else = do
          putStrLn (show n)
          loop (n+1)

_ = loop 10 ::: IO

Elixir

defmodule Loops do
  def do_while(n) do
    n1 = n + 1
    IO.puts n1
    if rem(n1, 6) == 0, do: :ok,
                      else: do_while(n1)
  end
end

Loops.do_while(0)

Emacs Lisp

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

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

Erlang

do() ->
	do(0).

do(0) ->
	io:fwrite( "0 " ),
        do( 1 );
do(N) when N rem 6 =:= 0 ->
	io:format("~w~n", [N]);
do(N) ->
	io:fwrite( "~p ", [N] ),
	do(N+1).

ERRE

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

Euphoria

{{works with|Open Euphoria}}

include std/console.e
include std/math.e

atom x = 0

loop do
	x += 1
	?x
	until(mod(x,6)) = 0
end loop

if getc(0) then end if

F#

If you must have a loop then this is acceptable F#

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

But I prefer this way:

Seq.initInfinite id |> Seq.takeWhile(fun n->n=0 || n%6>0) |> Seq.iter (fun n-> printfn "%d" n)

Either produces: {{out}}

0
1
2
3
4
5

Factor

0 [ dup 6 mod 0 = not ] [ [ . ] [ 1 + ] bi ] do while drop

Fantom

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

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

Forth

: do-until
  0
  begin 1+
        dup .
        dup 6 mod 0=
  until
  drop ;

Fortran

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

INTEGER :: i = 0
DO
  i = i + 1
  WRITE(*, *) i
  IF (MOD(i, 6) == 0) EXIT
END DO

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

      PROGRAM DOWHILE
C Initialize modulus and value.
        INTEGER MODLUS, IVALUE
        PARAMETER (MODLUS = 6)
        IVALUE = 0

C FORTRAN 77 has no do-while structure -- not semantically. It is not
C difficult to simulate it using GOTO, however:
   10   CONTINUE
          IVALUE = IVALUE + 1
          WRITE (*,*) IVALUE
        IF (.NOT. (MOD(IVALUE, MODLUS) .EQ. 0)) GOTO 10

        STOP
      END

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

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

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

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

Fortress

Due to the way that Fortress works, you have to use a label to escape a loop upon a specified condition being met. There is no traditional break equivalent.

component loops_do_while
  export Executable

  var x:ZZ32 = 0
  run() = label loop
    while true do
      x += 1
      println(x)

      if (x MOD 6) = 0
      then exit loop
      end
    end
  end loop
end

{{out}}

1
2
3
4
5
6

FreeBASIC

' FB 1.05. 0 Win64

Dim i As Integer = 0
Do
  i += 1
  Print i; " ";
Loop While i Mod 6 <> 0
Print
Sleep

{{out}}

 1  2  3  4  5  6

Frink

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

FutureBasic

include "ConsoleWindow"

dim as long i

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

Output:

 1
 2
 3
 4
 5
 6

Gambas

'''[https://gambas-playground.proko.eu/?gist=57e91eab60baf7e39df9b6d16a0deddd Click this link to run this code]'''

Public Sub Main()
Dim siCount As Short

Repeat
  Inc siCount
  Print siCount;;
Until siCount Mod 6 = 0

End

Output:

1 2 3 4 5 6

GAP

n := 0;
repeat
    n := n + 1;
    Print(n, "\n");
until RemInt(n, 6) = 0;

Go

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

package main

import "fmt"

func main() {
	var value int
	for {
		value++
		fmt.Println(value)
                if value%6 != 0 {
                        break
                }
	}
}

{{out}}

1
2
3
4
5
6

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

package main

import "fmt"

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

{{out}}

Same as before.

GML

i = 0
do
    {
    i += 1
    show_message(string(i))
    }
until (i mod 6 = 0)

Groovy

Groovy does not have a bottom-checking loop construct! So use an "infinite" while loop with a conditional break as the last statement

def i = 0
while (true) {
    i++
    println i
    if ( i % 6 == 0) break
}

{{out}}

1
2
3
4
5
6

=={{header|GW-BASIC}}== GW-BASIC does not have a do .. while construct. Equivalent using WHILE: {{works with|PC-BASIC|any}}

10 LET I% = 0
20 ' first iteration - before the WHILE
30 PRINT I%
40 LET I% = I% + 1
50 WHILE I% MOD 6 <> 0
60  PRINT I%
70  LET I% = I% + 1
80 WEND

Equivalent using GOTO: {{works with|PC-BASIC|any}}

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

Harbour

LOCAL n := 0

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

Haskell

import Data.List
import Control.Monad
import Control.Arrow

doWhile p f n = (n:) $ takeWhile p $ unfoldr (Just.(id &&& f)) $ succ n

Example executed in GHCi:

*Main> mapM_ print $ doWhile ((/=0).(`mod`6)) succ 0
0
1
2
3
4
5

The standard Prelude also includes, without further import or definition, an '''until''' function, which takes three arguments – a predicate function, a transformation function, and an initial value.

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

{{Out}}

0
1
2
3
4
5
6

With mutable references

Using iterateWhile from monad-loops package

import Data.IORef
import Control.Monad.Loops

main = do
  x <- newIORef 0;
  iterateWhile (\val -> val `mod` 6 /= 0 ) $ do
    modifyIORef x (+1)
    val <- readIORef x
    print val
    return val

HolyC

U8 i = 0;
do {
   i++;
   Print("%d\n", i);
} while (i % 6 != 0);

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

procedure main()

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

J

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

,. ([^:(0=6|])>:)^:a: 0

J does support loops for those times they can't be avoided (just like many languages support gotos for those time they can't be avoided).

3 : 0 ] 0

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

         whilst. 0 ~: 6 | y do.
             y 1!:2 ]2
             y =. y+1
         end.

        i.0 0
   )

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

Java

int val = 0;
do{
   val++;
   System.out.println(val);
}while(val % 6 != 0);

JavaScript

Javascript: Imperative

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

Javascript: Functional

=ES5=

In a functional idiom of JavaScript we cannot use a Do While '''statement''', as it returns no value and is not a composable expression. We can, however achieve the same effect with a composable doWhile '''function''', which takes three arguments, and returns the output series as a value.

:#An initial value, :#a Do function which transforms that value repetitively, corresponding to the body of the loop, :#and a conditional While function.

function doWhile(varValue, fnBody, fnTest) {
  'use strict';
  var d = fnBody(varValue); // a transformed value

  return fnTest(d) ? [d].concat(
    doWhile(d, fnBody, fnTest)
  ) : [d];
}

console.log(
  doWhile(0,           // initial value
    function (x) {     // Do body, returning transformed value
      return x + 1;
    },
    function (x) {     // While condition
      return x % 6;
    }
  ).join('\n')
);

Output:

1
2
3
4
5
6

Alternatively, if we assume instead that the unstated problem was not to produce repetitive computation, but to derive the '''membership of a set''' we could interpret the task as a request for a JavaScript implementation of the '''takeWhile''' function – a familiar staple of functional list processing.

So, for example, something like:

function range(m, n) {
  'use strict';
  return Array.apply(null, Array(n - m + 1)).map(
    function (x, i) {
      return m + i;
    }
  );
}

function takeWhile(lst, fnTest) {
 'use strict';
  var varHead = lst.length ? lst[0] : null;

  return varHead ? (
    fnTest(varHead) ? [varHead].concat(
      takeWhile(lst.slice(1), fnTest)
    ) : []
  ) : []
}

console.log(
  takeWhile(
    range(1, 100),
    function (x) {
      return x % 6;
    }
  ).join('\n')
);

Output:

1
2
3
4
5

=ES6=

A process or value of this kind might be better expressed (in functionally composed JavaScript) with an '''unfold''' or '''until''' function, returning a list.

(() => {
    'use strict';

    // unfoldr :: (b -> Maybe (a, b)) -> b -> [a]
    function unfoldr(mf, v) {
        for (var lst = [], a = v, m;
            (m = mf(a)) && m.valid;) {
            lst.push(m.value), a = m.new;
        }
        return lst;
    }

    // until :: (a -> Bool) -> (a -> a) -> a -> a
    function until(p, f, x) {
        let v = x;
        while(!p(v)) v = f(v);
        return v;
    }

    let result1 = unfoldr(
        x => {
            return {
                value: x,
                valid: (x % 6) !== 0,
                new: x + 1
            }
        },
        1
    );

    let result2 = until(
        m => (m.n % 6) === 0,
        m => {
            return {
                n : m.n + 1,
                xs : m.xs.concat(m.n)
            };
        },
        {
            n: 1,
            xs: []
        }
    ).xs;

    return [result1, result2];
})();

[[1, 2, 3, 4, 5], [1, 2, 3, 4, 5]]

ES6 is a superset of Javascript so the Javascript and ES5 solution is valid. An example of a do-while loop in a generator follows that produces correct output:

// generator with the do while loop
function* getValue(stop) {
    var i = 0;
    do {
        yield ++i;
    } while (i % stop != 0);
}

// function to print the value and invoke next
function printVal(g, v) {
    if (!v.done) {
        console.log(v.value);
        setImmediate(printVal, g, g.next());
    }
}

(() => {
    var gen = getValue(6);
    printVal(gen, gen.next());
})();

1
2
3
4
5
6

jq

{{works with|jq|1.4}} In jq 1.4, the "recurse" built-in always emits the input value, and so to accomplish the task specified here, we shall define a control structure: "do_while(action; condition)" as follows:

# Perform the action, then check the condition, etc
def do_while( action; condition ):
  def w: action | if (condition | not) then empty else ., w end;
  w;

'''The task:'''

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

{{out}} 1 2 3 4 5

Julia

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

julia> i = 0
0

julia> while true
           println(i)
           i += 1
           i % 6 == 0 && break
       end
0
1
2
3
4
5

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

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

julia> @eval macro $(:do)(block, when::Symbol, condition)
           when ≠ :when && error("@do expected `when` got `$s`")
           quote
               let
                   $block
                   while $condition
                       $block
                   end
               end
           end |> esc
       end
@do (macro with 1 method)

julia> i = 0
0

julia> @do begin
           @show i
           i += 1
       end when i % 6 ≠ 0
i = 0
i = 1
i = 2
i = 3
i = 4
i = 5

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

julia> macro do_while(condition, block)
           quote
               let
                   $block
                   while $condition
                       $block
                   end
               end
           end |> esc
       end
@do_while (macro with 1 method)

julia> i = 0
0

julia> @do_while i % 6 ≠ 0 begin
           @show i
           i += 1
       end
i = 0
i = 1
i = 2
i = 3
i = 4
i = 5

Kotlin

// version 1.0.6

fun main(args: Array<String>) {
    var value = 0
    do {
        println(++value)
    }
    while (value % 6 != 0)
}

{{out}}

1
2
3
4
5
6

LabVIEW

{{VI snippet}}
[[File:LabVIEW_Loops_Do-while.png]]

Lasso

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

Liberty BASIC

a = 0
do
  a =a +1
  print a
loop until ( a mod 6) = 0

Lingo

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

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

Lisaac

+ val : INTEGER;
{
  val := val + 1;
  val.print;
  '\n'.print;
  val % 6 != 0
}.while_do { };

LiveCode

repeat while n mod 6 is not 0 or n is 0
    add 1 to n
    put n
end repeat

Lua

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

i=0
repeat
  i=i+1
  print(i)
until i%6 == 0

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

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

{{out}}

1
2
3
4
5
6
1
2
3
4
5
6

Maple

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

Mathematica

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

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

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

   a=0;
   while (1)
      a = a+1;
      disp(a);
   if (~mod(a,6)) break; end;
   end;

Maxima

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

MAXScript

a = 0
do
(
    print a
    a += 1
)
while mod a 6 != 0

Metafont

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

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

Microsoft Small Basic

Microsoft Small Basic does not have a do .. while construct. Equivalent using While:

i = 0
' first iteration - before the While
TextWindow.WriteLine(i)
i = i + 1
While Math.Remainder(i, 6) <> 0
  TextWindow.WriteLine(i)
  i = i + 1
EndWhile

Equivalent using Goto:

i = 0
loopStart:
TextWindow.WriteLine(i)
i = i + 1
If Math.Remainder(i, 6) <> 0 Then
  Goto loopStart
EndIf

MIPS Assembly

	.text
main:	li 	$s0, 0		# start at 0.
	li	$s1, 6
loop:	addi	$s0, $s0, 1	# add 1 to $s0
	div	$s0, $s1	# divide $s0 by $s1. Result is in the multiplication/division registers
	mfhi	$s3		# copy the remainder from the higher multiplication register to $s3
	move	$a0, $s0	# variable must be in $a0 to print
	li	$v0, 1		# 1 must be in $v0 to tell the assembler to print an integer
	syscall			# print the integer in $a0
	bnez	$s3, loop	# if $s3 is not 0, jump to loop

	li	$v0, 10
	syscall			# syscall to end the program

=={{header|MK-61/52}}== 0 П4 КИП4 ИП4 6 / {x} x=0 02 С/П

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

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

=={{header|Modula-3}}== This is very similar to the [[Modula-2]] code above.

REPEAT
  i := i + 1;
  IO.Put(Fmt.Int(i));
UNTIL i MOD 6 = 0;

Monicelli

The do-while loop is the only kind of loop available in Monicelli

stuzzica
    ...     # loop body
e brematura anche, se <expr> # exit if <expr> is false

MUMPS

{{works with|Caché ObjectScript}}

DOWHILELOOP
    set val = 0
    do {
        set val = val + 1
        write val,!
    } while ((val # 6) '= 0)

    quit

{{out}}

SAMPLES>do ^DOWHILELOOP
1
2
3
4
5
6

Neko

/**
 Loops/Do-while in Neko
 Tectonics:
   nekoc loops-do-while.neko
   neko loops-do-while
*/

var index = 0;
do {
  index += 1;
  $print(index, "\n");
} while (index % 6) != 0

{{out}}

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

Nemerle

mutable x = 0;
do
{
    x++;
    WriteLine($"$x");
} while (x % 6 != 0)

NetRexx

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

/* NetRexx */
options replace format comments java crossref savelog symbols nobinary

  say
  say 'Loops/Do-while'

  i_ = 0
  loop until i_ // 6 = 0
    i_ = i_ + 1
    say i_
    end

NewLISP

(let ((i 0))
  (do-until (= 0 (% i 6))
	    (println (++ i))))

Nim

Nim does not have a do-while loop, but it's easy to write your own:

template doWhile(a, b: untyped): untyped =
  b
  while a:
    b

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

=={{header|Oberon-2}}== Works with oo2c Version 2

MODULE LoopDoWhile;
IMPORT
  Out;

PROCEDURE Do();
VAR
  i: INTEGER;
BEGIN
  i := 0;
  REPEAT
    Out.LongInt(i,0);Out.Ln;
    INC(i)
  UNTIL (i MOD 6 = 0);
END Do;

BEGIN
  Do
END LoopDoWhile.

OCaml

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

let rec loop i =
  let i = succ i in
  Printf.printf "%d\n" i;
  if i mod 6 <> 0 then
    loop i
  in
  loop 0

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

let do_while f p =
  let rec loop() =
    f();
    if p() then loop()
  in
  loop()
(** val do_while : (unit -> 'a) -> (unit -> bool) -> unit *)

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

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

let do_while f p ~init =
  let rec loop v =
    let v = f v in
    if p v then loop v
  in
  loop init

do_while (fun v ->
            let v = succ v in
            Printf.printf "%d\n" v;
            (v))
         (fun v -> v mod 6 <> 0)
         ~init:0

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

let v = ref 0
exception Exit_loop
try while true do
  incr v;
  Printf.printf "%d\n" !v;
  if not(!v mod 6 <> 0) then
    raise Exit_loop;
done
with Exit_loop -> ()

Objeck

i := 0;
do {
   i += 1;
   i->PrintLine();
}
while (i % 6 <> 0);

Octave

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

val = 0;
do
  val++;
  disp(val)
until( mod(val, 6) == 0 )

Oforth

 ] drop

OpenEdge/Progress

DEFINE VARIABLE ii AS INTEGER.

DO WHILE ii MODULO 6 <> 0 OR ii = 0:
   ii = ii + 1.
   MESSAGE ii VIEW-AS ALERT-BOX.
END.

Oz

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

declare
  I = {NewCell 0}
in
  for until:@I mod 6 == 0 do
     I := @I + 1
     {Show @I}
  end

PARI/GP

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

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

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

x = 0;
while (print(x++) || x % 6, )

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

Pascal

program countto6(output);

var
  i: integer;

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

Perl

my $val = 0;
do {
   $val++;
   print "$val\n";
} while ($val % 6);

do ... until (''condition'') is equivalent to do ... while (not ''condition'').

my $val = 0;
do {
   $val++;
   print "$val\n";
} until ($val % 6 == 0);

Perl 6

{{works with|Rakudo Star|2010.08}}

my $val = 0;
repeat {
    say ++$val;
} while $val % 6;

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

my $val = 0;
repeat {
    say ++$val;
} until $val %% 6;

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

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

my $val = 0;
repeat while $val % 6 {
    say ++$val;
}

Phix

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

PHL

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

PHP

$val = 0;
do {
   $val++;
   print "$val\n";
} while ($val % 6 != 0);

PicoLisp

Literally:

(let Val 0
   (loop
      (println (inc 'Val))
      (T (=0 (% Val 6))) ) )

Shorter:

(let Val 0
   (until (=0 (% (println (inc 'Val)) 6))) )

or:

(for (Val 0  (n0 (% (println (inc 'Val)) 6))))

Pike

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

PL/I

dcl value fixed bin (31) init (0);
do forever;
  value = value + 1;

  if mod(value, 6) = 0 then
    leave;

  put list (value);
end;

or shorter:

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

{{out}}

             1
             2
             3
             4
             5
             6

Pop11

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

PowerShell

$n = 0
do {
    $n++
    $n
} while ($n % 6 -ne 0)

Prolog

% initial condition
do(0):- write(0),nl,do(1).

% control condition
do(V):- 0 is mod(V,6), !, fail.

% loop
do(V) :-
    write(V),nl,
    Y is V + 1,
    do(Y).

wloop :-
   do(0).

PureBasic

{{works with|PureBasic|4.41}}

x=0
Repeat
  x+1
  Debug x
Until x%6=0

Python

Python doesn't have a do-while loop.

val = 0
while True:
   val +=1
   print val
   if val % 6 == 0: break

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

val = 1
print val
while val % 6 != 0:
   val += 1
   print val

R

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

Racket

Idiomatic Racket code is functional:

#lang racket
(let loop ([n 0])
  (let ([n (add1 n)])
    (displayln n)
    (unless (zero? (modulo n 6)) (loop n))))

But an imperative version is easy to do too:

#lang racket
(define n 0)
(let loop ()
  (set! n (add1 n))
  (displayln n)
  (unless (zero? (modulo n 6)) (loop)))

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
]

{{out}}

1
2
3
4
5
6

Red

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

{{out}}

i: 0
i: 1
i: 2
i: 3
i: 4
i: 5

REXX

In the '''DO UNTIL''' construct, the expression is evaluated at the end of the '''DO''' loop,

even though it is written at the beginning.

This insures that the '''DO UNTIL''' loop will execute at least once (as coded below).

In contrast, a '''DO WHILE''' construct, the expression would be evaluated at the beginning of the '''DO''' loop, and

may cause the '''DO WHILE''' loop to not execute at all.

This necessitates the use of '''DO UNTIL''' instead of '''DO WHILE'''.

version 1

/*REXX program demonstrates a     DO  UNTIL     construction.           */
v=0
          do  until  v//6==0           /*REXX   //   is the ÷ remainder.*/
          v=v+1
          say v
          end
                                       /*stick a fork in it, we're done.*/

{{out}}

1
2
3
4
5
6

version 2

/*REXX program demonstrates a     DO  UNTIL     construction.           */

          do v=1  until  v//6==0       /*REXX   //   is the ÷ remainder.*/
          say v
          end
                                       /*stick a fork in it, we're done.*/

'''output''' is the same as the 1^st version.

Ring

   n = 0
   While True
      n++  See n + nl
      if n % 6 = 0  exit ok
   end

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.

{| class="wikitable" ! while ! until |- |

val = 0
begin
   val += 1
   puts val
end while val % 6 != 0

|

val = 0
begin
   val += 1
   puts val
end until val % 6 == 0

|}

During November 2005, Yukihiro Matsumoto, the creator of Ruby, [http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/6741 regretted this loop feature] and [http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/6745 suggested using Kernel#loop].

{| class="wikitable" ! break unless ! break if |- |

val = 0
loop do
   val += 1
   puts val
   break unless val %6 != 0
end

|

val = 0
loop do
   val += 1
   puts val
   break if val %6 == 0
end

|}

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

Rust

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

let mut x = 0;

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

    if x % 6 == 0 { break; }
}

Salmon

variable x := 0;
do
  {
    ++x;
    x!
  }
while (x % 6 != 0);

SAS

/* using DO UNTIL so that the loop executes at least once */
data _null_;
n=0;
do until(mod(n,6)=0);
    n+1;
    put n;
end;
run;

Sather

{{trans|C}}

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

Scala

{{libheader|Scala}}

Imperative

  {
    var (x, l) = (0, List[Int]())
    do {
      x += 1
      l :+= x // A new copy of this list with List(x) appended.
    } while (x % 6 != 0)
    l
  }.foreach(println(_))

Tail recursive

	def loop(iter: Int, cond: (Int) => Boolean, accu: List[Int]): List[Int] = {
	  val succ = iter + 1
	  val temp = accu :+ succ
	  if (cond(succ)) loop(succ, cond, temp) else temp
	}
	println(loop(0, (_ % 6 != 0), Nil))

Stream

  def loop(i: Int, cond: (Int) => Boolean): Stream[Int] = {
    val succ = i + 1;
    succ #:: (if (cond(succ)) loop(succ, cond) else Stream.empty)
  }
  loop(0, (_ % 6 != 0)).foreach(println(_))

Scheme

(let loop ((i 1))
  (display i)
  (if (positive? (modulo i 6))
      (loop (+ i 1))))

Scilab

{{works with|Scilab|5.5.1}} v=0 while %T v=v+1 printf("%2d ",v) if modulo(v,6)==0 then break; end end printf("\n")

{{out}}

```txt
 1  2  3  4  5  6

Seed7

$ include "seed7_05.s7i";

const proc: main is func
  local
    var integer: number is 0;
  begin
    repeat
      incr(number);
      writeln(number)
    until number rem 6 = 0
  end func;

Sidef

var value = 0;
do {
    say ++value;
} while (value % 6);

Slate

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

Smalltalk

{{works with|Smalltalk/X}} {{works with|VisualWorks Smalltalk}}

|val|
val := 0.
[
  val := val + 1.
  val displayNl.
] doWhile: [ (val rem: 6) ~= 0 ]

|val|
val := 0.
[
  val := val + 1.
  val displayNl.
] doUntil: [ (val rem: 6) == 0 ]

{{works with|GNU Smalltalk}} To simulate the do-while construct, we can use the whileTrue: method of a block with a void while block.

|val|
val := 0.
[
  val := val + 1.
  val displayNl.
  (val rem: 6) ~= 0
] whileTrue: [ ]

Sparkling

var i = 0;
do {
    print(++i);
} while (i % 6 != 0);

Spin

{{works with|BST/BSTC}} {{works with|FastSpin/FlexSpin}} {{works with|HomeSpun}} {{works with|OpenSpin}}

con
  _clkmode = xtal1 + pll16x
  _clkfreq = 80_000_000

obj
  ser : "FullDuplexSerial.spin"

pub main | n
  ser.start(31, 30, 0, 115200)

  n := 0
  repeat
    n += 1
    ser.dec(n)
    ser.tx(32)
  while n // 6

  waitcnt(_clkfreq + cnt)
  ser.stop
  cogstop(0)

{{out}}

1 2 3 4 5 6

SPL

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

{{out}}

1
2
3
4
5
6

Stata

Stata macro language has no do/while loop, but it's possible to achieve this with a '''[https://www.stata.com/help.cgi?while while]''' loop.

Use a flag to force the first loop. It's changed in the loop so that it will have no effect after the first loop.

local n 0
local q 1
while `q' | mod(`n',6) {
	local q 0
	di `++n'
}

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

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

Mata

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

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

## Suneido


```Suneido
val = 0
do
    {
    Print(++val)
    } while (val % 6 isnt 0)

{{out}}

1
2
3
4
5
6

Swift

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

var val = 0
repeat {
  val += 1
  print(val)
} while val % 6 != 0

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

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

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

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

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 [http://wiki.tcl.tk/3603 Tcler's wiki]

proc do {body keyword expression} {
    if {$keyword eq "while"} {
       set expression "!($expression)"
    } elseif {$keyword ne "until"} {
       return -code error "unknown keyword \"$keyword\": must be until or while"
    }
    set condition [list expr $expression]
    while 1 {
       uplevel 1 $body
       if {[uplevel 1 $condition]} {
          break
       }
    }
    return
}

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

{{tcllib|control}}

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

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

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

TUSCRIPT

$$ MODE TUSCRIPT
var=0
LOOP
var=var+1, rest=var%6
PRINT var
IF (rest==0) EXIT
ENDLOOP

{{out}}

1
2
3
4
5
6

UNIX Shell

{{works with|bash}} {{works with|pdksh}} {{works with|zsh}}

val=0
while true; do
  echo $((++val))
  [ $((val%6)) -eq 0 ] && break
done

{{works with|Bourne Shell}}

val=0
while true; do
  val=`expr $val + 1`
  echo $val
  expr $val % 6 = 0 >/dev/null && break
done

{{works with|zsh}}

for ((val=1;;val++)) {
  print $val
  (( val % 6 )) || break
}

VBA

Public Sub LoopDoWhile()
    Dim value As Integer
    value = 0
    Do
        value = value + 1
        Debug.Print value;
    Loop While value Mod 6 <> 0
End Sub

{{out}}

 1  2  3  4  5  6

Vedit macro language

#1 = 0
do {
    #1++
    Num_Type(#1)
} while (#1 % 6 != 0);

Verbexx

//  Basic @LOOP until: verb

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

Visual Basic .NET

Dim i = 0
Do
    i += 1
    Console.WriteLine(i)
Loop Until i Mod 6 = 0

XPL0

code CrLf=9, IntOut=11;
int V;
[V:= 0;
repeat  V:= V+1;
        IntOut(0, V);  CrLf(0);
until   rem(V/6) = 0;
]

Yorick

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

zkl

{{trans|Yorick}}

val := 0;
do {
    val+=1;
    val.print(" ");
} while(val % 6 != 0);

{{out}}

1 2 3 4 5 6

{{omit from|GUISS}} {{omit from|Commodore BASIC}}