sclass SimpleInterpreter {

  sclass State {

    new LinkedHashMap<S, O> vars;

    new L stack;

    selfType set(S var, O value) {

      vars.put(var, value);

      this;

    }

    O eval(Instruction i) {

      i.run(this);

      ret pop();

    }

    <A> A eval(Evaluable<A> e) {

      ret e?.get(this);

    }

    O get(S var) { ret mapGet(vars, var); }

    void push(O value) { stack.add(value); }

    O pop() { ret popLast(stack); }

  }

  asclass Instruction {

    abstract void run(State state);

  }

  sinterface Evaluable<A> {

    A get(State state);

  }

  /*srecord Const(O value) > Instruction {

    void run(State state) {

      state.push(value);

    }

  }*/

  srecord Const<A>(A value) implements Evaluable<A> {

    public A get(State state) {

      ret value;

    }

  }

  srecord Sequence(L<Instruction> l) > Instruction {

    Sequence(Instruction... l) { this.l = asList(l); }

    void run(State state) {

      fOr ping (Instruction i : l)

        i.run(state);

    }

  }

  srecord GetVar(Evaluable<S> var) > Instruction {

    void run(State state) {

      state.push(state.get(state.eval(var)));

    }

  }

  srecord CallF(Evaluable f, Evaluable... args) > Instruction {

    void run(State state) {

      O realF = state.eval(f);

      O[] realArgs = mapToArray(args, a -> state.eval(a));

      state.push(safeCallF(realF, realArgs));

    }

  }

  State newState() { ret new State; }

}