One of the key differences between the different Java inner class and closure proposals is the lexical scope of names, this blog compares the scoping of the major proposals (CICE + ARM, C3S, FCM + JCA, and BGGA in both its forms). The order in the comparison table below, from left to right, is how large a change is made to Java. There are two main change groups: CICE and C3S do not change the semantics of inner class methods, whereas FCM and BGGA do. All the proposals add syntactic changes to make the declaration of inner classes shorter. The comparison is similar to that given by Stephen Colebourne in his blog, but includes the inherited scope as well as the enclosing scope. (Stephen Colebourne was going to post the table below, or at least a similar one, on his blog but was travelling at the time.)

A more detailed comparison was given in a previous post, but the table below is a good summary of an important difference (lexical scope).

function test(){
  return function(){ 
    return 4 // return from the anonymous function or from test?
  }
}

func = test();
func();

def test
  callcc {|cc| return cc}
  return 4
end
 
func = test()
func.call()

def mystery(n)
  callcc do |cc| 
    return n > 0 ? cc : lambda{}, n
  end
  
  mystery(n-1)
end
 
go, n = mystery(5)
print n
go.call

method boolean test() {
  return !method { return false }
}

method boolean test() {
  return !method { test.return false }
}

method boolean test() {
  class Test$ReturnException extends ReturnException {
    Test$ReturnException( Boolean value ) { super( value ) }
  }
  try {
    return !method { throw new Test$ReturnException( false ) }
  } catch ( Test$ReturnException e ) {
    return (boolean)e.getValue()
  }
}

boolean test() {
  return !{=> false }
}

boolean test() {
  return !{=> return false; }
}

boolean test() {
  return !{=> false; }
}

boolean test() {
  return !{=> return false }
}

return !method{ return true }

x = method{ return true }; // a closure object
x.call(); // true

function test(){
  return !function(){ return false }
}

function test(){
  return !function(){ return false }() // note the two parens
}

static boolean test() {
  return !method { return false }.call()
}
 
or
 
static boolean test() {
  return not method { return false }
}
 
where not is:
 
static Boolean not( Predicate p ) {
  return !p.call()
}

method boolean test() {
  return method { test.return 4 }
}
 
x = test(); // returns a Closure object
x.call(); // what happens here?

method boolean test() {
  return method { test.return 4 }
}
 
x = test();
System.out.print("foo"); 
x.call();

method boolean test() {
>   return method { test.return 4 }
> }
> 
> x = test(); // returns a Closure object
> x.call(); // what happens here?

final test = Method0< Method0< Integer > >.method { // instance of an anonymous class
  return Method0< Integer >.method { return 4 } // instance of a second anonymous class
}
 
final x = test.call; // returns an instance of the second class (calls the class's constructor)
out.println x.call; // prints 4

int test() { // normal method
  return increment method { test.return 4 } // make new instance and execute when test is called
}
 
out.println test; // prints 4

enum FlipFlop implements Block {
  FLIP {
    method {
      out.print this;
      state = FLOP
    }
  },
  FLOP {
    method {
      out.print this;
      state = FLIP
    }
  };
  private static declare state = FLIP;
  public method void callcc() { state.call }
}

> final test = Method0< Method0< Integer > >.method { //
> instance of an anonymous class
> return Method0< Integer >.method { return 4 } //
> // instance of a second anonymous class
> }
> 
> final x = test.call; // returns an instance of the second
> class (calls the class's constructor)
> out.println x.call; // prints 4
> 

> final test = Method0< Method0< Integer > >.method { //
> instance of an anonymous class
> return Method0< Integer >.method { test.return 4 } //
> // instance of a second anonymous class
> }
> 
> final x = test.call; // returns an instance of the second
> class (calls the class's constructor)
> out.println x.call; // prints 4
> 

(defun test () (lambda () (return-from test 4)))
(funcall (test))
ERROR: attempt to RETURN-FROM a block or GO to a tag that no longer exists

> int test() { // normal method
> return increment method { test.return 4 } // make new
> ew instance and execute when test is called
> }
> 
> out.println test; // prints 4
> 

> enum FlipFlop implements Block {
>   FLIP {
>     method {
>       out.print this;
>       state = FLOP
>     }
>   },
>   FLOP {
>     method {
>       out.print this;
>       state = FLIP
>     }
>   };
>   private static declare state = FLIP;
>   public method void callcc() { state.call }
> }
> 

> > final test = Method0< Method0< Integer > >.method { //
> > instance of an anonymous class
> OK, so what happens if we do test.return instead of
> return:
> 
> > [java]
> > final test = Method0< Method0< Integer > >.method { //
> > instance of an anonymous class
> > return Method0< Integer >.method { test.return 4 } //
> > // instance of a second anonymous class
> > }
> > 
> > final x = test.call; // returns an instance of the
> second
> > class (calls the class's constructor)
> > out.println x.call; // prints 4
> > 

> > int test() { // normal method
> > return increment method { test.return 4 } // make new
> > ew instance and execute when test is called
> > }
> > 
> > out.println test; // prints 4
> > 

void callcc() {
  for (;;) {
    out.println( "FLIP" );
    yield;
    out.println( "FLOP" );
    yield;
  }
}

> void callcc() {
>   for (;;) {
>     out.println( "FLIP" );
>     yield;
>     out.println( "FLOP" );
>     yield;
>   }
> }
> 

method void test() {
  final thread = Thread.method run() { test.return }; // **Compile** time error, Thread.run does not throw test$ReturnException
  thread.start
}

static method< Throwable... Es > void callcc( final Block1< Block< Es >, Es > block, final Block< Es > continuation ) {
  block.call continuation;
}
 
callcc method( continuation ) {
  out.println "Before";
  continuation.call;
  out.println "Not reached"
}, method {
  callcc.return
};

callcc method( continuation ) {
  out.println "Outer";
  callcc method( continuation ) {
    out.println "Inner";
    continuation.call;
    out.println "Not reached"
  }, continuation;
  out.println "Back to outer"
}, method {
  callcc.return
};

> callcc method( continuation ) {
>   out.println "Outer";
>   callcc method( continuation ) {
>     out.println "Inner";
>     continuation.call;
>     out.println "Not reached"
>   }, continuation;
>   out.println "Back to outer"
> }, method {
>   callcc.return
> };
> 

callcc do |continuation|
  print "Outer"
  callcc do |continuation|
    print "Inner"
    continuation.call
    print "Not reached"
  end
  print "Back to outer"
end

callcc do |return|
  // if we do return.call(...) we jump to
end  // <-- here, and we return the value passed to call(...)
 
// So:
 
x = callcc do |return|
  return.call(3)
end
 
// x = 3 now
 

x = callcc do |return|
  return
end // x.call(something) goes to the end of this block, and puts something into x
 
puts "hi"
 
x.call(x) // go back to the end of the callcc block, putting x back into x again. 
// If we just used x.call(), then x would contain nil (null) on the next run, because x.call() is equivalent to x.call(nil).

> callcc do |continuation|
>   print "Outer"
>   callcc do |continuation|
>     print "Inner"
>     continuation.call
>     print "Not reached"
>   end
>   print "Back to outer"
> end

abstract class< T > Callcc {
  T value;
  private static class CallccReturn extends RuntimeException {}
  private static final premade = new CallccReturn();
  abstract method void first();
  method void exit() {}
  method void next() {}
  method void call() {
    try {
      first
    } catch ( CallccReturn notUsed ) {
      exit
    }
    next
  }
  method void callccReturn( final T value ) { 
    this.value = value;
    throw premade
  }
  method void callccReturn() { callccReturn null }
  method void callNext( final T value ) { 
    this.value = value;
    next
  }
  method void callNext() { repeatNext null }
}

final x = Callcc.method {
  callccReturn( 3 )
}
 
// x.value = 3 now
 

final x = Callcc.new {
  method {}
  method next {
    out.println "hi"
    callNext
  }
}

public class Callcc< T > {
  private static class CallccReturn extends RuntimeException {}
  private static final CallccReturn preMade = new CallccReturn();
  public T value = null;
  public void first() { callccContinue(); }
  public void iteration() {}
  public void repeatable() {}
  public final void callccContinue( final T value ) {
    this.value = value;
    throw preMade;
  }
  public final void callccContinue() { callccContinue( null ); }
  public Callcc< T > call() {
    try {
      first();
    } catch ( CallccReturn notUsed ) {
      iteration();
    }
    for ( ;; ) {
      try {
        repeatable();
        return this;
      } catch ( CallccReturn notUsed ) {
        iteration();
      }
    }
  }
  @Override public String toString() { return "Callcc[" + value + "]"; }
}

    // Return a value
    final x = Callcc< String >.new {
      method first { callccContinue "A" }
    }.call;
    out.println "x = " + x;
    
    // Close over a variable to return a result
    final is = String.new[ 3 ];
    Callcc< Void >.new {
      declare local = { "i", "ii", "iii" };
      method iteration { arraycopy local, 0, is, 0, local.length }
    }.call;
    out.println "is = " + Arrays.toString( is );
    
    // Repeat
    Callcc< Void >.new {
      int count = 1;
      method repeatable {
        out.println count;
        count++;
        if ( count <= 3 ) { callccContinue }
      }
    }.call;