def foo
  callcc do |cc| 
    $k = cc # set global variable
    return 1
  end
  return 4
end
 
print foo() # 1
$k.call() # 4, 4, 4, 4, 4 (goes back to the previous line and returns from foo() again. The value returned from foo is passed to print() again)

    Callcc< Integer >.new {
        method iteration { value = ( value == null ) ? 1 : ( value + 1 ) }
        method repeatable {
          out.println value;
          if ( value < 3 ) { callccContinue }
        }
      }.call();

    Callcc< Integer >.new {
        method iteration { value = ( value == null ) ? 1 : 4 }
        method repeatable {
          out.println value;
          callccContinue
        }
      }.call();

a = choose(1, 2, 3, 4, 5, 6)
b = choose(1, 2, 3, 4, 5, 6)
 
assert(a + b == 7) # try other numbers if a + b != 7
 
print a, b # will only print a's and b's that sum to 7
 
assert(false) # next possibility

def foo(x)
  a = choose(*(0..x))
  b = choose(*(0..x))
  assert(a + b == 7)
  return [a,b]
end
 
a, b = foo(6)
 
print a, b
 
assert(false) # next one

def only_primes(x)
  assert(x.prime?)
end
 
def only_pythagorean_triples(a, b, c)
  assert(a**2 + b**2 == c**2)
end
 
def three_numbers_upto(x)
  return [choose(*(0..x)), choose(*(0..x)), choose(*(0..x))]
end
 
a, b, c = three_numbers_upto(100)
 
only_primes(a) # try again if a isn't prime
 
only_pythagorean_triples(a, b, c) # try again if a, b, c is not a pythagorean triple
 
print a, b, c # here we have a pythagorean triple a, b, c, and a is prime.

public class Amb< R, A > extends Callcc< R > {
  public final Method0< A >[] methods;
  
  private int index = 0;
  
  public Amb( final Method0< A >... methods ) { this.methods = methods; }
  
  public final A next() throws AmbException {
    while ( index < methods.length ) { 
      try {
        return methods[ index++ ].call();
      } finally {
        // Try next method
      }
    }
    throw new AmbException();
  }
  
  public final void fail() { callccContinue(); }
  
  @Override public String toString() { return "Amb[" + value + "]"; }
}

    final angelic = Amb< Integer, Boolean >.new( method { false }, method { true } ) {
        method repeatable {
          if ( next ) { value = 1 }
          else { fail }
        }
      }.call;

    final range = Method0< Integer >.new[] { method { 0 }, method { 1 }, method { 2 }, method { 3 } };
    final outer = t (Amb< Integer, Integer >)null; // Forward declaration, t makes a tuple
    outer.e1 = Amb< Integer, Integer >( range ).new {
        method repeatable {
          value = next;
          final inner = Amb< Integer, Integer >.new( range ) {
              method repeatable {
                value = next;
                if ( outer.e1.value + value == 3 ) { out.println "Found: " + outer.e1 + " + " + this + " = 3" }
                fail; // Repeat inner loop
              }
            };
          try {
            inner.call; // Start inner loop
          } catch ( AmbException notUsedInner ) {
            // End inner loop
          }
          fail; // Repeat outer loop
        }
      };
    try {
      outer.e1.call; // Start outer loop
    } catch ( AmbException notUsedOuter ) {
      // End outer loop
    }

def foo
  x = choose(1,2,3)
  return x
end

static final x = Choose.new( 1, 2, 3 );
method Integer foo { x.next }

x = foo()
y = foo()
 
print x, y
 
fail

    abstract class Foo extends Choose< Character > {
      new { super 'a', 'b' }
    }
    class X extends Foo {
      method {
        Foo.method {
            out.println "Foos: " + X.this.value + " and " + value;
            fail X.this // Repeat all combinations
          }.startChooseLoop // Start inner loop
      }
    }
    X.new.startChooseLoop // Start outer loop
  }

a = [foo(), foo()]

[1,1]
[1,2]
...
[3,3]

def bar()
  (1..foo()).map{foo()}
end

[1]
[2]
[3]
[1,1]
[1,2]
...
[3,3]
[1,1,1]
[1,1,2]
...
[3,3,3]

# amb lib
 
$fail = lambda { fail "No solution found." }
 
def choose(*choices)
  prev_fail = $fail
 
  callcc do |ret|
    for choice in choices
      callcc do |next|
        $fail = next
        ret.call(choice)
      end
    end
 
    prev_fail.call()
  end
end
 
def assert(x)
  choose if !x
end
 
# end of amb lib
 
def country
  choose(:red, :blue, :yellow, :green)
end
 
def adjacent(country1, country2)
  assert(country1 != country2)
end
 
netherlands = country
belgium = country
france = country
spain = country
portugal = country
germany = country
luxemburg = country
switzerland = country
austria = country
italy = country
 
adjacent(netherlands, belgium)
adjacent(netherlands, germany)
adjacent(belgium, france)
adjacent(belgium, germany)
adjacent(belgium, luxemburg)
adjacent(france, spain)
adjacent(france, germany)
adjacent(france, italy)
adjacent(france, luxemburg)
adjacent(france, switzerland)
adjacent(spain, portugal)
adjacent(germany, switzerland)
adjacent(germany, luxemburg)
adjacent(germany, austria)
adjacent(switzerland, austria)
adjacent(switzerland, italy)
adjacent(austria, italy)
 
puts "netherlands: #{netherlands}"
puts "belgium: #{belgium}"
puts "france: #{france}"
puts "spain: #{spain}"
puts "portugal: #{portugal}"
puts "germany: #{germany}"
puts "luxemburg: #{luxemburg}"
puts "switzerland: #{switzerland}"
puts "austria: #{austria}"
puts "italy: #{italy}"

netherlands: red
belgium: blue
france: red
spain: blue
portugal: red
germany: yellow
luxemburg: green
switzerland: blue
austria: red
italy: yellow