VK>repeatLoop(() => { System.Console.WriteLine($"i=$i"); i++ }).until(() => i >= 4);
VK>

object LoopSpeed2 extends Application {
  def meter( name: String, action: => unit ) {
    val start = java.util.Calendar.getInstance.getTimeInMillis
    action
    val finish = java.util.Calendar.getInstance.getTimeInMillis

    Console.println( name + ": " + (finish - start) )
  }

  class Repeater( command: => unit ) {
    def until( condition: => boolean ): unit = {
      do command while( !condition )
    }
  }

  def repeatLoop( action: => unit ) = new Repeater( action )

  val LIMIT = 100000000

  meter( "Simple do-while",
    { var i = 0; do { i = i + 1 } while( i < LIMIT ); } )
  meter( "Repeat until",
    { var i = 0; repeatLoop { i = i + 1 } until( i >= LIMIT ); } )
}

Simple do-while: 2313
Repeat until: 4359

public class LoopSpeed2$Repeater implements ScalaObject
{
    private Function0 command;

    public void until(Function0 condition)
    {
        do
        {
            command.apply();                                                           // (*)
        } while(!ScalaRunTime$.MODULE$.booleanValue((BoxedBoolean)condition.apply())); // (**)
    }

    public int $tag() { return scala.ScalaObject.class.$tag(this); }

    public LoopSpeed2$Repeater(Function0 command) { this.command = command; super(); }
}

public LoopSpeed2.Repeater repeatLoop(Function0 action)
{
    return new LoopSpeed2.Repeater(action);
}
  ...
//meter( "Repeat until",
//  { var i = 0; repeatLoop { i = i + 1 } until( i >= LIMIT ); } )
LoopSpeed2$.MODULE$.repeatLoop(new _anonfun__cls2(i$0)).until(new _anonfun__cls3(i$0));

E>object LoopSpeed2 extends Application {
E>  def meter( name: String, action: => unit ) {
E>    val start = java.util.Calendar.getInstance.getTimeInMillis
E>    action
E>    val finish = java.util.Calendar.getInstance.getTimeInMillis

E>    Console.println( name + ": " + (finish - start) )
E>  }

E>  class Repeater( command: => unit ) {
E>    def until( condition: => boolean ): unit = {
E>      do command while( !condition )
E>    }
E>  }

E>  def repeatLoop( action: => unit ) = new Repeater( action )

E>  val LIMIT = 100000000

E>  meter( "Simple do-while",
E>    { var i = 0; do { i = i + 1 } while( i < LIMIT ); } )
E>  meter( "Repeat until",
E>    { var i = 0; repeatLoop { i = i + 1 } until( i >= LIMIT ); } )
E>}
E>

E>Simple do-while: 2313
E>Repeat until: 4359
E>

  macro dowhile (cond, body) 
  syntax ("do", body, "while", "(", cond, ")") 
  {
    def loop = Nemerle.Macros.Symbol (Util.tmpname ("do_while_"));

    <[
      ($("_N_break" : global) : {
        def $(loop : name) () {
          $("_N_continue" : global) : {
            $body
          }
          when ($cond) $(loop : name) ();
        }
        $(loop : name) ()
      })
    ]>
  }

using System.Diagnostics;

[Record]
class repeatLoop
{
    action : void->void;
    public until(condition : void->bool) : void
    {
            do action() while(condition());
    }
}

def meter( name, action ) 
{
  def stopwatch = Stopwatch();
  
  stopwatch.Start();
  action();
  stopwatch.Stop();

  System.Console.WriteLine( $"$name : $(stopwatch.ElapsedMilliseconds) ms elapsed" );
}

def LIMIT = 100000000;

meter( "Macro do-while",()=>{ mutable i = 0; do { i++; } while( i < LIMIT ); } );
meter( "Repeat until",()=>{mutable i = 0; repeatLoop(()=> i++ ).until(()=> i < LIMIT)} );

import std.stdio, std.perf;

class Repeater
{
  void delegate() _command;
  
  public this( void delegate() command )
  {
    _command = command;
  }
  
  public void until( bool delegate() condition )
  {
    do _command(); while( condition() );
  }
}

Repeater repeatLoop( void delegate() action ) { return new Repeater( action ); }

void meter(char[] name, void delegate() action)
{
  auto t = new HighPerformanceCounter();  
  
  t.start();
  action();
  t.stop(); 
  
  writefln(name,": ", t.milliseconds() ," ms elapsed ");
}

void main()
{
  auto LIMIT = 100000000;
  
  meter( "Simple do-while", { auto i = 0; do { i++; } while( i < LIMIT ); } );
  meter( "Repeat until", {auto i = 0; repeatLoop( { i++; } ).until( { return i < LIMIT; });} );
}