sclass VStack is Steppable, IVStack {

  new L<Computable> stack;

  O latestResult;

  transient O newResult;

  // the null sentinel replaces a null function result

  // when stored in latestResult

  sclass NullSentinel {}

  static new NullSentinel nullSentinel;

  *() {}

  *(Computable computation) { push(computation); }

  *(Iterable<Computable> l) { pushAll(l); }

  // A is what the function returns

  interface Computable<A> {

    public void step(VStack stack, O subComputationResult);

  }

  private O deSentinel(O o) {

    ret o instanceof NullSentinel ? null : o;

  }

  private O sentinel(O o) {

    ret o == null ? nullSentinel : o;

  }

  // called by computations or users to start a subroutine

  public void push(Computable computation) {

    stack.add(assertNotNull(computation));

  }

  // perform a computation step. returns false iff done

  public bool step() {

    if (empty(stack)) false;

    newResult = null;

    last(stack).step(this, result());

    latestResult = newResult;

    newResult = null;

    true;

  }

  // called from a computation to return a value

  public void _return(O value) {

    newResult = sentinel(value);

    pop();

  }

  // called from a computation to tail-call another routine

  public void tailCall aka replace(Computable computation) {

    pop();

    stack.add(computation);

  }

  // all-in-one evaluation function - call on an empty stack 

  <A> A compute(Computable<A> computation) {

    if (computation == null) null;

    push(computation);

    stepAll(this);

    ret (A) latestResult;

  }

  // return result of just completed computation or sub-computation

  public O result aka subResult() {

    ret deSentinel(latestResult);

  }

  bool hasSubResult() { ret latestResult != null; }

  void pushAll(Iterable<Computable> l) {

    fOr (Computable c : l)

      push(c);

  }

  void add(Runnable r) {

    if (r == null) ret;

    push((stack, subComputationResult) -> r.run());

  }

  // caller of current function

  Computable caller() {

    ret nextToLast(stack);

  }

  protected void pop() {

    removeLast(stack);

  }

  bool isEmpty() { ret empty(stack); }

}