{
  def f() : int { return 42; }
  def delay(function f) { return f; }
  def force(function f) { return f(); }
  write_int(force(delay(f)));
}

(define (memo-proc proc)
  (let ((already-run? false) (result false))
    (lambda ()
      (if (not already-run?)
          (begin (set! result (proc))
                 (set! already-run? true)
                 result)
          result))))

class memo_proc {
  public {
    _init(function f) {
      mf = f;
      mb = false;
    }
    _call(list l) {
      if (!mb) {
        mo = mf(l);
      }
      return mo;
    }
  }
  fields {
    object mo;
    function mf;
    bool b;
  }
}
 
def f() : int { 
  return 42; 
}
def g(function f1, function f2) : int { 
  return f1() + f2(); 
}
 
memo_proc mp(f);
g(mp, mp);

class Test
{
   int x;
 
   void F() {
      int y = 123;
      for (int i = 0; i < 10; i++) {
         int z = i * 2;
         D d = delegate { Console.WriteLine(x + y + z); };
      }
   }
}

class Test
{
   void F() {
      __locals1 = new __Locals1();
      __locals1.__this = this;
      __locals1.y = 123;
      for (int i = 0; i < 10; i++) {
         __locals2 = new __Locals2();
         __locals2.__locals1 = __locals1;
         __locals2.z = i * 2;
         D d = new D(__locals2.__Method1);
      }
   }
 
   class __Locals1
   {
      public Test __this;
      public int y;
   }
 
   class __Locals2
   {
      public __Locals1 __locals1;
      public int z;
 
      public void __Method1() {
         Console.WriteLine(__locals1.__this.x + __locals1.y + z);
      }
   }
}

package innerclasses;
 
public class Main {
    
    interface Timeable< R > { public R time(); }
    
    static < R > void timeOnce( final Timeable< R > t ) {
        System.gc();
        System.gc();
        final long start = System.currentTimeMillis();
        final R r = t.time();
        final long finish = System.currentTimeMillis();
        System.out.println( "time taken = " + (finish - start) + " ms" + ", result = " + r );
    }
    
    static < R > void time( final Timeable< R > t ) {
        System.out.println( t );
        System.out.print( "run 1: " );
        timeOnce( t );
        System.out.print( "run 2: " );
        timeOnce( t );
    }
    
    static final long times = 1000000000;  /* times round loop for timing */
    
    static class LongHolder { long v; }
    
    void inc( final LongHolder l ) { l.v++; } // delegate method
    
    interface Inner { void inc(); } // adaptor interface to give the method a name
    
    public static void main( final String[] notUsed ) {
        time( new Timeable< Long >() {
            public String toString() { return "Delegate - as optimum as possible since method names match"; }
            public Long time() {
                final Main delegate = new Main(); // delegate method name not needed in this example since it matches already - see comment below
                final LongHolder l = new LongHolder();
                l.v = 0L;
                for ( long count = 1; count < times; count++ ) delegate.inc( l ); // in a real delegate call the name would not have to be the same - just the signature
                return l.v;
            }
        } );
        time( new Timeable< Long >() {
            public String toString() { return "Inner class"; }
            public Long time() {
                final LongHolder l = new LongHolder();
                l.v = 0L;
                final Inner inner = new Inner() { public void inc() { l.v++; } }; // inner class
                for ( long count = 1; count < times; count++ ) inner.inc();
                return l.v;
            }
        } );
        time( new Timeable< Long >() {
            public String toString() { return "No delegate or inner class, but still heap allocation"; }
            public Long time() {
                final LongHolder l = new LongHolder();
                l.v = 0L;
                for ( long count = 1; count < times; count++ ) l.v++;
                return l.v;
            }
        } );
        time( new Timeable< Long >() {
            public String toString() { return "No delegate, no inner class, and no heap allocation - baseline comparison"; }
            public Long time() {
                long l = 0L;
                for ( long count = 1; count < times; count++ ) l++;
                return l;
            }
        } );
    }
    
}

Delegate - as optimum as possible since method names match
run 1: time taken = 10656 ms, result = 999999999
run 2: time taken = 6439 ms, result = 999999999
Inner class
run 1: time taken = 8072 ms, result = 999999999
run 2: time taken = 5678 ms, result = 999999999
No delegate or inner class, but still heap allocation
run 1: time taken = 5668 ms, result = 999999999
run 2: time taken = 6479 ms, result = 999999999
No delegate, no inner class, and no heap allocation - baseline comparison
run 1: time taken = 4857 ms, result = 999999999
run 2: time taken = 4857 ms, result = 999999999