anchor.diff:  /// argument for function invocation.
   /// TODO: Add checks for validation of arguments according to spec.
   class ActualArgumentsContinuation extends ExpressionContinuation {
  -  final Arguments arguments;
  -  final FunctionNode functionNode;
  -  final Environment environment;
  -  final ExpressionContinuation continuation;
  -
  -  final List<Value> _positional = <Value>[];
  -  int _currentPositional = 0;
  -  final Map<String, Value> _named = <String, Value>{};
  -  int _currentNamed = 0;
  -
  -  ActualArgumentsContinuation(
  -      this.arguments, this.functionNode, this.environment, this.continuation);
  +  final ArgumentExpression currentArgument;
  +  final List<ArgumentExpression> arguments;
  +  final Environment environment;
  +  final ApplicationContinuation applicationContinuation;
  +
  +  ActualArgumentsContinuation(this.currentArgument, this.arguments,
  +      this.environment, this.applicationContinuation);
   
     Configuration call(Value v) {
  -    if (_currentPositional < arguments.positional.length) {
  -      _positional.add(v);
  -      _currentPositional++;
  +    ArgumentValue argumentValue;
  +    if (currentArgument is NamedArgumentExpression) {
  +      argumentValue = new NamedArgumentValue(
  +          (currentArgument as NamedArgumentExpression).name, v);
       } else {
  -      assert(_currentNamed < arguments.named.length);
  -      String name = arguments.named[_currentNamed].name;
  -      _named[name] = v;
  -      _currentNamed++;
  -    }
  -
  -    return createCurrentConfiguration();
  -  }
  -
  -  Configuration createCurrentConfiguration() {
  -    // Next argument to evaluate is a provided positional argument.
  -    if (_currentPositional < arguments.positional.length) {
  -      return new ExpressionConfiguration(
  -          arguments.positional[_currentPositional], environment, this);
  -    }
  -    // Next argument to evaluate is a provided named argument.
  -    if (_currentNamed < arguments.named.length) {
  -      return new ExpressionConfiguration(
  -          arguments.named[_currentNamed].value, environment, this);
  -    }
  -
  -    // TODO: check if the number of actual arguments is larger then the number
  -    // of required arguments and smaller then the number of formal arguments.
  -
  -    return new OptionalArgumentsContinuation(
  -            _positional, _named, functionNode, environment, continuation)
  -        .createCurrentConfiguration();
  -  }
  -}
  -
  -class OptionalArgumentsContinuation extends ExpressionContinuation {
  -  final List<Value> positional;
  -  final Map<String, Value> named;
  -  final FunctionNode functionNode;
  -  final Environment environment;
  -  final ExpressionContinuation continuation;
  -
  -  final Map<String, VariableDeclaration> _missingFormalNamed =
  -      <String, VariableDeclaration>{};
  -
  -  int _currentPositional;
  -  String _currentNamed;
  -
  -  OptionalArgumentsContinuation(this.positional, this.named, this.functionNode,
  -      this.environment, this.continuation) {
  -    _currentPositional = positional.length;
  -    assert(_currentPositional >= functionNode.requiredParameterCount);
  -
  -    for (VariableDeclaration vd in functionNode.namedParameters) {
  -      if (named[vd.name] == null) {
  -        _missingFormalNamed[vd.name] = vd;
  -      }
  -    }
  -  }
  -
  -  Configuration call(Value v) {
  -    if (_currentPositional < functionNode.positionalParameters.length) {
  -      // Value is a optional positional argument
  -      positional.add(v);
  -      _currentPositional++;
  -    } else {
  -      // Value is a optional named argument.
  -      assert(named[_currentNamed] == null);
  -      named[_currentNamed] = v;
  -    }
  -
  -    return createCurrentConfiguration();
  -  }
  -
  -  /// Creates the current configuration for the evaluation of invocation a
  -  /// function.
  -  Configuration createCurrentConfiguration() {
  -    if (_currentPositional < functionNode.positionalParameters.length) {
  -      // Next argument to evaluate is a missing positional argument.
  -      // Evaluate its initializer.
  -      return new ExpressionConfiguration(
  -          functionNode.positionalParameters[_currentPositional].initializer,
  -          environment,
  -          this);
  -    }
  -    if (named.length < functionNode.namedParameters.length) {
  -      // Next argument to evaluate is a missing named argument.
  -      // Evaluate its initializer.
  -      _currentNamed = _missingFormalNamed.keys.first;
  -      Expression initializer = _missingFormalNamed[_currentNamed].initializer;
  -      _missingFormalNamed.remove(_currentNamed);
  -      return new ExpressionConfiguration(initializer, environment, this);
  -    }
  -
  -    Environment newEnv = _createEnvironment();
  -    State bodyState = new State.initial()
  -        .withExpressionContinuation(continuation)
  -        .withConfiguration(new ExitConfiguration(continuation))
  -        .withEnvironment(newEnv);
  -
  -    return new StatementConfiguration(functionNode.body, bodyState);
  -  }
  -
  -  /// 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.
  -  Environment _createEnvironment() {
  -    Environment newEnv = new Environment.empty();
  -    // Add positional parameters.
  -    for (int i = 0; i < positional.length; ++i) {
  -      newEnv.expand(functionNode.positionalParameters[i], positional[i]);
  -    }
  -    // Add named parameters.
  -    for (VariableDeclaration v in functionNode.namedParameters) {
  -      newEnv.expand(v, named[v.name.toString()]);
  -    }
  -
  -    return newEnv;
  +      assert(currentArgument is PositionalArgumentExpression);
  +      argumentValue = new PositionalArgumentValue(v);
  +    }
  +
  +    return new ArgumentsConfiguration(arguments, environment,
  +        new ArgumentValueApplication(argumentValue, applicationContinuation));
     }
   }
   
  
positive.code:       executer.eval(expression, this);
  }
  
  /// Represents an expression continuation.
  abstract class ExpressionContinuation {
    Configuration call(Value v);
  }
  
  
negative.code:       statement.accept1(this, state);
    Configuration eval(Expression expression, ExpressionConfiguration config) =>
        evaluator.eval(expression, config);
    Configuration evalArgs(
            List<ArgumentExpression> args, Environment env, Continuation cont) =>
        evaluator.evalArgs(args, env, cont);
  
    Configuration defaultStatement(Statement node, State state) {
      throw notImplemented(
  