// A represents the return type of the backtrackable main computation
sclass BStack_v2<A> extends VStack {
  static int idCounter;
  int stackID = ++idCounter; // for debugging
  
  // cloned version made at last branch point
  BStack_v2<A> snapshot;
  
  // remaining options at last branch point
  Iterator<IVF1<?>> options;
  
  // steps to undo before switching to the alternative
  L<AutoCloseable> undos;
  
  *() {}
  *(Computable<A> computation) { push(computation); }
  *(Iterable<Computable> l) { pushAll(l); }
  
  sclass NoOptionsException extends RuntimeException {}
  
  BStack_v2<A> cloneStack() {
    new BStack_v2<A> s;
    s.snapshot = snapshot;
    s.options = options;
    s.undos = undos;
    s.stack = shallowCloneElements(stack);
    ret s;
  }
  
  void addUndo aka temp(AutoCloseable undo) {
    if (undo == null) ret;
    if (undos == null) undos = new L;
    undos.add(undo);
  }
  
  <B extends VStack.Computable> void options(B function,
    IVF1<B>... options) {
    options(function, asList(options));
  }
    
  <B extends VStack.Computable> void options(B function, Iterable<IVF1<B>> options) {
    Iterator<IVF1<B>> iterator = nonNullIterator(iterator(options));
    
    if (!iterator.hasNext())
      throw new NoOptionsException;
      
    IVF1<B> firstOption = iterator.next();
    
    // All options except first are stored as alternatives
    // in cloned stacks.
    
    setOptions(iterator);

    // Execute the first option
    firstOption.get(function);
  }
  
  srecord noeq ExecuteOption(IVF1 option) is VStack.Computable {
    public void step(VStack stack, O subComputationResult) {
      O target = stack.caller();
      stack.return();
      option.get(target);
    }
  }
  
  <B> void setOptions(Iterator<IVF1<B>> options) {
    snapshot = cloneStack();
    this.options = options;
    undos = null;
  }
  
  // Try to backtrack one step and return a new stack
  // Returns null if no backtracking possible
  BStack_v2<A> backtrack() ctex {
    // Apply undos in reverse order
    for (int i = l(undos)-1; i >= 0; i--)
      undos.get(i).close();
        
    if (options == null || !options.hasNext()) null;
    BStack_v2<A> stack = snapshot;
    snapshot.push(new ExecuteOption(options.next()));
    ret snapshot;
  }
  
  A nextResult() {
    stepAll(this);
    return (A) latestResult;
  }
  
  // calculate next result and print stack at every step
  A nextResultWithPrintStruct(long maxSteps) {
    stepMaxWithPrintIndentedStruct(this, maxSteps);
    return (A) latestResult;
  }
}