anchor.diff:  }
   
   /// Represents the configuration for applying an [ApplicationContinuation].
  -class ArgumentContinuationConfiguration extends Configuration {
  +class ExpressionListContinuationConfiguration extends Configuration {
     final ApplicationContinuation continuation;
  -  final List<ArgumentValue> argumentValues;
  -
  -  ArgumentContinuationConfiguration(this.continuation, this.argumentValues);
  -
  -  Configuration step(StatementExecuter _) => continuation(argumentValues);
  +  final List<InterpreterValue> values;
  +
  +  ExpressionListContinuationConfiguration(this.continuation, this.values);
  +
  +  Configuration step(StatementExecuter _) => continuation(values);
   }
   
   /// Represents the configuration for evaluating an [Expression].
  
positive.code:   Configuration eval(Expression expr, ExpressionConfiguration config) =>
        expr.accept1(this, config);
  
    Configuration evalArgs(List<ArgumentExpression> args, Environment env,
        ApplicationContinuation cont) {
      if (args.isNotEmpty) {
        return new ExpressionConfiguration(args.first.expression, env,
            new ActualArgumentsContinuation(args.first, args.skip(1), env, cont));
      }
      return new ArgumentContinuationConfiguration(cont, <ArgumentValue>[]);
    }
  
    Configuration defaultExpression(
  
negative.code:       statement.accept1(this, state);
    Configuration eval(Expression expression, ExpressionConfiguration config) =>
        evaluator.eval(expression, config);
    Configuration evalList(
            List<InterpreterExpression> es, Environment env, Continuation cont) =>
        evaluator.evalList(es, env, cont);
  
    Configuration defaultStatement(Statement node, State state) {
      throw notImplemented(
  