anchor.diff:    Configuration eval(Expression expr, ExpressionConfiguration config) =>
         expr.accept1(this, config);
   
  -  Configuration evalArgs(List<ArgumentExpression> args, Environment env,
  +  Configuration evalList(List<InterpreterExpression> list, 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>[]);
  +    if (list.isNotEmpty) {
  +      return new ExpressionConfiguration(list.first.expression, env,
  +          new ExpressionListContinuation(list.first, list.skip(1), env, cont));
  +    }
  +    return new ExpressionListContinuationConfiguration(
  +        cont, <InterpreterValue>[]);
     }
   
     Configuration defaultExpression(
  
positive.code:   }
  }
  
  /// Represents the application continuation called after the evaluation of all
  /// argument expressions for an invocation.
  class ArgumentValueApplication extends ApplicationContinuation {
    final ArgumentValue value;
    final ApplicationContinuation applicationContinuation;
  
    ArgumentValueApplication(this.value, this.applicationContinuation);
  
    Configuration call(List<ArgumentValue> args) {
      args.add(value);
      return new ArgumentContinuationConfiguration(applicationContinuation, args);
    }
  }
  
  
negative.code: /// Represents the continuation called after the evaluation of argument
  /// expressions.
  abstract class ApplicationContinuation extends Continuation {
    Configuration call(List<InterpreterValue> values);
  
    /// Creates an environment binding actual argument values to formal parameters
    /// of the function in a new environment, which is used to execute the
    /// body od the function.
    /// TODO: Add checks for validation of arguments according to spec.
    static Environment createEnvironment(
        FunctionNode function, List<InterpreterValue> args) {
      Environment newEnv = new Environment.empty();
      List<PositionalArgumentValue> positional = args.reversed
          .where((InterpreterValue av) => av is PositionalArgumentValue)
          .toList();
  
      // Add positional parameters.
  