persistable sclass PStack is Steppable {
  settable new ProbabilisticScheduler scheduler;
  settable bool verbose;
  
  sclass NoOptionsException extends RuntimeException {}
  
  <A> *(VStack.Computable<A> computable) { add(computable); }
  
  srecord noeq ExecuteOption(IVF1 option) is VStack.Computable {
    public void step(VStack stack, O subComputationResult) {
      O target = stack.caller();
      stack.return();
      option.get(target);
    }
  }
  
  class SingleStack extends VStack is IPStack, Runnable {
    double probability = 1.0;
    
    *() {}
    *(VStack.Computable computable) { super(computable); }
    
    run {
      if (verbose) print("Stepping " + last(stack));
      if (step() && !isEmpty()) {
        if (verbose) print("Re-scheduling at " + probability + ": " + last(stack));
        // re-add myself to scheduler to continue
        scheduler.add(probability, this);
      }
    }
    
    // give each option the probability 1/n (with n=number of options)
    public <B extends VStack.Computable> void options(B function, Iterable<IVF1<B>> options) {
      L<IVF1<B>> optionsList = nonNulls(options);
      
      if (empty(optionsList))
        throw new NoOptionsException;
        
      // probability penalty according to number of options
      probability = probability/l(optionsList);
      
      // Schedule all options except first in cloned stacks
      int n = l(optionsList)-1;
      for (int i = 0; i < n; i++) {
        new SingleStack s;
        s.stack = shallowCloneElements(stack);
        s.push(new ExecuteOption(optionsList.get(i)));
        s.probability = probability;
        scheduler.at(probability, s);
      }
      
      // Last option is executed in same stack
      push(new ExecuteOption(last(optionsList));
    }
    
    // give each option its own probability
    public <B extends VStack.Computable> void probabilisticOptions(B currentFrame, Iterable<WithProbability<IVF1<B>>> options) {
      L<WithProbability<IVF1<B>>> optionsList = nonNulls(options);
      
      if (empty(optionsList))
        throw new NoOptionsException;
        
      // Schedule all options except first in cloned stacks
      int n = l(optionsList)-1;
      for (int i = 0; i < n; i++) {
        new SingleStack s;
        s.stack = shallowCloneElements(stack);
        var option = optionsList.get(i);
        s.push(new ExecuteOption(option!));
        s.probability = probability*option.probability();
        scheduler.at(s.probability, s);
      }
      
      // Last option is executed in same stack
      var option = last(optionsList);
      probability *= option.probability();
      push(new ExecuteOption(option!));
    }
  }
  
  srecord noeq FollowUp<A>(VStack.Computable<A> computable, IVF1<A> onCompletion) extends PStackComputableWithStep {
    // !customConstructor
    *(VStack.Computable<A> *computable, IVF1<A> *onCompletion) {
      probability = getProbability(computable);
    }
    
    void step(IPStack stack) {
      if (step == 0) {
        stack.push(computable);
        ++step;
      } else {
        onCompletion.get((A) stack.subResult());
        stack.return();
      }
    }
  }
  
  // also takes a PStackComputable
  void add(VStack.Computable computable) {
    scheduler.at(getProbability(computable), new SingleStack(computable));
  }
  
  // also takes a PStackComputable
  <A> void add(VStack.Computable<A> computable, IVF1<A> onCompletion) {
    if (onCompletion != null)
      add(new FollowUp<>(computable, onCompletion));
    else
      add(computable);
  }
  
  public bool step() { ret scheduler.step(); }
  meta-for run also as runWithStats {
    public void run() { scheduler.run(); }
    void run(VStack.Computable computable) { add(computable); run(); }
  }
  
  static double getProbability(VStack.Computable computable) {
    ret computable cast PStackComputable ?
      computable.probability : 1.0;
  }
}