int foo(){
  {x => return x}.invoke(10); // anonymous function has type int -> void.
  bar(); // will not be executed!
}
 
===
 
int foo(){
  return {x => x}.invoke(10) // anonymous function has type int -> int.
  bar(); // will not be executed!
}

executor.execute( { => ...; } ); // OK

{ => void } toBeRun = { => ...; };
executor.execute( toBeRun ); // Oops

{ int => int } factorial = { x => x <= 1 ? 1 : x * factorial( x - 1 ) };

int foo(){
  Bar x = new Bar();
  x.setQ({z => return z;});
  x.callQ(3);
}

collection1.each(theClosure);
collection2.each(theClosure);

theClosure = {x => if(x==theElement){return true}};

static <T> boolean isKeyPresent( List<T> list, T key ) {
  Collections.each( list, {T x => if ( x.equals( key ) ) return true; } );
  return false;
}

static <T> boolean isKeyPresent( List<T> list, T key ) {
  class IsKeyPresent$Return extends ReturnException {}
  final IsKeyPresent$Return isKeyPresent$Return = new IsKeyPresent$Return();
  try {
    Collections.each( list, {T x => if ( x.equals( key ) ) { 
      isKeyPresent$Return.setValue( Boolean.True );
      throw isKeyPresent$Return; 
    } );
    return false;
  } catch (IsKeyPresent$Return notUsed) {
    return (boolean) isKeyPresent$Return.getValue();
  }
}

int foo(){
  if(this.isFirstCall){
    this.callMeLater = {x => return x;};
    this.isFirstCall = false;
  }else{
    this.callMeLater.invoke(2);
  }
  return 3;
}
 
...
 
foo();
foo();

class Foo
  def initialize
    @is_first_call = true
  end
  
  def bar
    if @is_first_call
      puts "First"
      @call_me_later = proc { | x | return x }
      @is_first_call = false
    else
      puts "Rest"
      puts @call_me_later.call( 2 )
    end
    return 1
  end
end
 
foo = Foo.new
puts "One"
puts foo.bar
puts "\nTwo"
puts foo.bar
puts "\nFinish"

One
First
1

Two
Rest
2
1

Finish

lambda {
  if foo
     1
  else
     2
  end
}.call # returns 1 or 2

{x =>
  if(foo){
     1;
  }else{
     2;
  }
}.invoke

{ =>
  if(foo){
     return 1;
  }else{
     return 2;
  }
}.invoke

{ =>
  int temp;
  if(foo){
     temp = 1;
  }else{
     temp = 2;
  }
  temp
}.invoke